Arquillian

Arquillian Drone Extension 1.2.0.Alpha2 Released

2013-05-04T00:00:00Z

The Arquillian team is proud to announce the 1.2.0.Alpha2 release of the Arquillian Drone Extension component!

We’ve please to announce Drone 1.2.0.Alpha2. This release brings you PhantomJS support and an easier model for future extensions.

Significant changes since 1.2.0.Alpha1

Support for PhantomJS

PhantomJS allow you to run headless tests on a real browser. And Drone supports it out of the box.

arquillian.xml

<extension qualifier=“webdriver”>

          <property name=“browserCapabilities”>phantomjs</property>

          <property name=“phantomjs.binary.path”>/path/to/phantomjs.binary</property>

      </extension>

Automatic Augmentation: RemoteWebDriver instances are now automatically augmented.

Discarding cookies for reusable browsers

You can now use reusable browser while ensuring cooking from previous test runs do not affect current test run. The default behavior is to delete the cookies. If you want to preserve previous behavior, you can use the reuseCookies configuration option.

arquillian.xml

<extension qualifier=“webdriver”>

          <property name=“reuseCookies”>true</property>

      </extension>

This release breaks implementation compatibility with previous Drone releases. You should not be affected by this unless you use Drone combined with other projects that depend on more then just SPI, such as Graphene 2. We are releasing new compatible versions of these projects; such as Graphene 2.0.0.Alpha4.
These changes were done in order to make Drone more reusable by third party projects to avoid similar problems in future.

I’d like to thank everybody involved in this release. You guys make testing a breeze!

We hope that you’ll enjoy the improvements and look forward to hear your feedback in the community forums.

What is Arquillian?

Arquillian is open source software that empowers you to test JVM-based applications more effectively. Created to defend the software galaxy from bugs, Arquillian brings your test to the runtime so you can focus on testing your application's behavior rather than managing the runtime. Using Arquillian, you can develop a comprehensive suite of tests from the convenience of your IDE and run them in any IDE, build tool or continuous integration environment.

Release details

Component	Arquillian Drone Extension
Version	1.2.0.Alpha2 view tag
Release date	2013-04-12
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 11

PhantomJS; Automatic Augmentation; Discarding cookies for reusable browsers

Component Upgrade

ARQ-1308 - Update Selenium to 2.30.0
ARQ-1310 - Update Arquillian Core in Drone to 1.0.3.Final
ARQ-1349 - Drone: upgrade Selenium to 2.31.0 and phantomjsdriver to 1.0.3

Enhancement

ARQ-1314 - Better exception message when creating a new instance fails
ARQ-1350 - Drone: allow reuse of session even though all capabilities are not serializable

Feature Request

ARQ-1177 - Allow browser capabilities to be extensible
ARQ-1206 - Add configuration option to delete all cookies on reusable browser instance
ARQ-1307 - Support for GhostDriver / PhantomJS
ARQ-1351 - Drone: augment RemoteWebDriver instances automatically
ARQ-1363 - Drone SPI - provide service type for enhancing a instances instantiated by Drone
ARQ-1364 - Drone SPI - add DroneReady event fired when either class or method-level instance is created

Thanks to the following list of contributors: Lukas Fryc, Karel Piwko, Tomas Repel, Jiří Locker, Jan Papoušek, Aslak Knutsen

Arquillian Container GlassFish 1.0.0.CR4 Released

2013-05-03T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.CR4 release of the Arquillian Container GlassFish component!

What is Arquillian?

Release details

Component	Arquillian Container GlassFish
Modules	Arquillian GlassFish Managed 3.1 Container Adapter Arquillian GlassFish Remote 3.1 Container Adapter Arquillian GlassFish Embedded 3.1 Container Adapter
Version	1.0.0.CR4 view tag
Release date	2013-04-29
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.container

org.jboss.arquillian.container » arquillian-glassfish-common jar pom
org.jboss.arquillian.container » arquillian-glassfish-embedded-3.1 jar pom
org.jboss.arquillian.container » arquillian-glassfish-managed-3.1 jar pom
org.jboss.arquillian.container » arquillian-glassfish-remote-3.1 jar pom

Release notes and resolved issues 8

GlassFish 4

Bug

ARQ-837 - Managed GlassFish container does not shutdown correctly in a Maven build
ARQ-856 - Embedded GlassFish adapter may use an incorrect HTTP port when a custom domain configuration XML file is used
ARQ-1232 - Random "contextRoot must not be null" failures thrown by Arquillian on deployment to GlassFish

Enhancement

ARQ-796 - Remove the GlassFishRestDeploymentAppender from the GlassFish container adapter
ARQ-923 - Delete temporary instance root for Embedded GlassFish on exit
ARQ-1211 - Revisit the allowConnectToRunningServer flag for managed containers

Feature Request

ARQ-1293 - Add Support for GlassFish 4.x series

Thanks to the following list of contributors: Vineet Reynolds, Dan Allen, Aslak Knutsen, JJ Snyder

Graphene 2.0.0.Alpha4 Released

2013-04-25T00:00:00Z

The Arquillian team is proud to announce the 2.0.0.Alpha4 release of the Graphene component!

As we are on the way to a first Beta release, we identified a need for sharing some of the recent Graphene improvements:

Highlighted Changes

Guard Improvements and Fixes: Request Guards were polished, extended and hardened. (read more)

Creating Page Fragments Programatically: Page Fragments can now be instantiated not only using dependency injection, but also programatically. (read more)

PhantomJS Support: You can now fully leverage awesomness of headless testing with PhantomJS.

Guarding Programatically Retrieved Elements: Elements retrieved programatically using WebElement#findElement(...) or WebElement#findElements(...) are now guarded against StaleElementReferenceException.

Automatic Inference of Locators: You no longer need to define a locator in simple forms – you can leverage their automatic inference from a injection point name. (read more)

Dependency Injection of SessionStorage and LocalStorage: These resources are now exposed directly via @ArquillianResource.

Dependency Injection of Selenium Resource Parametrized by WebElement: Selenium resources which takes WebElement as an argument in a constructor (e.g. Select) can be injected using FindBy.

Support for FindBys and FindBy(How, String)

Improved Integration with Drone: Drone 1.2.0.Alpha2’s new Enhancer API allow us to integrate with Drone seamlessly.

Deprecations

Deprecation of Old Variant of Waiting Fluent API: Graphene.element(...) and Graphene.attribute(...) are now deprecated and they will be removed in an upcoming releases.

Deprecated guardXhr replaced by guardAjax: Not all of us are familiar with abbreviation XHR (XMLHttpRequest). In order to make the API more clear for most of Graphene users, we have deprecated guardXhr and replaced it with guardAjax. guardXhr will be removed in upcoming releases.

Guard Improvements and Fixes

waitForHttp: When an Ajax request is followed by a relocation (HTTP request), guardXhr or guardHttp can’t deterministically wait for an end of a request – in these situations you can use waitForHttp instead.

Testing delayed requests: Guards now waits for a given time interval for a request to start and once the request is started, they wait the another interval for the request to finish.

Bug Fixes: Guards had problems on Android with deterministic waiting for HTTP requests.

Creating Page Fragments Programatically

Till this release, the only option to create a page fragment was injecting it:

@FindBy(...)
      MyComponent component;

With Alpha4 we have added the possibility to create a page fragment programatically:

public <T> T getContent(Class<T> clazz) {
          return PageFragmentEnricher.createPageFragment(clazz, root);
      }

@Test
      public void testTabPanelSwitching() {
          Panel tab3 = tabPanel.switchTo(2);
          ContentOfTab content = tab3.getContent(ContentOfTab.class);
          assertEquals("The tab panel was not switched to third tab correctly!", "Content of the tab 3", content.text.getText());
          
          Panel tab1 = tabPanel.switchTo(0);
          content = tab1.getContent(ContentOfTab.class);
          assertEquals("The tab panel was not switched to first tab correctly!", "Content of the tab 1", content.text.getText());
      }

You can find reference usage in this functional test together with an implementation of #getContent(Class<T>).

Automatic Inference of Locators

How many times you have written:

// look for input with a name 'firstname'
      @FindBy(name = "firstname")
      private WebElement firstname;

You can now simplify your tests to just

@FindBy
      private WebElement firstname;

Graphene will automatically use the strategy How.ID_OR_NAME to locate the element by its ID or name.

Since this mechanism uses the strategy pattern, you can overwrite the default strategy for your test suite and therefore find elements by e.g. their class names or even JSF component IDs.

Roadmap

This release is a maintanance release on the way to Beta1.

What is Arquillian?

Release details

Component	Graphene
Version	2.0.0.Alpha4 view tag
Release date	2013-04-12
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.graphene

org.jboss.arquillian.graphene » graphene-build-resources jar pom
org.jboss.arquillian.graphene » graphene-component-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-drone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-ftest jar pom
org.jboss.arquillian.graphene » graphene-webdriver-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-spi jar pom

Release notes and resolved issues 20

Q1/13: PhantomJS

Bug

ARQGRA-257 - Guards are not working with AndroidDriver
ARQGRA-262 - Element click with HTTP guard causes WebDriverException: ReferenceError: Graphene is not defined
ARQGRA-266 - Waiting for presence of element defined by jQuery selector sometimes causes "IllegalStateException: JQueryPageExtension can't be installed"
ARQGRA-272 - Introduced waitForHttp (guardXhr does not work for redirected pages)
ARQGRA-274 - The request guard does timeout for delayed requests
ARQGRA-289 - JavaScript interfaces fails on Chrome and PhantomJS
ARQGRA-290 - testAttributeIsPresent fails on Chrome and PhantomJS

Enhancement

ARQGRA-199 - Provide a way to create Page Fragments dynamically
ARQGRA-235 - Automatically infer ID locator from field name annotated just by @FindBy
ARQGRA-250 - Shortcut for waiting on element's attribute value

Feature Request

ARQGRA-220 - Locating elements with @FindBy(how = How.ID, using = "foobar") not working
ARQGRA-247 - Add support for enriching @FindBys annotations
ARQGRA-254 - Expose LocalStorage and SessionStorage enrichments directly
ARQGRA-258 - Provide injecting classes requiring WebElement in their constructors via @FindBy annotation
ARQGRA-259 - Provide timeout setting in fluent API
ARQGRA-273 - Intercept WebDriver to return proxies in findElement()/findElements() methods

Story

ARQGRA-286 - Support PhantomJSDriver in Graphene

Task

ARQGRA-168 - Create QUnit tests for Graphene.Page.RequestGuard.js
ARQGRA-284 - Rename guardXhr to guardAjax
ARQGRA-287 - Deprecate Graphene.element and attribute methods

Thanks to the following list of contributors: Jan Papoušek, Lukas Fryc, Juraj Huska, Jiri Stefek, Andreas Vallen

Arquillian GWT Testing extension 1.0.0.Alpha2 Released

2013-04-17T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian GWT Testing extension component!

This is an update of the Arquillian GWT extension to remove the need for the custom GwtArchive class. Arquillian GWT tests can now leverage the standard ShrinkWrap API for specifiying their deployments. The WebArchive is automatically enhanced to include all dependencies and configurations relevant to the GWT deployment.

Here’s an updated example of a complete test class:

GreeterRpcTest.java


      @RunWith(Arquillian.class)
      public class GreeterRpcTest extends ArquillianGwtTestCase {
      
        @Deployment
        public static WebArchive createDeployment() {
          return ShrinkWrap.create(WebArchive.class, "test.war")
            .addClass(Greeter.class)
            .addClass(GreetingService.class)
            .addClass(GreetingServiceImpl.class)
            .addAsWebInfResource(new File("src/main/webapp/WEB-INF/web.xml"));
        }
      
        @Test
        @RunAsGwtClient(moduleName = "org.myapp.MyGwtModule")
        public void testGreetingService() {
          GreetingServiceAsync greetingService = GWT.create(GreetingService.class);
          greetingService.greetServer("Hello!", new AsyncCallback<String>() {
            @Override
            public void onFailure(Throwable caught) {
              Assert.fail("Request failure: " + caught.getMessage());
            }
      
            @Override
            public void onSuccess(String result) {
              assertEquals("Received invalid response from Server", "Welcome!", result);
              finishTest();
            }
          });
          delayTestFinish(5000);
        }
      }

Note that you will only need to extend ArquillianGwtTestCase if you want to inherit GWT’s asynchronous testing methods (finishTest and delayTestFinish).

We look forward to your feedback on this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian GWT Testing extension
Version	1.0.0.Alpha2 view tag
Release date	2013-04-15
Released by	Christian Sadilek
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-gwt jar pom

Release notes and resolved issues 2

Automatic deployment archive enhancement for GWT

Feature Request

ARQ-1354 - Automatically enhance the deployment archive to include all dependencies and configurations relevant to the GWT deployment

Thanks to the following list of contributors: Christian Sadilek

Arquillian Container Weld 1.0.0.CR6 Released

2013-03-09T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.CR6 release of the Arquillian Container Weld component!

What is Arquillian?

Release details

Component	Arquillian Container Weld
Modules	Arquillian Weld EE Embedded 1.1.x Container Adapter Arquillian Weld SE Embedded 1.x Container Adapter Arquillian Weld SE Embedded 1.1.x Container Adapter
Version	1.0.0.CR6 view tag
Release date	2013-03-08
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.container

org.jboss.arquillian.container » arquillian-weld-ee-embedded-1.1 jar pom
org.jboss.arquillian.container » arquillian-weld-se-embedded-1 jar pom
org.jboss.arquillian.container » arquillian-weld-se-embedded-1.1 jar pom

Release notes and resolved issues 3

Support for Weld 2.0

Bug

ARQ-841 - Should not scan for classes in Archive if it contains no beans.xml

Feature Request

ARQ-1302 - Support Weld 2.x

Thanks to the following list of contributors: Aslak Knutsen, Matt Benson

Arquillian Persistence Extension 1.0.0.Alpha6 Released

2013-03-08T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha6 release of the Arquillian Persistence Extension component!

Arquillian Persistence Extension is back on the release train and the future plan is stronger than ever. The Alpha6 release brings a lot of improvements and fixes thanks to invaluable feedback from the community.

Big thanks go to Marco Cella, Matti Linnanvuori, Bernard Łabno, Tiago Wanke Marques, Karsten Ohme, Vineet Reynolds, Cyrill Ruettimann, Bryan Saunders, Anton Shaykin, Nicolas-Xavier Vanderlinden and Noah White for their feedback which led us to fix some minor annoyances and shortcomings of APE. We are proud of the vibrant and active community around Arquillian!

Some of the highlights in this release

Transaction support has been replaced with Transaction Extension. By default the JTA implementation is included. The only thing you will need to change in your tests is the import sttement for the @Transactional annotation. From now on it’s under org.jboss.arquillian.transaction.api.annotation.

Support for row ordering when comparing datasets. When using Generated ID’s for instance, such as UUID’s, the rows need to be sorted in order for the DbUnit comparison to pass. If they are not ordered, then the assertion is unreliable.

Improved error reporting, including rows comparision and misconfigured entries.

DTD support for flat XML data sets (DBUnit feature).

Proper support for multiple line SQL scripts with comments (ANSI SQL compliant)

We’ve also extended our test suite by adding Apache Derby to our continuous integration pipeline.

Important change: We re-groupped configuration entries arquillian.xml giving them more qualifiers:
persistence – for all basic settings
persistence-dbunit – for DBUnit specific configuration
persistence-script – for SQL related things
Please refer to our confluence documentation for detailed description.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Persistence Extension
Version	1.0.0.Alpha6 view tag
Release date	2013-03-07
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-persistence-api jar pom
org.jboss.arquillian.extension » arquillian-persistence-impl jar pom
org.jboss.arquillian.extension » arquillian-persistence-integration-tests-testng jar pom

Release notes and resolved issues 25

Bug

ARQ-1028 - @ShouldMatchDataSet before persist
ARQ-1081 - DTD not supported by APE
ARQ-1086 - @CleanuUsingScript with phase NONE
ARQ-1087 - Wrong dump directory path
ARQ-1094 - @ShouldMatchDataSet Not Properly Comparing Datasets
ARQ-1100 - Datetime conversion does not work as expected for YAML data sets
ARQ-1101 - Exception with nested transaction with MySQL
ARQ-1127 - Order of scripts and data sets should be preserved when defined on class level
ARQ-1146 - Single statement which spans multiple lines is not handled properly
ARQ-1167 - Transactional support from Seam 3 interfere Persistence Extension resulting in ExclusiveTransactionException
ARQ-1208 - Multiple line statements are not handled properly
ARQ-1300 - Execute script handler does not properly ignore /* */ and {} ANSI compliant SQL comments

Enhancement

ARQ-1085 - Unify JPA Cache eviction events with APE
ARQ-1215 - Clean slf4j dependency

Feature Request

ARQ-1093 - Support for Row Ordering when Comparing Datasets
ARQ-1149 - Dataset comparision should collect all differences in the rows instead of failing on the first column
ARQ-1157 - Replace Persistence internal Transaction management with Transaction Extension
ARQ-1231 - Should observe required object ArquillianDescriptor instead of assuming Lifecycle
ARQ-1248 - Add Derby to the testing matrix

Task

ARQ-1342 - Clean up POM
ARQ-1343 - Schema creation scripts should be repeatable

Sub-task

ARQ-1158 - Extract JTA from APE and replace with Transaction Extension dependency
ARQ-1334 - Should inform if table defined for exclusion is not defined in the schema
ARQ-1335 - Should inform when non-defined configuration key encountered in arquillian.xml

Thanks to the following list of contributors: Bartosz Majsak, Aslak Knutsen, Vineet Reynolds, Jakub Narloch, Artur Dryomov

Arquillian GWT Testing extension 1.0.0.Alpha1 Released

2013-02-27T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha1 release of the Arquillian GWT Testing extension component!

This is the first release of the Arquillian GWT extension which aims to bring true integration testing to GWT.

Highlighted Features

Run GWT integration tests in Arquillian containers: This means that GWT integration tests can break free and execute in the actual runtime container instead of being tied to GWT’s embedded Jetty server.

Combining client-side and in-container tests: It is possible to combine GWT client-side and standard in-container tests in the same test class. This allows to test features without having to worry about the client-server bridge and should pave the way for future support of Arquillian Warp and Drone in GWT integration tests.

Getting Started

To start using the Arquillian GWT extension just add the following dependency to your project:

pom.xml

<dependency>
          <groupId>org.jboss.arquillian.extension</groupId>
          <artifactId>arquillian-gwt</artifactId>
          <version>1.0.0.Alpha1</version>
      </dependency>

Writing Arquillian GWT tests

To run a test method as a GWT integration test either annotate the test class or test method with @RunAsGwtClient and specifiy the GWT module. If you annotate the test class all test methods in that class will run as GWT integration tests.

MyTestClass.java


      @RunWith(Arquillian.class)
      public class MyTestClass {
      
        @Test 
        @RunAsGwtClient(moduleName = "org.myapp.MyGwtModule")
        public void myGwtTest() {
      
        }
      }

To help packaging your app for the test deployment Arquillian GWT provides a simple utility called GwtArchive. The next version of Arquillian GWT will automatically enhance the used WebArchive. So, you won’t need to use this utility in the future. Here’s a complete example:

GreeterRpcTest.java


      @RunWith(Arquillian.class)
      public class GreeterRpcTest extends ArquillianGwtTestCase {
      
        @Deployment
        public static WebArchive createDeployment() {
          return GwtArchive.get()
            .addClass(Greeter.class)
            .addClass(GreetingService.class)
            .addClass(GreetingServiceImpl.class);
        }
      
        @Test
        @RunAsGwtClient(moduleName = "org.myapp.MyGwtModule")
        public void testGreetingService() {
          GreetingServiceAsync greetingService = GWT.create(GreetingService.class);
          greetingService.greetServer("Hello!", new AsyncCallback<String>() {
            @Override
            public void onFailure(Throwable caught) {
              Assert.fail("Request failure: " + caught.getMessage());
            }
      
            @Override
            public void onSuccess(String result) {
              assertEquals("Received invalid response from Server", "Welcome!", result);
              finishTest();
            }
          });
          delayTestFinish(5000);
        }
      }

Note that you will only need to extend ArquillianGwtTestCase if you want to inherit GWT’s asynchronous testing methods (finishTest and delayTestFinish).

We look forward to your feedback on this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian GWT Testing extension
Version	1.0.0.Alpha1 view tag
Release date	2013-02-23
Released by	Christian Sadilek
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-gwt jar pom

Release notes and resolved issues 1

Initial prototype release

Thanks to the following list of contributors: Christian Sadilek, Karel Piwko, Aslak Knutsen

Hackfest: DevConf 2013, Czech Republic, Brno

2013-02-17T00:00:00Z

In about a weeks time DevConf 2013 in Brno, Czech Republic will kick of for the 5. year in a row.
This year, as last, we will take part in the HackFest spanning from Saturday 23. to Sunday 24. of February. And for the eager hackers even Monday 25. February.

Introducing the candidates

Without any more fuzz, let’s jump straight into some of the ideas we have for this hackfest. Of course, you’re free to bring your own as well!

Gradle Container Controller

One of the hacks that was started during the Devoxx 2012 Hackergarten: was the Arquillian Gradle integration. The basic idea is to leverage Arquillian’s Container support to control Containers and Deployments within the Gradle build system, much like we do for Maven via the Arquillian Maven Plugin. This in particular is a very interesting integration since it opens up Arquillian to a new type of usage, as a pure Container Controller.

Why would Gradle use Arquillian for this? It’s a simple matter of focus. Gradle care about build systems and don’t have the resources to implement support for all the Containers. Arquillian on the other hand care very much of the Containers and already support much more than Gradle currently do in this area. Perfect combination of two tools with different capabilities.

You can read up on some of the discussions and see look at the early prototype.

The end goal would be to match as much as possible of the Gradle Design docs and have Arquillian be the internal runner.

Arquillian Forge Plugin – Extensions

JBoss Forge is best described by them selves.

A core framework and next-generation shell for tooling and automation at a command line level; with APIs for integration in IDEs, extending built in functionality with plugins, and scripting for automating repetitive tasks, Forge is a tool every open-source developer should be looking at.

A core framework for rapid-application development in a standards-based environment. Plugins / incremental project enhancement for Java EE, and more.

There exists already an Arquillian Plugin for Forge which handles setup of Arquillian Core and Container dependencies, Container configuration and simple TestClass generation.

But the missing bit is set up and support for the Arquillian Extensions. This hack should be able to answer, by using Forge, questions like:

How do I setup Drone, Persistence, Transactions?
How do I configure Drone?
Which configuration options does Persistence support?

Arquillian Warp

Arquillian Warp fills the void between client-side and server-side testing. Using Warp, you can initiate an HTTP request using a client-side testing tool such as WebDriver and, in the same request cycle, execute in-container server-side tests. This powerful combination lets you cover integration across client and server.

SeamTest

Warp leverages any HTTP client (such as httpclient or WebDriver), to produce testable requests and provides server-side hooks which allows you to execute arbitrary logic in any part of the request lifecycle. However the fact that developer needs to provide HTTP request in order to test is limiting – sometimes you need to test using any request type: such as conversations. The goal is designing an API and implementation for testing sequence of requests without providing an HTTP client logic. (This extension should provide a migration layer for SeamTest )

CDI events

Warp plays nicely with IoC principles – your test does not need to tightly couple with container, it will bring all the necessary dependencies to the test. In Java EE, Warp leverages CDI to inject user-defined beans into the test. Warp has the potential to use much more from the concepts brought by CDI: observe CDI events, produce beans or intercept calls to existing beans. The idea is to provide hooks which would make testing of client request interaction with CDI beans as easy as defining Warp’s lifecycle hooks.

Arquillian Google Web Toolkit

The Google Web Toolkit is a development tool for building complex browser-based applications written in pure Java. The new Arquillian GWT extension brings true integration testing to GWT. This means that GWT integration tests can break free and execute in the actual runtime container instead of being tied to GWT’s embedded Jetty server. Further it is now possible to combine GWT client-side and standard in-container tests in the same test class. This allows to test features without having to worry about the client-server bridge and should pave the way for future support of Arquillian Warp and Drone in GWT integration tests.

Remove the need for GwtArchive

Currently the Arquillian GWT extension uses a custom utility (GwtArchive) to enrich WebArchives for GWT deployments. This causes the API for Arquillian GWT tests to deviate from standard Arquillian tests. It should be possible to automatically enhance the deployment archive to include all dependencies and configurations that are relevant to the GWT deployment, possibly by leveraging an Arquillian packaging SPI’s. As a result of this, GWT integration tests will use the same API as all other Arquillian tests.

Leverage Arquillian Warp in GWT integration tests

Warp enables tests to assert on both client-side and server-side logic and is an extremely useful tool for writing compact integration tests. The focus will be on brainstorming to come up with a battle plan for how Warp could be integrated with Arquillian GWT.

Arquillian Distribution Extension

This is probably the hardest and largest of them all. But even more interesting, right?. As Arquillian work today it will allow you to interact with local and remote Containers. But the big assumption with Remote Containers is that the Container is already up and running and we only need to connect to it. As we’re growing out to support more and more advanced use cases we’re starting to see the need for the ability to control and distribute infrastructure. Infrastructure being servers, containers or clouds.

A very brief description of what this extension should do:

Install Container A on Server B (copy source and configure)
Install Container X on Server Y (copy source and configure)
Configure Arquillian to use Container A on Server B
Configure Arquillian to use Container X on Server Y

From here on Arquillian Test takes over and run tests as described by the Test Suite. Next steps would be:

Uninstall Container X on Server Y
Uninstall Container A on Server B

This is particularly useful for the upcoming Performance Extension to allow it to install a full environment, including clients and targets, for performance testing.

What is Arquillian?

Arquillian is open source software that empowers you to test JVM-based applications more effectively. Created to defend the software galaxy from bugs, Arquillian brings your test to the runtime so you can focus on testing your application’s behavior rather than managing the runtime. Using Arquillian, you can develop a comprehensive suite of tests from the convenience of your IDE and run them in any IDE, build tool or continuous integration environment.

When and where are we hacking?

We are going to use the free Hackfest at DevConf 2013 as an opportunity to put our heads together to make progress on these ideas. Here are the details:

When: Saturday February 23 12:30 – 18:30 CET, Sunday February 24 09:00 – 18:30 CET, Monday February 25 09:00 – 17:00 CET
Where: Hackfest at DevConf 2013 (Masaryk University, Faculty of Informatics, Brno, Czech Republic)
Conference URL: http://devconf.cz/
Hashtag: #hackdevconf and #arquillian
Lanyrd: http://lanyrd.com/2013/hackdevconf/
IRC: #arquillian on Freenode

Of course, anyone is welcome to hack on these ideas at anytime from anywhere. This is open source!

Who will be there hacking?

Karel Piwko (Arquillian Drone Lead)
Lukáš Fryč (Arquillian Warp & Graphene Lead)
Dan Allen (Arquillian team member)
Aslak Knutsen (Arquillian Lead)
You

Happy hacking!

Arquillian Portal Extension 1.0.0.Beta1 Released

2013-02-01T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Beta1 release of the Arquillian Portal Extension component!

Highlighted Features

Shrinkwrap Archive type for portlets: We now have PortletArchive for creating Shrinkwrap archives for portlets. (read more)

Helpers for creating portlet.xml: Within PortletArchive there are some simple helpers for creating the contents of portlet.xml. (read more)

Shrinkwrap Archive type for portlets

We can now use PortletArchive instead of WebArchive when we’re creating micro deployments for testing a portlet. In it includes methods for setting the content of portlet.xml without needing to specify the path, in a similar manner that WebArchive provides setWebXML() methods.

Helpers for creating portlet.xml

PortletArchive also adds some nice helpers for creating GenericPortlet or GenericFacesPortlet portlet definitions within portlet.xml. A GenericPortlet can be added to portlet.xml by:

Shrinkwrap.create(PortletArchive.class)
      	.createSimplePortlet(MyPortletClass.class);

And adding a portlet for JSF is:

Shrinkwrap.create(PortletArchive.class)
      	.createFacesPortlet("portletName", "Portlet Title", "index.xhtml");

For examples on how to use these extensions with their respective portal containers, you can take a look at the testsuite of Portlet Bridge.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Portal Extension
Version	1.0.0.Beta1 view tag
Release date	2013-01-31
Released by	Ken Finnigan
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-portal jar pom
org.jboss.arquillian.extension » arquillian-portal-api jar pom
org.jboss.arquillian.extension » arquillian-portal-impl jar pom
org.jboss.arquillian.extension » arquillian-portal-shrinkwrap-api jar pom
org.jboss.arquillian.extension » arquillian-portal-shrinkwrap-impl jar pom
org.jboss.arquillian.extension » arquillian-portal-spi jar pom

Release notes and resolved issues 2

Feature Request

ARQ-1279 - Create PortletArchive as Shrinkwrap archive type for portlets

Thanks to the following list of contributors: Ken Finnigan

Arquillian Drone Extension 1.1.1.Final Released

2013-01-25T00:00:00Z

The Arquillian team is proud to announce the 1.1.1.Final release of the Arquillian Drone Extension component!

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.1.1.Final view tag
Release date	2013-01-24
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 7

Bug fix release for Arquillian Drone 1.1.0.Final

Bug

ARQ-1251 - Arquillian Drone is unable to instantiate Firefox driver if acceptSslCerts, webStorageEnabled, loggingPrefs properties are used in arquillian.xml
ARQ-1258 - Allow Chrome switches to contain spaces

Component Upgrade

ARQ-1252 - Upgrade to Selenium 2.28.0 and use Selenium BOM
ARQ-1280 - Update selenium to 2.29.0
ARQ-1281 - Update Arquillian Core in Drone to 1.0.3.Final

Task

ARQ-952 - Avoid heavy-weight tests for Drone functional testing
ARQ-1268 - Prepare Drone 1.1.1.Final release

Thanks to the following list of contributors: Karel Piwko, Tomas Repel, Lukas Fryc

Graphene 2.0.0.Alpha3 Released

2013-01-16T00:00:00Z

The Arquillian team is proud to announce the 2.0.0.Alpha3 release of the Graphene component!

Highlighted Features

jQuery Selectors: Graphene gets its own @FindBy annotation and ByJQuery selector in order to fully support jQuery selectors. (read more)

Injecting Selenium Resources: The interesting Selenium APIs (HTML5, Mobile, etc.) can be injected to the test or page fragments directly. (read more)

Fluent API for Waiting: Waiting conditions can now be defined in a nice fluent API. (read more)

Injecting List of Page Fragments: It’s possible to inject a list of page fragments with @FindBy List<PageFragment>.

Page Fragment Enrichment: Any Arquillian resource available through @ArquillianResource can be injected into page fragments.

Important Bug Fixes

XHR Request Guards: guardXhr wasn’t waiting for the XHR request to fully complete. So we have improved it and now it not only waits for AJAX callback to completely finish, but it will wait for any asynchronous processing caused by that callback to finish.

Protecting against Stale Elements: You are now completely protected against StaleElementReferenceException when using page fragments and elements injected by @FindBy, because operations on those elements are evaluated lazily (at the time of usage) and they are re-evaluated when they get stale.

Refined Page Fragments: Page Fragments have received a lot of bug fixes and improvements.

jQuery Selectors

This feature injects a jQuery script to a tested page and allows Graphene to find elements using the jQuery Selectors syntax:

@FindBy(jquery = ":button:visible")
      WebElement firstVisibleButton;

Note that Graphene injects jQuery in non-conflict way, so it does not affect your tested application.

Injecting Selenium Resources

Graphene leverages a long list of advanced Selenium features and their APIs to take full control of your browser:

You can inject those using @ArquillianResource annotation:

@ArquillianResource
      BrowserConnection connection;
      
      @Test
      public void test() {
          connection.setOnline(false);
      }

Fluent API for Waiting

The Alpha2 API allowed you to define a wait like this:

waitAjax().until(element(button).isVisible());

In order to fully support code-completion, we have decided to deprecate this API in favor of a fluent API:

waitAjax().until().element(button).is().visible();

Roadmap

This release is a significant milestone on the way to Beta1.

What is Arquillian?

Release details

Component	Graphene
Version	2.0.0.Alpha3 view tag
Release date	2013-01-08
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.graphene

org.jboss.arquillian.graphene » graphene-build-resources jar pom
org.jboss.arquillian.graphene » graphene-component-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-drone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-drone jar pom
org.jboss.arquillian.graphene » graphene-webdriver-ftest jar pom
org.jboss.arquillian.graphene » graphene-webdriver-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-spi jar pom

Release notes and resolved issues 39

Q1/13: Page Fragment enrichment; jQuery locators

Bug

ARQGRA-184 - Using driver in test listener causes NullPointerException
ARQGRA-198 - TestFactoryClass fails on NPE
ARQGRA-201 - Guards are not working with AndroidDriver
ARQGRA-202 - Page Fragments: injected web elements are not found relatively to root element
ARQGRA-232 - Enriched WebElement cannot be converted to JSON without manual unwrapping
ARQGRA-233 - Graphene does not guard against StaleElementException
ARQGRA-240 - Move Grapgene's FindBy from SPI to API
ARQGRA-241 - Double quotes in jquery fails
ARQGRA-242 - Dependency cleanup: remove Guava, commons-* and replace JBoss Logging with JUL
ARQGRA-245 - Returning a value from Function<T,V> in WebDriverwait cannot be compiled with JDK7
ARQGRA-246 - ByJQuery.jquerySelector with findElemens behaves differently than By
ARQGRA-249 - Negation in fluent API is not compilable

Component Upgrade

ARQGRA-217 - Upgrade to Arquillian Core 1.0.3.Final
ARQGRA-218 - Upgrade to Drone 1.1.0.Final
ARQGRA-248 - Upgrade commons-lang to 3.1

Enhancement

ARQGRA-195 - Page Fragment Enricher fail with no context to where
ARQGRA-200 - Enhance Graphene's guards to wait until page fully updates
ARQGRA-211 - Enhance guards to wait for request
ARQGRA-228 - Waiting conditions improvements - string matchers, no-parameter until()
ARQGRA-229 - Support for JavaScript interfaces defined as abstract classes
ARQGRA-230 - Override a toString method in BooleanConditionWrapper
ARQGRA-234 - Sizzle locators: make injected jQuery noConflict

Feature Request

ARQGRA-84 - Support Sizzle locators with Selenium 2
ARQGRA-165 - Test enricher or resource provider for JSInterfaceFactory
ARQGRA-166 - Enrichment of page abstractions with Graphene configuration
ARQGRA-189 - Support @Page in Page objects
ARQGRA-190 - Support initializing Page Objects declared with generic types
ARQGRA-191 - Support @Drone and @ArquillianResource in Page objects
ARQGRA-192 - Support enriching also List<WebElement> fields annotated with @FindBy
ARQGRA-204 - Support innitialization of Page Fragments nested in other Page Fragments
ARQGRA-214 - Support for enriching by Page Objects and Page Fragments declared as nested classes
ARQGRA-215 - Enable injection of List<Page Fragment>
ARQGRA-216 - Support protection from StaleElementReferenceException
ARQGRA-227 - Support for injecting common Selenium resources: JavaScriptExecutor, Actions, Capabilities, etc.
ARQGRA-239 - CGLib usage interferes with test execution, leading to Security exception
ARQGRA-244 - Type parameters should be uppercase

Task

ARQGRA-193 - Make Graphene 2 Configuration be compatible with Drone configuration
ARQGRA-207 - Page Fragments: support initialization of Page Fragments which are without @Root field
ARQGRA-219 - Refactor whole Enricher related code

Thanks to the following list of contributors: Jan Papoušek, Lukas Fryc, Juraj Huska, Karel Piwko

Arquillian Warp 1.0.0.Alpha2 Released

2013-01-16T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian Warp component!

It has been a pretty long road from Alpha1 to this release, focused primarily on polishing the user experience.

So without any further ado, let’s look at the new shiny features!

Highlighted Features

Renaming Warp API methods: The API methods were renamed according to the results of our public survey. (read more)

In the simplest scenario you want to inspect the first request after performing a given client activity. For this purpose, you can use a basic Warp API known from Alpha1:

Warp
          .initiate(Activity)
          .inspect(Inspection);

This will intercept the first request coming from the client and ignore the rest of the potential requests.

Additionally, Warp will ignore requests for favicon.ico which could fail your test unexpectadly.

You can find more samples for this API in a source .

Anonymous and Inner Classes: It’s now much easier to define a verification code, which is also more readable.

In Alpha1, you had to use a top-level or a static inner classes to define inspections.

In Alpha2, you can provide non-static inner class or even anonymous class.

HelloWarp.java

Warp
          // first you need to initiate activity which triggers HTTP request
          .initiate(new Activity() {
              public void perform() {
                  ajaxButton.click();
              }
          })
      
          // and then specify what behavior should be inspected on the server
          .inspect(new Inspection() {
      
              // don't forget to specify serialVerionUID to allow serialization
              private static final long serialVersionUID = 1L;
              
              // bring JSF context via dependency injection
              @ArquillianResource
              FacesContext facesContext;
      
              // verify expected behavior in given request phase
              @AfterPhase(RESTORE_VIEW)
              public void beforeServlet() {
                  assertTrue(facesContext.isPostback());
              }
          });

This example showed how to use the new API together with anonymous inspections

Multiple Requests / Request Groups: It is possible to intercept several requests during one Warp execution.

Warp allows you to verify more than one request triggered by a single client activity. This allows you to verify e.g. a request for HTML page and all its resources (JS, CSS, images) separately. This feature is called Request Groups.

TestRequestGroups.java

// Request Group execution will return WarpResult
      WarpResult result = Warp
          .initiate(Activity)
          // a group specification without name - the name will be generated
          .group()
              .observe(HttpRequestFilter)
              .inspect(Inspection1)
          // a named group specification - the result can be easily accessed
          .group("second")
              .observe(HttpRequestFilter)
              .inspect(Inspection2)
          // you need to execute whole Request Group once it is completely specified
          .execute();
          
          // you can access details of finished execution
          result.getGroup("second").getInspection();

The Request Groups execution returns a WarpResult which contains details about the finished execution. In order to access the results related to a specific group, you can give the group a name

Request Observers & Fluent API: The new API for observing the correct request allows you to select which request should be verified on a server.

When using Request Groups, all of the requests will be inspected by the inspections defined in that group. There might be one or more requests verified by each group.

Since multiple request can be triggered, you might want to choose the correct request to observe. For this purpose, we have the HttpRequestFilter interface, where you specify which HttpRequest should matches the current group.

import static org.jboss.arquillian.warp.client.filter.http.HttpFilters.request;
      
      // will accept only requests for HTML
      ...group()
          .observe(request().uri().contains(".html"))
      
      // will accept only REST requests for JSON
      ...group()
          .observe(request().header().containsValue("Accept", "application/json"))
      
      // will accept only POST requests
      ...group()
         .observe(request().method().equal(POST))

In order to simplify writing the Warp specifications, you can define the observer using a fluent API and static factory methods.

Dependency Injection for Servlets and JSF: Test enrichers now allow the the injection of Servlet and JSF resources. (read more)

Renaming Phaser to Warp JSF: The JSF specific extension was renamed from Phaser to Warp JSF. (read more)

Introduction of Dependency Chain: The dependency chain was introduced to bring in all necessary dependencies by specifying just one dependency. (read more)

Warp Extensions for REST and Spring MVC: Thanks to Jakub Narloch, we have two new additions to Arquillian Galaxy. (read more)

Under the Hood

Usability and Debugging Improvements: A focus of Alpha2 was to polishing the way Warp behave in case of failures and on debuggability of Warp execution.

Validation of Warp Specification: Warp now validates that the number of observed requests match a number of expected requests. It also makes sure that all of defined lifecycle callbacks are executed on the server, to avoid any false positives.

As you can see there are many of new features, so let’s look at them separately:

Renaming Warp API

After Alpha1 we got several requests for clarifying the Warp high-level API:

Warp.execute(ClientAction).verify(ServerAssertion)

The announced survey helped us choose the new API. As a result, 88% of participants reported they found this new API more natural:

Warp.initiate(Activity).inspect(Inspection)

Big thanks to everyone who participated in the survey! This type of collaboration makes me really proud to be part of the team.

Warp Extensions: REST and Spring MVC

Warp was from the beginning built as a project that focused on any framework/technology that is based on top of the Servlet API.

Thus it’s not surprising that there are already two extensions shaping out thanks to Jakub Narloch:

Introduction of Dependency Chain

Putting Warp to work in your Maven project is now as easy as defining a single dependency:

pom.xml

<dependency>
          <groupId>org.jboss.arquillian.extension</groupId>
          <artifactId>arquillian-warp</artifactId>
          <version>1.0.0.Alpha2</version>
          <type>pom</type>
      </dependency>

This declaration will bring Warp core, which supports Servlet API lifecycle callbacks.

Renaming Phaser to Warp JSF

Initially we had created Phaser as the next generation of the successful JSFUnit. It occured to use that Phaser is an unfortunate name and it just makes it harded to understand the Arquillian eco-system.

That’s why we have come up with a simpler variant – so let me introduce the Warp JSF extension.

You can bring Warp JSF to your project just by adding the following declaration:

pom.xml

<dependency>
          <groupId>org.jboss.arquillian.extension</groupId>
          <artifactId>arquillian-warp-jsf</artifactId>
          <version>1.0.0.Alpha2</version>
      </dependency>

Dependency Injection for Servlets and JSF

After the announcement of the Alpha1 release, we focused on improving Warp to come closer to the Arquillian goal: bring all necessary dependencies to the test (in our case to inspection).

Now, you can not only inject all CDI managed beans (@Inject), EJB beans (@EJB) or container managed resources @Resource, but you can also inject the following resources:

Servlet resources
- ServletRequest or HttpServletRequest
- ServletResponse or HttpServletResponse

JSF resources
- FacesContext
- Application
- ELContext, ELResolver, ExpressionFactory
- ExceptionHandler
- Flash
- NavigationHandler
- PartialViewContext
- RenderKit
- ResourceHandler
- StateManager
- UIViewRoot
- ViewHandler

Migration from Alpha1

We’ve create a little bash script to convert the java source from Alpha1 API to Alpha2 that might help you with the upgrade.

How to Learn Warp?

The best way now is to look at functional tests for Warp or Warp JSF.

Roadmap

The roadmap to Beta1 is pretty clear:

documentation and guides
adding features known from SeamTest and JSFUnit
new injections and event hooks (e.g. improved CDI integration)
hardering and usability enhancements (here we rely on your issue reports!)

Along the way we will welcome every idea for integrating Warp with your favorite web framework – so don’t be a stranger and come to us!

What is Arquillian?

Release details

Component	Arquillian Warp
Version	1.0.0.Alpha2 view tag
Release date	2013-01-08
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.3.Final ShrinkWrap Resolvers – 2.0.0-alpha-1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-warp-api jar pom
org.jboss.arquillian.extension » arquillian-warp-bom pom
org.jboss.arquillian.extension » arquillian-warp-build-resources jar pom
org.jboss.arquillian.extension » arquillian-warp-ftest jar pom
org.jboss.arquillian.extension » arquillian-warp-impl jar pom
org.jboss.arquillian.extension » arquillian-warp-jsf jar pom
org.jboss.arquillian.extension » arquillian-warp-jsf-ftest jar pom
org.jboss.arquillian.extension » arquillian-warp-spi jar pom

Release notes and resolved issues 35

Renaming API methods according to survey; Anonymous/Inner Class; Request Observers/Filters

Bug

ARQ-972 - Warp tests should be excluded from scanning by CDI container
ARQ-973 - Warp: if primitive field in ServerAssertion is changed during test, it is wrongly changed to initial value on deenrichment
ARQ-976 - The exceptions that occurrs in @AfterServlet test is not being propagated back to the client.
ARQ-982 - Response header size exceeded in Warp test.
ARQ-992 - Warp does not support request redirection.
ARQ-1063 - Warp: when both ServerAssertion and ClientAction fails, server error should be reported
ARQ-1163 - Warp: response is not properly commited
ARQ-1174 - Warp: DeploymentEnricher should check whether current TestClass is annotated with WarpTest
ARQ-1195 - Warp: do not remove static inner classes from deployment
ARQ-1197 - Warp: report that serialVersionUID was not set for Inspection
ARQ-1254 - Warp: RequestPayload decides whether transform class for all inspections instead of each inspection at own

Component Upgrade

ARQ-1052 - Upgrade Arquillian Core to 1.0.3.Final
ARQ-1053 - Upgrade Arquillian Drone to 1.1.0.Final

Enhancement

ARQ-979 - Exposed BeforeServlet and AfterServlet events to SPI
ARQ-980 - Make ServletRequest an injectable resource
ARQ-981 - Move BeforeServlet and AfterServlet events to SPI
ARQ-1060 - Fail to start a Warp test when @Deployment(testable=false) and when no @RunAsClient present
ARQ-1120 - Warp: safe propagation server-side failures to client-side
ARQ-1223 - Warp JSF: refactor PhaseLifecycleEvent to expose name of the event when debugging
ARQ-1224 - Warp: expose RequestContext and RequestScope to SPI
ARQ-1236 - Warp: filter favicon.ico requests by default
ARQ-1246 - Warp: single execution should observe only first request

Feature Request

ARQ-932 - Warp: support for inner/anonymous classes
ARQ-937 - Add usage examples to API/SPI classes
ARQ-964 - Verify that all tests in ServerAssertion has been called - prevents false negatives
ARQ-965 - Warp: Enable common JSF objects (FacesContext, Application) to be injected using @ArquillianResource
ARQ-967 - Warp: client-side filters for waiting for "right" request or enriching several requests
ARQ-1056 - Warp: Enable common JSF objects (FacesContext, Application) to be injected using @Inject
ARQ-1057 - Warp: Resource provider for HttpServletRequest/HttpServletResponse
ARQ-1061 - Debug output from Warp when Arquillian logging enabled
ARQ-1073 - Warp: buffering writer/stream re-initializes on each getWriter/getOutputStream call
ARQ-1204 - Builder for Warp filters.

Task

ARQ-1054 - Warp: rename arquillian-warp-phaser to arquillian-warp-jsf
ARQ-1055 - Introduce Warp depchain
ARQ-1233 - Warp: rename API according to results of survey

Thanks to the following list of contributors: Lukas Fryc, Jakub Narloch, Lukas Fryc, Martin Kouba, Brian Leathem, Aslak Knutsen

Arquillian Drone Extension 1.2.0.Alpha1 Released

2013-01-16T00:00:00Z

The Arquillian team is proud to announce the 1.2.0.Alpha1 release of the Arquillian Drone Extension component!

We’ve introduced new features and bugfixes in 1.2.0.Alpha1 while still preserving backwards compatibility with 1.1.0.Final. We fixed an annoying bug that made usage of some capabilities impossible and have delivered some Firefox goodies.

Significant changes since 1.1.0.Final

Updated Selenium to 2.28.0 and introduced Selenium BOM

Now you can switch to next Selenium version only by including following snippet in your pom.xml file.

pom.xml

<dependencyManagement>

          <dependencies>

              <groupId>org.jboss.arquillian.selenium</groupId>

              <artifactId>selenium-bom</artifactId>

              <version>${version.selenium}</version>

              <type>pom</type>

              <scope>import</scope>

          </dependencies>

      </dependencyManagement>

This snippet must be placed above arquillian-drone-bom in order to override Selenium versions.

Support for loading XPI into Firefox profile

There is no need to work with a separate Firefox profile. Simply use the WebDriver generated one and let Drone install all extensions you need.

arquillian.xml

<extension qualifier=“webdriver”>

          <property name=“browserCapabilities”>firefox</property>

          <property name=“firefoxExtensions”>/path/to/extension1 “/path/to extension2/with/space”</property>

      </extension>

Ability to set WebDriver logging level

Drone allows to to set the logging level for Firefox WebDriver directly from Arquillian configuration.

arquillian.xml

<extension qualifier=“webdriver”>

          <property name=“browserCapabilities”>firefox</property>

          <property name=“loggingPrefs”>driver=INFO,profiler=WARNING</property>

      </extension>

Logging level are the same as for JUL, that is SEVERE, WARNING, INFO, CONFIG, FINE, FINER and FINEST.

I’d like to thank everybody involved in this release. You guys make testing a breeze!

We hope that you’ll enjoy the improvements. We look forward to hear your feedback in the community forums.

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.2.0.Alpha1 view tag
Release date	2013-01-09
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 6

Bug

ARQ-1251 - Arquillian Drone is unable to instantiate Firefox driver if acceptSslCerts, webStorageEnabled, loggingPrefs properties are used in arquillian.xml
ARQ-1258 - Allow Chrome switches to contain spaces

Component Upgrade

ARQ-1252 - Upgrade to Selenium 2.28.0 and use Selenium BOM

Feature Request

ARQ-1138 - Drone: provide selenium-bom to manage Selenium dependencies
ARQ-1259 - Make possible to load an xpi as firefox Extension

Task

ARQ-952 - Avoid heavy-weight tests for Drone functional testing

Thanks to the following list of contributors: Tomas Repel, Karel Piwko, Lukas Fryc, Jan Papoušek, Aslak Knutsen

Arquillian Android Extension 1.0.0.Alpha2 Released

2013-01-16T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian Android Extension component!

Arquillian Android Extension has reached the Alpha2 milestone. This is a bugfix release with a few new nice features.

Significant changes in 1.0.0.Alpha2

Ability to specify ABI

Since Android 4 the SDK allows to define multiple ABI types for the emulator. We now honor this property and fail fast if multiple ABIs are available during creation of the emulator.

arquillian.xml

<extension qualifier=“android”>

         <property name=“abi”>armeabi-v7a</property>

      </extension>

Ability to inject Android Driver instance into the test

You now have limited control of the device from the test itself.

AndroidApkInstallationTestCase.java

@ArquillianResource
      AndroidDevice device;
      
      @Test
      public void installAndUninstallApk() throws AndroidExecutionException {
          device.installPackage(new File("src/test/apk/calculator.apk"), true);
      
          List<String> installedApps = getInstalledPackages(device);
      
          Assert.assertTrue("Calculator app was installed", installedApps.contains(CALCULATOR_APP));
          device.uninstallPackage(CALCULATOR_APP);
      
      installedApps = getInstalledPackages(device);

          Assert.assertFalse(“Calculator app was uninstalled”, installedApps.contains(CALCULATOR_APP));

      }

Big thanks go to Jan Papousek (@jan_papousek) for improving and testing this release!

We hope that you’ll enjoy the improvements. We look forward to hear your feedback in the community forums.

What is Arquillian?

Release details

Component	Arquillian Android Extension
Version	1.0.0.Alpha2 view tag
Release date	2013-01-09
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.3.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-android-api jar pom
org.jboss.arquillian.extension » arquillian-android-bom pom
org.jboss.arquillian.extension » arquillian-android-configuration jar pom
org.jboss.arquillian.extension » arquillian-android-depchain pom
org.jboss.arquillian.extension » arquillian-android-drone jar pom
org.jboss.arquillian.extension » arquillian-android-impl jar pom
org.jboss.arquillian.extension » arquillian-android-spi jar pom

Thanks to the following list of contributors: Karel Piwko, Lukas Fryc, Jan Papoušek, Aslak Knutsen

Arquillian Extension Jacoco 1.0.0.Alpha5 Released

2012-11-28T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha5 release of the Arquillian Extension Jacoco component!

Some of the highlights in this release

EclEmma Eclipse Plugin support

When you run your Arquillian tests via “Coverage As → JUnit” in Eclipse, you’ll now see the remote coverage data collected by the Arquillian Jacoco Extension right there alongside the client coverage data. In your IDE!

It’s no longer needed to go via Maven and view the html output. Maven is of course still supported.

We added Include/Exclude filtering

The default filer is *.class. But you might not want to record coverage data on all the external libraries in your deployment. By using Include and Exclude filters you can control what is recorded.

<?xml version="1.0" encoding="UTF-8"?>
      <arquillian
        xmlns="http://jboss.org/schema/arquillian"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xsi:schemaLocation="
              http://jboss.org/schema/arquillian
              http://jboss.org/schema/arquillian/arquillian_1_0.xsd">
      
        <extension qualifier="jacoco">
          <property name="excludes">my.package.some.*</property>
          <property name="includes">my.package.some.include.*,my.package.some.other.*</property>
        </extension>
              
      </arquillian>

Thanks to Lukas Krejci for the nice filtering support.

Important change: Upgraded to Jacoco version 0.6.0.201210061924

What is Arquillian?

Release details

Component	Arquillian Extension Jacoco
Version	1.0.0.Alpha5 view tag
Release date	2012-11-27
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-jacoco jar pom

Release notes and resolved issues 2

Packaging fix

Bug

ARQ-1226 - Jacoco should not package arquillian.xml

Thanks to the following list of contributors: Aslak Knutsen

Arquillian Extension Jacoco 1.0.0.Alpha4 Released

2012-11-28T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha4 release of the Arquillian Extension Jacoco component!

What is Arquillian?

Release details

Component	Arquillian Extension Jacoco
Version	1.0.0.Alpha4 view tag
Release date	2012-11-27
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-jacoco jar pom

Release notes and resolved issues 3

EclEmma IDE support

Feature Request

ARQ-1219 - Only collect remote coverage data when running in coverage mode
ARQ-1220 - Make Remote Coverage data available to IDE

Thanks to the following list of contributors: Aslak Knutsen, Lukas Krejci

Arquillian Transaction Extension 1.0.0.Alpha3 Released

2012-11-17T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha3 release of the Arquillian Transaction Extension component!

What is Arquillian?

Release details

Component	Arquillian Transaction Extension
Version	1.0.0.Alpha3 view tag
Release date	2012-11-16
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final ShrinkWrap Resolvers – 2.0.0-alpha-1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-transaction-api jar pom
org.jboss.arquillian.extension » arquillian-transaction-bom pom
org.jboss.arquillian.extension » arquillian-transaction-impl-base jar pom
org.jboss.arquillian.extension » arquillian-transaction-jta jar pom
org.jboss.arquillian.extension » arquillian-transaction-spi jar pom

Release notes and resolved issues 3

Container Transactions and Default mode

Enhancement

ARQ-1185 - Transaction extension should also work for in-container tests
ARQ-1186 - Default transaction mode should be configurable through arquillian.xml

Thanks to the following list of contributors: Bartosz Majsak, Aslak Knutsen

Devoxx 2012 Hackergarten Overdrive!

2012-11-16T00:00:00Z

Kick-off

Each project represented at Hackergarten briefly introduced itself and presented ideas to hack on. The presence of Red Hat community projects was very strong (~75%). We’re happy to report that there was lots of interest in Arquillian. It received the most votes for hacking, with JBoss Forge drawing in the second most.

General impressions

The Hackergarten was held in open areas at the back of the pavilion. The areas gave plenty of privacy, but also gave people freedom to move around. We didn’t have to experience that awkwardness of peeking through a door or the distraction of doors opening and closing. We were able to do demos in one section without affecting hacks or discussions going on in other sections because there was enough ambient noise, mostly music from the trade floor. The wired connections provided by switches at each table removed the distraction of getting on wifi, although it took a bit of time and some shuffling around in the morning to figure all that out.

Once we knew to get everyone plugged into the switches, we were off to the hacking races!

Pictures!

See more pictures in Album 1 and Album 2.

Hacking Overview (related to testing)

Code Contributions

Arquillian Drone + FluentLenium
- Related hack: Thucydides + FluentLenium
Arquillian Gradle Plugin
Arquillian Ape demo code
Improvements to Arquillian Transaction
EJB injection for Arquillian CloudBees adapter
Bootstrap API for Thucydides
Bootstrap API for NoSQLUnit

Design Discussions

Arquillian Drone + Thucydides
Arquillian Ape + NoSQLUnit
Drools rules, Drools decision tables and Drools planner for filtering, prioritizing and coordinating distribution of tests in a suite
IntelliJ support for Arquillian, JBoss Forge
Using the web browser as a “container” to incorporate JavaScript tests into a Drone test
Juzu demo and shout out to use of Arquillian for testing
Jersey looking into adoption of Arquillian in test suite
Using Thucydides for CDI test suite and supporting spec documentation

Activity Stream (related to testing)

At the start of the event, I suggested the hack idea to integrate Arquilliun Drone and FluentLenium to Jan Papoušek
- Jan and I introduced ourselves to Mathilde Lemee and they got to work on the integration straight away, starting off by sharing with each other how their respective projects worked.
- By days end, they completed a working integration
- Mathilde also integrated FluentLenium with Thucydides (“2 CDs”); stay tuned because that integration and the integration with Drone may become one and the same
- In both cases, the integration with FluentLenium was so straightforward (and thus hackable) because of the nice abstraction layer Mathilde created that handled bootstrapping FluentLenium
Aslak hacked with Hans Dockter, creator of Gradle, on a gradle deployment plugin that uses Arquillian Containers to handle life cycle of dozens of containers (application servers, servlet containers and beyond)
Bartosz Majsak hacked on a demo for Arquillian Ape and enhanced Arquillian Transaction to work both in-container and embedded
I spoke with two of the IntelliJ developers (Peter and Yann) about:
- a plugin for Arquillian (similar to the Eclipse Arquillian plugin)
- adding an embedded Forge shell with UI interplay (similar to the JBoss Forge view in JBoss Tools)
I chatted with Julien Viet about:
- use of Arquillian for testing portlets in isolation and within the portal container
- treating the web browser as a “container” to incorporate JavaScript testing into a Drone test (prototype, proposal)
Later in the day, Julien gave a presentation and demo of Juzu, excited to say it’s tested w/ Arquillian Core and Arquillian Drone
I brainstormed with Geoffrey De Smet, lead of Drools Planner, about:
- using rules to handle the filtering decision for tests
- the role decision tables can play in declaring conditions for which tests to run
- optimizing test suite execution using Drools Planner and distributing tests over a grid
I spoke with John Smart about Arquillian Core and Arquillian Drone integration with Thucydides
- We discussed how much the two projects align and what it would take to integrate
- We concluded the first step is adding a bootstrap API in Thucydides, which he began to flesh out, that could be hooked to the Arquillian event model and all the integrations with individual test runners can be done once in Arquillian
- We talked about how Drone could likely provide management of WebDriver
- John Smart has been busy all week working on a bootstrap API for Thucydides (hacking on it with an ATDD approach, of course)
Koen Aers gave a demonstration of the JBoss Forge integration in JBoss Tools, talked about each of elements it brings to the Forge experience in the IDE
- Koen wrote his first “Hello, World” IntelliJ plugin to get spun up and prepare to help with the integration
- IntelliJ said they would put it on their roadmap and support the effort where possible
Alex Soto and Bartosz discussed integrating NoSQLUnit into Arquillian Ape (peristence extension)
- These projects closely align and it pushes Arquillian’s definition of container management forward
- I told Marek Jelen about Alex’s NoSQLUnit demo of testing MongoDB on OpenShift through the port forwarding setup by JBoss Tools; a blog entry may be in the works;
- Arquillian + NoSQLUnit has lots of application, one of which may be testing NoSQL backends in the Infinispan project
Alexis Hassler was busy improving the Arquillian adapter for CloudBees by adding EJB injection support.
Aslak discussed with JAX-RS lead about using Arquillian for JAX-RS TCK; not likely soon, but Jersey is entertaining idea of using Arquillian to test Jersey (JAX-RS reference implementation)
I spoke with Paul Bakker briefly about combining the Forge Arquillian plugin and the Forge Arquillian Extension plugin into one code base
I brainstormed with David Blevins, lead of TomEE, about the role a test suite can play in the early and in-progress development of a specification
- proposed idea of using a ATDD approach where tests could be not only marked as pending (before a ref impl is in place), but also proposed, open question and alternative
- agreed that using tests can focus the discussion about the spec, clarify ambiguities & resolve different interpretations
- John Smart gave a demo of Thucydides and we contemplated using it for the CDI test suite

Wrap-up

As the event wound down, I discussed with Andres Almiray, who organized the Hackergarten, about what went on during the day, whether Hackergarten accomplished his goals. He talked about the importance of giving people a chance to make a concrete contribution, give them a win to take home with them, lower perception of a barrier to contributing. I talked to him about the fact that Hackergarten is a catalyst for ideas, some of which come into play before the event, already successful and is also ongoing throughout the week, so we’ll only know total impact once conference is over. Some ideas take time to soak. I can attest, we’re still hacking ;)

Finally, Arquillian was invited to join the Nighthacking Tour hosted by Steven Chin on on Wednesday night, so look for that coverage when it comes online.

What people were tweeting…

Bartosz Majsak (@majson) posted: #devoxx #arquillian @aslakknutsen you have some pull requests
Markus Eisele (@myfear) posted: What could be the next cool #Arquillian feature? creative @aslakknutsen at the #hackergarden http://twitpic.com/bcv2lv
Alexis Hassler (@AlexisHassler) posted: GREEN BAR on my #arquillian test. Cloudbees Container Adapter is getting further, thanks to @majson & @aslakknutsen
Aslak Knutsen (@aslakknutsen) posted: Hacking #Arquillian Container control plugin for #SBT & #Leiningen. #Gradle next…
Jan Papousek (@jan_papousek) posted: @MathildeLemee the first attempt of integration FluentLenium and Arquillian is here https://github.com/papousek/arquillian-extension-fluentlenium
Mathilde Lemee (@MathildeLemee) posted: integrating FluentLenium to Arquillian Drone with @jan_papousek
John Smart (@wakaleo) posted: Awesome concentrated hacking session with @MathildeLemee: integrating #thucydides and FluentLenium in less than 10 lines of code.
Alex Soto (@alexsotob) posted: @majson Back home ty Arquillian guys for treat me as one of your team

Get Test-Infected at Devoxx 2012

2012-11-09T00:00:00Z

It’s no suprise we’re obsessed with testing here in the Arquillian Galaxy. We’re eternally interested in sharpening our testing weapons, learning about tools that advance the frontline against the bugs, and discovering all the deep, dark code caves where bugs try to hide from testers.

This year, Devoxx, one of the premier Java developer conferences, is bringing together a large group of testing experts. Listed below are just some of the labs, workshops, and BOFs being presented at Devoxx that will enhance your bug hunting skills.

Monday, November 12, 2012

NoSQLUnit. Testing Your NoSQL Databases.

Alex Soto, Tools in Action

Unit tests should follow the FIRST rules (Fast, Isolated, Repeatable, Self-Validated and Timely). When persistence layer is under test, fast and isolated rules are the most violated. For relational database management systems, embedded databases and DbUnit framework exist to help us to not break them, but there is no like DBUnit framework for heterogeneous NoSQL systems. More »

Blast Your WebApp with Galting

Stephane Landelle and Romain Sertelon, Tools in Action

Your application is going live tomorrow, the new marketing campaign is about to start, you enjoy a margarita, life is good. Yet something keeps bugging you, are you sure your webapp won’t crash down? “Damn, forgot about the stress tests!” Traffic grows, data grows, our applications have to withstand increasing loads, so stress tests are more and more of a critical issue. More »

The Bugs Are Building Another Death Star

Multi-framework, battle hardened testers including members of Ike’s Crew, BOF

The bugs are building another Death Star. What’s our invasion plan?

Bugs don’t rest when you go to sleep. In fact, you should worry most when they are left alone. They are tireless creatures, hard at work to destroy your home. In software, it’s no different. We are at constant war with bugs. News flash, the bugs are building another Death Star and we’re just standing by! Let’s plot an invasion plan during this moderated discussion on the topic of enterprise testing. More »

Tuesday, November 13, 2012

To ATDD and Beyond! Better Automated Acceptance Testing on the JVM

John Smart, University

Test Driven Development is a game changer for developers, but Automated Acceptance Testing (ATDD) is a game changer for the whole team! More than just a testing technique, Automated Acceptance Testing is both a collaboration tool and a vital step on the road to Continuous Delivery. In this talk, you will see a real-world demo applying practical ATDD techniques to real-world projects using JBehave, Selenium 2 and Thucydides. More »

Testacular – Spectacular Test Runner for JavaScript

Vojta Jina, Tools in Action

Introduction to Testacular – test runner that makes makes testing JavaScript applications in real browsers frictionless and enjoyable. More »

JUnit Rules

Jens Schauder, Tools in Action

We all know JUnit rulez. But do you know JUnit Rules? Rules are a not so well known feature of JUnit. They allow us to encapsulate setup and teardown in a reusable package. You can manipulate the way tests get executed as well. More »

Wednesday, November 14, 2012

Testing Java Persistence Layer Done Right with Arquillian

Bartosz Majsak, Quickie

The Persistence Layer is one of the most crucial parts of enterprise applications, and we use many different frameworks and patterns to keep it clean. We write sophisticated queries and use optimization techniques to give our end users the greatest possible experience. So why is Persistence very often skipped in testing efforts? Is it really that complex and painful to setup? The Arquillian Persistence Extension removes that burden and boilerplate to make you a happy and productive programmer again. More »

Behaviour Driven Development on the JVM – A State of the Union

John Smart, Conference

Behavior Driven Development (BDD) is an increasingly popular variation on Test Driven Development, which helps developers think more about what they are testing, in terms of “executable specifications” rather than conventional tests. But there are dozens of BDD tools for the JVM out there: how do you know what to use, and when? More »

Thursday, November 15, 2012

Unitils: Full Stack Testing Solution for Enterprise Applications

Thomas De Rycke and Jeroen Horemans, Conference

Automated testing is the key to developing high quality software and maintainable codebases. How can we automate testing when data and database schemes are constantly evolving? How can we test infrastructure related components like automated e-mails without actually sending them? More »

Do You REST Assured?

Johan Haleby, Quickie

Today it’s easy to expose services as REST/HTTP with frameworks like Jersey and Spring but validating that the server actually behaves as expected can be cumbersome in Java. REST Assured is an open source Java DSL that allows you to avoid boiler-plate code to make requests and validate even complex responses in a simple manner. More »

JavaScript Unit Testing and Build Integration

Wouter Groeneveld, Conference

Unit testing has become very popular with the rise of test-first software development. Most enterprise applications contain only a small portion of javascript code, almost always completely untested. We have seen a steady increase of javascript code and frameworks lately, but for most people it’s still unclear how to (unit) test javascript, and most of all how to properly integrate these within your build environment next to other JUnit test cases. More »

Apache TomEE, Java EE 6 Web Profile on Tomcat

David Blevins, Conference

Apache TomEE is the Java EE 6 Web Profile certified version of Apache Tomcat and combines the simplicity of Tomcat with the power of Java EE. The first half of this session introduces TomEE and shows how Tomcat applications leveraging Java EE technologies can become simpler and lighter with a Java EE 6 certified solution built right on Tomcat. More »

Spock: Boldly Go Where No Test Has Gone Before

Andres Almiray, Quickie

Testing, testing, testing. We all know it has to be done but no one likes to do it. Enter Spock, a revolutionary way to writing (and thinking about) test code, that promises to wash away the pain and bring back the fun. More »

We look forword to hearing what testing tools, techniques and strategies you discover at Devoxx 2012.

Hack Idea: Fully Automate ATDD by Integrating Thucydides with Arquillian

2012-11-06T00:00:00Z

Imagine being able to organize and structure your Arquillian tests as human-readable specifications by example that describe at a high-level how the application should work, then being able to present illustrated documentation generated from a test run that gives all parties an account of the features under development and tracks feature sign-off through automation of the acceptance criteria.

This goal can be achieved by Thucydides and Arquillian joining forces. Acceptance tests will not only be agile and illustrated, but fully automated. With a proof of concept in hand, we plan to advance this combination, including substituting Arquillian Drone to manage WebDriver, at the Devoxx 2012 Hackergarten.

Introducing the candidates

What is Thucydides?

Thucydides is a testing tool that encourages developers write more flexible and reusable end-to-end acceptance tests. In the style of Acceptance Test-Driven Development, Thucydides introduces a narrative for tests that describes the high-level requirements and automates the acceptance criteria using the tests. Developers then iterate using a test-driven approach to complete the requirements (i.e., stories), as depicted in the diagram below.

By analyzing the test metadata and test results, Thucydides generates illustrated documentation that describes how the application is used in the form of high-level requirements, acceptance criteria and screenshots, and records the progress of development.

What is Arquillian?

Arquillian is open source software that empowers you to test JVM-based applications more effectively. Created to defend the software galaxy from bugs, Arquillian brings your test to the runtime so you can focus on testing your application’s behavior rather than managing the runtime. Using Arquillian, you can develop a comprehensive suite of tests from the convenience of your IDE and run them in any IDE, build tool or continuous integration environment.

What is Arquillian Drone?

Arquillian Drone is an extension to Arquillian that manages the lifecycle of browsers for the purpose of controlling them from a test, thus simplifying automated functional / acceptance testing. Drone bootstraps the tooling necessary to send commands to the browser (e.g. Selenium Server, WebDriver, etc), spawns an instance of a browser, injects the browser API into the test class to allow tests to control that instance and, finally, properly disposes of the browser instance after the test is complete.

Integration benefits

Arquillian and Thucydides as yin and yang

While Thucydides handles automation of the browser—via the WebDriver library—it does not handle deploying the application being tested, nor does it manage the lifecycle of the container to which the application is deployed. In other words, it doesn’t automate everything. That’s where Arquillian steps in.

Thucydides brings the ATDD methodology and rich test reports to Arquillian, both new features to the Arquillian ecosystem. Arquillian complements Thucydides by managing the lifecycle of the container and deploying the application (as a whole or micro-deployment) to it. These services would otherwise need to be handled by the build when using Thucydides alone.

Beyond their combined core feature set, the integration brings all of the Arquillian extensions to Thucydides tests, opening the door to services such as loading seed data into the database, measuring performance and even managing browser automation. Speaking of managing browser automation…

More powerful browser automation with Drone

Bringing Arquillian Drone into the fold provides additional benefit by introducing a more powerful and flexible choice for controlling the browser in a Thucydides test, including simplified configuration, alternatives to WebDriver and extensions (e.g., Graphene). This secondary integration between Arquillian and Thucydides also unifies the developer experience with regard to how the browser is controlled across vanilla Arquillian Drone tests and Thucydides tests (embracing the concept that each tool should focus on doing one thing well).

Basic integration between Arquillian and Thucydides is a first step and getting Drone integrated is an optional (but valuable) bonus.

How this integration helps test writers

Arquillian tests become contract deliverables by leveraging Thucydides’ language for ATDD
Test segments of the webapp in isolation (using micro-deployments)
- Accelerates acceptance testing because entire application doesn’t have to be built and deployed
Skip the build (e.g., Run As > XYZ Test in the IDE)
- automatic container lifecycle management
- deploy test archive defined in test class
- inject application (initial) URL into test
Support for multiple target environments (e.g., local, dev, qa, staging)
Write Thucydides tests using other test runners, such as TestNG and Spock
Write Thucydides tests using any Arquillian-supported programming model (CDI, Spring, etc)
Rich reports summarizing test results generated by Thucydides, something Arquillian doesn’t currently provide
Use additional Arquillian extensions in Thucydides tests
Integrated configuration (arquillian.xml) for containers and browsers*
Use alternate browser automation libraries supported by Drone*
Use Graphene page fragments to reduce boilerplate code common in acceptance tests*

* requires Drone integration

Balancing responsibility

Thucydides’ strong suit is promoting ATDD through its programming model for writing acceptance tests as specifications by example and its reporting pipeline that summarizes test results as user stories. We believe Thucydides could move faster by focusing on tools and metrics needed to facilitate ATDD, allowing Arquillian to address the need of general purpose test extensions such as alternate test runners, data loading, browser automation, programming model integration, etc. In other words, Thucydides has more freedom to focus on its core competency, as stated on its website:

Organize and structure acceptance tests, associate tests with the user stories or features that they test and generate illustrated documentation describing how the application is used based on the stories described by the tests.

Hacking on the integration

We plan to hack on this idea during the Hackergarten at Devoxx 2012. Keep in mind there is a proof of concept we can reference as a starting point, described later in this section.

John Smart, the author of Thucydides, has offered to host the integration in the Thucydides code base, which is fantastic.

When and where are we hacking?

We are going to use the free Hackergarten day at Devoxx 2012 as an opportunity to put our heads together to make progress on this integration. Here are the details:

When: Tue 13th November 2012, 09:30 – 16:30
Where: Hackergarten at Devoxx 2012 (Metropolis, Antwerpen, Belgium)
Conference URL: http://devoxx.com
Hashtag: #hackdevoxx and #arquillian
Lanyrd: http://lanyrd.com/2012/devoxx/syzdq
RSVP: Google+ Event: Arquillian Hands-On Coding at Devoxx 2012 Hackergarten
IRC: #arquillian on Freenode

We’ll also be hacking throughout the week, either at the long white “hacking” tables on the second floor of the venue or after hours at a bar. Of course, anyone is welcome to hack on this idea at anytime from anywhere. This is open source!

Who will be there hacking?

John Ferguson Smart (Thucydides Lead)
Aslak Knutsen (Arquillian Lead)
Bartosz Majsak (Arquillian team member, author of Beer Advisor)
Dan Allen (Arquillian team member)
Jan Papoušek (Arquillian Drone contributor)
Alex Soto (NoSQLUnit Lead, testing advocate)

Karel Piwko (Arquillian Drone Lead) and Vineet Reynolds (Arquillian Core and Thucydides integration) will be participating, time permitting, from afar. Feel free to reach out to them on IRC or the forums.

What we want to achieve

The following two tests are proposed milestones we want to achieve during the hack. They contrast what integration looks like without Drone to the integration with Drone. Thinking through these scenarios helps reveal integartion points that need to be exposed or refined.

The tests in this section apply to the Beer Advisor sample application.

Sample test without Drone integration

@RunWith(ThucydidesRunner.class) // or @RunWith(Arquillian.class)
      @Story(BeerAdvisorFeatures.SearchingBeers.class)
      public class SearchingBeersStory {
      
          // Thucydides members
      
          @Managed(uniqueSession = true)
          public WebDriver browser;
      
          @ManagedPages
          public Pages pages;
      
          @Steps
          public SearchingSteps searchingSteps;
      
          // Arquillian members
      
          @Deployment(testable = false)
          public static WebArchive createTestArchive() {
             return ShrinkWrap.create(WebArchive.class, "searching-beers-story.war")...;
          }
      
          @ArquillianResource
          URL deploymentUrl;
      
          // Tests
      
          @Before
          public void before_tests() {
              pages.setDefaultBaseUrl(deploymentUrl.toExternalForm());
          }
      
          @Test
          public void should_find_all_usa_beers() {
              searchingSteps.on_main_beer_advisor_page();
              searchingSteps.search_for("from usa");
              searchingSteps.should_contain_beers(new Beer("90 minute IPA"), new Beer("Mirror Pond"));
          }
      }

The following steps outline the interplay between Arquillian and Thucydides while the test executes in this scenario.

Either Arquillian or Thucydides takes over test execution and activate both frameworks
Responding to the test suite start event, Arquillian and configures and starts (or connects to) the container
Arquillian deploys test archive(s) to container
Arquillian injects the application URL into the @ArquillianResource URL inject point of the test
Thucydides spawns a browser instance using WebDriver
Thucydides executes tests, sending browser commands to WebDriver
Thucydides takes screenshots using WebDriver as the browser is interacting with the web application
Thucydides destoys the browser instance using WebDriver
Arquillian undeploys the test archive
Arquillian stops the container
Thucydides generates reports from the high-level summarizes, screenshots and test results

Any Arquillian extensions that are loaded should also work as normal.

Sample test with Drone integration

@RunWith(ThucydidesRunner.class) // or @RunWith(Arquillian.class)
      @Story(BeerAdvisorFeatures.SearchingBeers.class)
      public class SearchingBeersStory {
      
          // Thucydides members
      
          @Steps
          public SearchingSteps searchingSteps;
      
          // Arquillian members
      
          @Deployment(testable = false)
          public static WebArchive createTestArchive() {
             return ShrinkWrap.create(WebArchive.class, "searching-beers-story.war")...;
          }
      
          @Drone // may get moved to the page objects
          public WebDriver browser;
      
          // Tests
      
          @Test
          public void should_find_all_usa_beers() {
              searchingSteps.on_main_beer_advisor_page();
              searchingSteps.search_for("from usa");
              searchingSteps.should_contain_beers(new Beer("90 minute IPA"), new Beer("Mirror Pond"));
          }
      }

The following steps outline the interplay between Arquillian and Thucydides while the test executes in this scenario.

Either Arquillian or Thucydides takes over test execution and activate both frameworks
Arquillian configures and starts (or connects to) the container
Arquillian deploys test archive(s) to container
Arquillian injects the application URL into the @ArquillianResource URL injection point of the test
Arquillian Drone spawns a browser instance using the configured browser automation library (e.g., WebDriver)
Arquillian Drone sets the default base URL on the managed pages
Thucydides executes tests, sending browser commands to the browser automation library
Arquillian Drone takes screenshots as the browser is interacting with the web application
Arquillian Drone destoys the browser instance using the configured browser automation library
Arquillian undeploys the test archive
Arquillian stops the container
Thucydides generates reports from the high-level summarizes, screenshots and test results

Any Arquillian Drone extensions, such as Graphene, that are loaded should also work as normal.

Sample code to use for exploring the integration

Beer Advisor by Bartosz Majsak
Currency Exchange by Vineet Reynolds

Prior work

Vineet Reynolds has been experimenting with an integration between Thucydides and Arquillian Core. Vineet’s integration code uses a Thucydides StepListener implementation to weave the Arquillian lifecycle into the test. Tests are run using the Thucydides testrunner, while Arquillian manages the container lifecycle and performs the deployment of archives defined in the tests. The integration does not incorporate Arquillian Drone, opting to leave management of WebDriver up to Thucydides.

Aslak and Bartosz improved upon the integration and incorporated it into the Beer Advisor sample app for their JavaZone talk in September 2012. They introduced a JUnit Rule that activates the Arquillian services that run before and after each test method, such as test enrichment. A JUnit Rule is currently necessary due to insufficient hooks in Thucydides, but it gets the job done. Eventually we want to phase out the JUnit Rule because it exposes integration plumbing in the test.

Engineering challenges

Challenge #1: Unified test runner

Thucydides needs a startup API that isn’t coupled with JUnit so that Arquillian is able to perform the startup in an extension. At the moment there is a lot of setup code in the ThucydidesRunner to reproduce. The alternative is that Thucydides provides enough hooks in its StepEventBus for Arquillian to hook its own startup into the Thucydides lifecycle. In the integration prototype, a JUnit rule is used to activate Arquillian in a Thucydides test, but this is not the most elegant approach.

Ideally, the @RunWith(Arquillian.class) annotation should be enough for Arquillian to drive Thucydides if Arquillian detects Thucydides is also in use (e.g., the @Story annotation is present on the test class). This is the preferred approach since it simplifies the experience for the user across the test suite (a single @RunWith for all integration tests) and it may make the integration more compatible with extensions since Arquillian has a more sophisticated event bus.

Challenge #2: Drone integration

When Drone is integrated, the user has an option to use the browser automation library (directly or via the page object pattern) as with other Drone tests or use the page object support provided by Thucydides. Drone should be able to pass Thucydides the WebDriver instance so that Thucydides can operate its own page objects.

Ideally, the integration with Drone should cut down on as many redundant declarations in the class as possible to simplify test authoring. That means that the @Drone injection point is used to access the browser instance and and @ArquillianResource URL injection point is used to access the initial (base) url.

Karel Piwko mentioned that Drone needs a better SPI for improved integration with Arquillian Graphene, slated for 1.2.0.Final. He believes the Drone SPI will also help facilitate Thucydides integration. It also opens the door for Drone to be integrated into Thucydides on its own.

Happy hacking!

Resources

Thucydides: project page – reference guide – API documentation
Acceptance test-driven development for web applications by John Smart (JavaWorld)
Selenium 2 and Thucydides for ATDD by John Smart (JavaWorld)
Real Agile: How Real Tests Lead to Real Progress by Aslak Knutsen and Bartosz Majsak (JavaZone 2012)
How to test enterprise applications by Alex Soto (LinuxTag 2012)
Prototype of Arquillian and Thucydides integration by Vineet Reynolds
Arquillian Thucydides integration discussion post

Arquillian Container Weld 1.0.0.CR5 Released

2012-11-03T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.CR5 release of the Arquillian Container Weld component!

What is Arquillian?

Release details

Component	Arquillian Container Weld
Modules	Arquillian Weld EE Embedded 1.1.x Container Adapter Arquillian Weld SE Embedded 1.x Container Adapter Arquillian Weld SE Embedded 1.1.x Container Adapter
Version	1.0.0.CR5 view tag
Release date	2012-11-02
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.container

org.jboss.arquillian.container » arquillian-weld-ee-embedded-1.1 jar pom
org.jboss.arquillian.container » arquillian-weld-se-embedded-1 jar pom
org.jboss.arquillian.container » arquillian-weld-se-embedded-1.1 jar pom

Release notes and resolved issues 3

Minor enhancement

Feature Request

ARQ-1148 - weld-ee-container should remove duplicate entries when merging multiple beans.xml files
ARQ-1168 - Merge beans.xml files for Embedded Weld Containers

Thanks to the following list of contributors: Aslak Knutsen

Arquillian Transaction Extension 1.0.0.Alpha2 Released

2012-11-02T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian Transaction Extension component!

JTA implementation

The time has come to extract the JTA transactions support from Arquillian Persistence Extension and move it over to the Transaction Extension. It was in fact quite a natural refactoring step. This opens the possibility of providing a different transaction manager to your (not only) persistence related tests. Many thanks to Jakub Narloch for bringing the Transaction Extension to life as a top level module and helping with this release!

Future releases of the Arquillian Persistence Extension will ship with the JTA extension implementation as a dependency, but the Persistence Extension API will change to the new API from the Transaction Extension. Since the Persistence Extension is using the transaction provider SPI you will be able to change the implementation without a need to adopt your test code to whatever comes in the future.

Usage

Just include this in your dependencies to leverage the JTA implementation within the container of your choice.

pom.xml

<dependency>
        <groupId>org.jboss.arquillian.extension</groupId>
        <artifactId>arquillian-transaction-jta</artifactId>
        <version>1.0.0.Alpha2</version>
      </dependency>

New SPI hook

The TransactionEnabler interface has been introduced to the SPI. It gives the option to alternate the strategy for enabling transactions. This is particularly handy for the Persistence Extension where we automatically wrap annotations like @UsingDataSet or @ShouldMatchDataSet in a transaction. For reference you may take a look at the new SPI interface and the related tests.

That’s pretty much it! We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Transaction Extension
Version	1.0.0.Alpha2 view tag
Release date	2012-10-30
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final ShrinkWrap Resolvers – 2.0.0-alpha-1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-transaction-api jar pom
org.jboss.arquillian.extension » arquillian-transaction-bom pom
org.jboss.arquillian.extension » arquillian-transaction-impl-base jar pom
org.jboss.arquillian.extension » arquillian-transaction-jta jar pom
org.jboss.arquillian.extension » arquillian-transaction-spi jar pom

Release notes and resolved issues 6

Embedded Container and JTA support

Enhancement

ARQ-1137 - Provide a way to alter logic determining if transaction support is required
ARQ-1156 - Improve resource handling

Feature Request

ARQ-1074 - TransactionProvider should be supported on client side
ARQ-1155 - Make JNDI transaction name configurable

Sub-task

ARQ-1069 - JTA implementation for Transaction Extension

Thanks to the following list of contributors: Bartosz Majsak, Aslak Knutsen, Jakub Narloch

Arquillian Drone Extension 1.1.0.Final Released

2012-10-26T00:00:00Z

The Arquillian team is proud to announce the 1.1.0.Final release of the Arquillian Drone Extension component!

We’ve introduced new features in 1.1.0.Final while still preserving backwards compatibility with 1.0.0.Final. There’s now a much simpler way to configure Drone, better support for the Opera browser and support for browsers on iOS devices.

Significant changes since 1.0.0.Final

Browser capabilities instead of implementationClass and native capability configuration

Think of any WebDriver capability, such as opera.no_restart or acceptSSLCerts, and you can now specify it directly in arquillian.xml:

arquillian.xml

<extension qualifier=“webdriver”>

          <property name=“browserCapabilities”>opera</property>

          <property name=“opera.no_restart”>true</property>

          <property name=“acceptSSLCerts”>false</property>

      </extension>

Support for reusable browsers

Reusable browsers stay connected even if you finish the tests. This will speed up turnaroud when developing the application. Reusable browsers are based on top of remote browsers, so you’ll need Selenium Hub (run selenium-server-standalone-2.25.0.jar) running during your tests. This is how you enable them (remoteAddress is optional, default value listed here):

arquillian.xml

<extension qualifier=“webdriver”>

          <property name=“browserCapabilities”>chrome</property>

          <property name=“remoteReusable”>true</property>

          <property name=“remoteAddress”>http://localhost:4444/wd/hub</property>

      </extension>

Better support for the Opera browser

Support for browsers on iOS devices

Deprecated Arquillian Drone system properties configuration

The system properties configuration provided by Arquillian Core is now the preferred way to configure Arquillian Drone. The old style of system properties still work, but using them will produce warnings in the log and will be removed completely in a future version. Now use arq.extension.extensionName.propertyName to override a value from arquillian.xml file

I’d like to thank everybody from the community eagerly adopting new releases, discovering bugs and providing bugfixes. You guys are awesome!

We hope that you’ll enjoy the improvements. We look forward to hear your feedback in the community forums.

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.1.0.Final view tag
Release date	2012-10-24
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 9

Bug

ARQ-1048 - RemoteWebDriver ignores old configuration properties
ARQ-1110 - can't create an instance of IPhoneDriver
ARQ-1113 - Add @Deprecation to ConfigurationMapper.fromSystemConfiguration

Component Upgrade

ARQ-1170 - Update Selenium to 2.25.0

Enhancement

ARQ-929 - Drone: Switch useJavaScript to true by default
ARQ-1165 - Remove ChromeDriver tests exclusions

Feature Request

ARQ-1164 - Use default Chrome location for tests

Sub-task

ARQ-1112 - Verify Arquillian Drone can run on JDK 1.5

Thanks to the following list of contributors: Karel Piwko, Aslak Knutsen, Jan Papoušek

Arquillian Core 1.0.3.Final Released

2012-10-20T00:00:00Z

The Arquillian team is proud to announce the 1.0.3.Final release of the Arquillian Core component!

What is Arquillian?

Release details

Component	Arquillian Core
Version	1.0.3.Final view tag
Release date	2012-10-18
Released by	Aslak Knutsen
Compiled against	ShrinkWrap Core – 1.0.1 ShrinkWrap Descriptors – 2.0.0-alpha-3 JUnit – 4.8.1 TestNG – 5.14.6

Published artifacts org.jboss.arquillian

org.jboss.arquillian » arquillian-bom pom
org.jboss.arquillian.config » arquillian-config-api jar pom
org.jboss.arquillian.config » arquillian-config-impl-base jar pom
org.jboss.arquillian.config » arquillian-config-spi jar pom
org.jboss.arquillian.container » arquillian-container-impl-base jar pom
org.jboss.arquillian.container » arquillian-container-spi jar pom
org.jboss.arquillian.container » arquillian-container-test-api jar pom
org.jboss.arquillian.container » arquillian-container-test-impl-base jar pom
org.jboss.arquillian.container » arquillian-container-test-spi jar pom
org.jboss.arquillian.core » arquillian-core-api jar pom
org.jboss.arquillian.core » arquillian-core-impl-base jar pom
org.jboss.arquillian.core » arquillian-core-spi jar pom
org.jboss.arquillian.junit » arquillian-junit-container jar pom
org.jboss.arquillian.junit » arquillian-junit-core jar pom
org.jboss.arquillian.junit » arquillian-junit-standalone jar pom
org.jboss.arquillian.protocol » arquillian-protocol-jmx jar pom
org.jboss.arquillian.protocol » arquillian-protocol-servlet jar pom
org.jboss.arquillian.test » arquillian-test-api jar pom
org.jboss.arquillian.test » arquillian-test-impl-base jar pom
org.jboss.arquillian.test » arquillian-test-spi jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-cdi jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-ejb jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-initialcontext jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-resource jar pom
org.jboss.arquillian.testng » arquillian-testng-container jar pom
org.jboss.arquillian.testng » arquillian-testng-core jar pom
org.jboss.arquillian.testng » arquillian-testng-standalone jar pom

Release notes and resolved issues 3

TestNG Bug fix

Bug

ARQ-563 - @ArquillianResource in TestNG based tests causes test body not to be evaluated

Feature Request

ARQ-1102 - Publish Test Source jars to Nexus

Thanks to the following list of contributors: Aslak Knutsen, Kristoffer Richardsson, Lukas Fryc

Arquillian Portal Extension 1.0.0.Alpha2 Released

2012-10-19T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian Portal Extension component!

The Portal extension for Arquillian brings testing into the world of Portlets!

Some of the highlights in this release

URL injection of portlets by name. @PortalURL now supports defining the names of the portlets that you want rendered on the page of the injected URL. You can either specify a single portlet name, multiple, or leave it empty and it will load all portlets defined within portlets.xml onto the page. Injecting a URL of a portlet page with the MyPortlet portlet present is done by:

MyTest.java

@ArquillianResource
      @PortalURL("MyPortlet")
      URL portletPage;

Annotation for marking portlet tests. @PortalTest now represents a marker on a test class that signifies to Portal extension implementations that a portlet test is being invoked. This enables for augmenting the test deployment with whatever information is needed for particular portlet containers to enable a portlet to be tested. It has the added benefit of decoupling a test needing to inject a @PortalURL if the tests don’t require a URL to the portlet page.

Currently there are two implementations of this extension for use with Pluto and GateIn portal containers.

For examples on how to use these extensions with their respective portal containers, you can take a look at the testsuite of JBoss Portlet Bridge.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Portal Extension
Version	1.0.0.Alpha2 view tag
Release date	2012-10-17
Released by	Ken Finnigan
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-portal jar pom
org.jboss.arquillian.extension » arquillian-portal-api jar pom
org.jboss.arquillian.extension » arquillian-portal-impl jar pom
org.jboss.arquillian.extension » arquillian-portal-spi jar pom

Release notes and resolved issues 6

Bug

ARQ-961 - Error in README for the name of additional URL qualifier

Enhancement

ARQ-1117 - Support Portal URL for specific portlet or several on a page

Task

ARQ-1115 - Introduce Portal depchain
ARQ-1116 - Change references of portal container to portlet container
ARQ-1151 - Update Portal Extension to Core 1.0.2.Final

Thanks to the following list of contributors: Ken Finnigan, Thomas Delhoménie

Arquillian Container Weld 1.0.0.CR4 Released

2012-10-18T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.CR4 release of the Arquillian Container Weld component!

What is Arquillian?

Release details

Component	Arquillian Container Weld
Modules	Arquillian Weld EE Embedded 1.1.x Container Adapter Arquillian Weld SE Embedded 1.x Container Adapter Arquillian Weld SE Embedded 1.1.x Container Adapter
Version	1.0.0.CR4 view tag
Release date	2012-10-17
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.container

org.jboss.arquillian.container » arquillian-weld-ee-embedded-1.1 jar pom
org.jboss.arquillian.container » arquillian-weld-se-embedded-1 jar pom
org.jboss.arquillian.container » arquillian-weld-se-embedded-1.1 jar pom

Release notes and resolved issues 6

Bug

ARQ-753 - ShrinkWrapClassLoader does not find service provider in WAR
ARQ-817 - arquillian-weld-container does not build on Maven Default Profile
ARQ-818 - WebArchiveClassLoader only honors resource requests for Service files
ARQ-819 - Wrong criteria used for supplying Weld with WebArchiveClassLoader
ARQ-890 - WeldEEMockContainer does not clean up resources if the deployment fails

Feature Request

ARQ-1160 - Prepare Weld CR4

Thanks to the following list of contributors: Aslak Knutsen, Andrew Lee Rubinger, Jozef Hartinger, Martin Kouba

Arquillian Container Tomcat 1.0.0.CR4 Released

2012-09-25T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.CR4 release of the Arquillian Container Tomcat component!

Some of the highlights in this release

Support for nice multiline/pretty formatting of JVM-argument configuration. Additionally, you can use quotes to provide values containing spaces.

<property name="javaVmArguments">
        -Xms512m -Xmx512m
        -XX:MaxPermSize=512m
        "-Djavax.net.ssl.keyStore=/path/to your/keystore"
      </property>

Embedded Tomcat 7 is now capable of protected WAR deployment (this is usual in typical standalone server), thus some standard deployment features are now available even for embedded use, e.g.:

Deployment of an archive named “ROOT.war” to the default context “/”
Proper processing of “META-INF/context.xml” if present in the WAR.

What is Arquillian?

Release details

Component	Arquillian Container Tomcat
Modules	Arquillian Tomcat Managed 5.5.x Container Adapter Arquillian Tomcat Embedded 6.x Container Adapter Arquillian Tomcat Remote 6.x Container Adapter Arquillian Tomcat Managed 6.x Container Adapter Arquillian Tomcat Embedded 7.x Container Adapter Arquillian Tomcat Managed 7.x Container Adapter
Version	1.0.0.CR4 view tag
Release date	2012-09-24
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.container

org.jboss.arquillian.container » arquillian-tomcat-common jar pom
org.jboss.arquillian.container » arquillian-tomcat-embedded-6 jar pom
org.jboss.arquillian.container » arquillian-tomcat-embedded-7 jar pom
org.jboss.arquillian.container » arquillian-tomcat-managed-5.5 jar pom
org.jboss.arquillian.container » arquillian-tomcat-managed-6 jar pom
org.jboss.arquillian.container » arquillian-tomcat-managed-7 jar pom
org.jboss.arquillian.container » arquillian-tomcat-remote-6 jar pom

Release notes and resolved issues 4

Small bugfix release

Bug

ARQ-548 - Unable to set custom Loader for Tomcat 7 Embedded container
ARQ-1044 - The properties of tomcat container configuration in arquillian.xml are not parsed properly
ARQ-1051 - Arquillian Container Tomcat test dependency weld-servlet is not available in Maven Central

Thanks to the following list of contributors: Aslak Knutsen, Ian Brandt, Tomas Repel

Introducing Arquillian Graphene Page Fragments

2012-09-20T00:00:00Z

Tools like Arquillian Graphene, WebDriver, or just plain Selenium combined with concepts like Page Objects can help you automate your functional(integration, whatever…) web UI tests. We have already introduced some of the advances brought to you by Arquillian Graphene earlier. In this blog entry we will look a bit deeper into a new concept introduced in Arquillian Graphene 2.0.0.Alpha2; Page Fragments.

Consider the following example taken from the RichFaces component showcase. The page under test contain three Autocomplete widgets.

public class TestAutocompleteWidgets extends AbstractGrapheneTest {
      
          private JQueryLocator minCharInput = jq("input[type=text]:eq(0)");
          private JQueryLocator multipleSelectionInput = jq("input[type=text]:eq(1)");
          private JQueryLocator selectFirstFalseInput = jq("input[type=text]:eq(2)");
          private JQueryLocator selection = jq("div.rf-au-itm");
      
          @Test
          public void testFirstAutocomplete() {
      
              graphene.keyPress(minCharInput, 'a');
      
              assertFalse(graphene.isElementPresent(selection),
                  "The suggestion list should not be visible, since there is only one char!");
      
              String keys = "ar";
              graphene.focus(minCharInput);
              selenium.type(minCharInput, keys);
              guardXhr(graphene).fireEvent(minCharInput, Event.KEYPRESS);
      
              assertTrue(graphene.isVisible(selection), 
                  "The suggestion list should be visible, since there are two chars!");
      
              String actualArizona = graphene.getText(jq(selection.getRawLocator() + ":eq(0)"));
              assertEquals(actualArizona, "Arizona", "The provided suggestion should be Arizona!");
      
              String actualArkansas = graphene.getText(jq(selection.getRawLocator() + ":eq(1)"));
              assertEquals(actualArkansas, "Arkansas", "The provided suggestion should be Arkansas!");
      
          }
      
          @Test
          public void testSecondAutocomplete() {
      
              char key = 'a';
              selenium.focus(multipleSelectionInput);
              guardXhr(selenium).keyPress(multipleSelectionInput, key);
      
              assertTrue(selenium.isVisible(selection),
                  "The suggestion list should be visible, since there is correct starting char!");
      
              selenium.keyPressNative(KeyEvent.VK_ENTER);
      
              key = ' ';
              selenium.keyPress(multipleSelectionInput, key);
      
              key = 'w';
      
              selenium.focus(multipleSelectionInput);
              guardXhr(selenium).keyPress(multipleSelectionInput, key);
      
              assertTrue(selenium.isVisible(selection),
                  "The suggestion list should be visible, since there is correct starting char!");
      
              selenium.keyPressNative(KeyEvent.VK_ENTER);
      
              String actualContentOfInput = selenium.getValue(multipleSelectionInput);
              assertEquals(actualContentOfInput, "Alabama Washington", "The input should contain something else!");
          }
      
          @Test
          public void testThirdAutocomplete() {
              //similar autocomplete interactions as in the previous tests
          }
      }

Now, ask yourself the following questions:

Do you find these types of tests less robust than for example unit tests for the persistence layer?

Do you think these tests still pass when the underlying HTML change?

Do you see repeating code in the these tests?

In my opinion you should have a clean answer to all of these questions. You are probably aware that tests should be loosely coupled with the underlying HTML structure of the application under test as it makes tests more robust and changes in the HTML structure of the page will not directly affect all tests.

Let’s apply the Page Objects pattern to split the HTML structure and the test logic. The Page Object will encapsulate the HTML structure so when the HTML change, only your Page Objects has to change.

But what about when I’m testing another application that use the same Autocomplete widget?

Should I copy the part of the Page Object that interact with the Autocomplete widget and paste it around in my code?

But as you’re already thinking: this would be a major don’t-repeat-yourself violation! Is there something we could do to improve this?

Yes, there is! Arquillian Graphene Page Fragments to the rescue!

Page Fragments, what are they?

Page Fragments are any repeating part of a page, any widget, web component, etc.
They encapsulate parts of the page into reusable test components across your whole test suite.
You can differentiate each fragment by its root element and reference other elements as children of that root.
They leverage Selenium WebDriver under the hood combined with all of the killer features of Graphene.
And they come with a set of utilities which simplify using them within tests and Page Objects.

How to define Page Fragments

public class AutocompleteFragment<T> {
      
          @Root
          WebElement root;
      
          @FindBy(css = "input[type='text']")
          WebElement inputToWrite;
      
          public static final String CLASS_NAME_SUGGESTION = "rf-au-itm";
      
          public List<Suggestion<T>> getAllSuggestions(SuggestionParser<T> parser) {
              List<Suggestion<T>> allSugg = new ArrayList<Suggestion<T>>();
      
              if (areSuggestionsAvailable()) {
                  WebElement rightSuggList = getRightSuggestionList();
                  List<WebElement> suggestions = rightSuggList.findElements(
                              By.className(CLASS_NAME_SUGGESTION));
      
                  for (WebElement suggestion : suggestions) {
                      allSugg.add(parser.parse(suggestion));
                  }
              }
      
              return allSugg;
          }
      
          public List<Suggestion<T>> type(String value, SuggestionParser<T> parser) {
              List<Suggestion<T>> suggestions = new ArrayList<Suggestion<T>>();
      
              inputToWrite.sendKeys(value);
              try {
                  waitForSuggestions();
              } catch (TimeoutException ex) {
                  // no suggestions available
                  return suggestions;
              }
      
              suggestions = getAllSuggestions(parser);
              return suggestions;
          }
      
          //other handy encapsulation of Autocomplete services
      }

The example is just a snippet from the full implementation of the RichFaces Autocomplete component.

Notice the @Root annotation? The value of the root field is automatically injected by Graphene. The root field contain the root element as defined by the @FindBy annotation on the injection point of the Page Fragment in the Page Object or test. All @FindBy fields in the Page Fragment will use this root as a starting point.

The fragment implementation is pretty generic and therefore reusable in all tests in all applications that use the Autocomplete widget. A full implementation would encapsulate all the services this fragment provide, but it could for example also encapsulate browser specific interactions like submit or click actions. There are no boundaries!

Using Page Fragments and Page Objects together

Let’s rewrite the previous test to use our new Page Fragment together with our Page Object.

First we define a Page Object which contain the structure of the page under test.

public class TestPage {
          
          @FindBy(css = "div.rf-au:nth-of-type(1)")
          private AutocompleteFragment<String> autocomplete1;
      
          @FindBy(css = "div.rf-au:nth-of-type(2)")
          private AutocompleteFragment<String> autocomplete2;
      
          @FindBy(css = "div.rf-au:nth-of-type(3)")
          private AutocompleteFragment<String> autocomplete3;
      
          @FindBy(xpath = "//*[contains(@id,'sh1')]")
          private WebElement viewSourceLink;
      
          //all getters for the fields
      
          //other handy methods which you find useful when testing those three Autocomplete widgets
      }

Declaring the Page Fragment in the Page Object is the preferred option, but you can also declare the Page Fragment directly in the test if desired. The only thing you need to do is to annotate the Page Fragment object with WebDriver’s @FindBy annotation to refer to the fragment’s root DOM element. That simple!

Graphene differentiates between Page Fragments and plain WebElements in the same Page Object so they can be declared side by side. All of the initialization is done automatically, so there is no need to initialize the Page Fragments or Page Objects in the @Before method of your test case.

In this last example we see how the autocomplete widgets’s Page Fragment is used in the test case.

public class TestWhichUsesPageFragments extend AbstractTest {
      
          @Page
          private TestPage testPage;
      
          @Test
          public void testFirstAutocomplete {
              AutocompleteFragment<String> autocomplete = testPage.getAutocomplete1();
              
              autocomplete.type("a");
      
              assertFalse(autocomplete.areSuggestionsAvailable(), 
                  "The suggestion list should not be visible, since there is only one char!");
      
              String keys = "ar";
              autocomplete.type(keys);
      
              assertTrue(autocomplete.areSuggestionsAvailable(), 
                  "The suggestion list should be visible, since there are two chars!");
      
              List<Suggestion<String>> expectedSuggestions = new ArrayList<Suggestion<String>>();
              expectedSuggestions.add(new Suggestion<String>("Arizona"));
              expectedSuggestions.add(new Suggestion<String>("Arkansas"));
      
              assertEquals(autocomplete.getAllSuggestions(new StringSuggestionParser()), expectedSuggestions, 
                  "Suggestions are wrong!");
          }
      
          @Test
          public void testSecondAutocomplete() {
              AutocompleteFragment<String> autocomplete = testPage.getAutocomplete2();
      
              String key = "a";
              autocomplete.type(key);
              
              String errorMsg = "The suggestion list should be visible, since there was typed correct char ";
              assertTrue(autocomplete.areSuggestionsAvailable(), errorMsg + key);
      
              autocomplete.autocomplete(autocomplete.getFirstSuggestion());
      
              autocomplete.type(" ");
      
              key = "w"
              autocomplete.type(key);
      
              assertTrue(autocomplete.areSuggestionsAvailable(), errorMsg + key);
      
              autocomplete.autocomplete(autocomplete.getFirstSuggestion());        
      
              String actualContentOfInput = autocomplete.getInputValue();
              assertEquals(actualContentOfInput, "Alabama Washington", "The input should contain something else!");
          }
      
          @Test
          public void testThirdAutocomplete() {
              //similar autocomplete interactions as in the previous tests
          }
      }

As your application grow, the only thing that needs to change is the root references of your Page Fragments. Last but not least you will be able to make your Page Fragment availabe to be used by other tests in other applications.

To try Page Fragments check out the Graphene 2.0.0.Alpha2 release. Getting start information can be found in the Reference Documentation.

Graphene 2.0.0.Alpha2 Released

2012-09-18T00:00:00Z

The Arquillian team is proud to announce the 2.0.0.Alpha2 release of the Graphene component!

Graphene 2 is building on top of the Selenium WebDriver API and provide extensions for writing reusable, robust and AJAX-enabled tests with improved readability.

Graphene 2 uses the ideas from Graphene 1 (based on Selenium 1 API) and applies it to the world of Selenium WebDriver.

You can read more about the difference between Graphene 1 and Graphene 2 in the Reference Documentation

Features

Page Abstractions

Page abstractions allow you to abstract page functionality using the well-known Selenium design pattern Page Objects. In Graphene you can inject page objects directly into the test case using the @Page annotation.

But we take the Page Objects pattern one step further with the concept of Page Fragments . Page Fragments are reusable parts within a page encapsulated into an object similar to Page Objects. A good example of Page Fragments are JavaScript widgets or forms.

The concept of Page Fragments comes from an idea that those components share a same underlying DOM structure, the only difference between all occurences of a component is a location in a DOM tree where a component is rendered – this is denoted by the @Root annotation. You can define this root location for each concrete occurence using a @FindBy(locator) annotation.

Fluent-API for Waiting Conditions

Graphene provides a set of widely used conditions to avoid writing them repeatedly.

Request Guards

Request guards block the Selenium test execution until a network communication caused by a given action ends. Guards support blocking on HTTP and XHR (AJAX) but can also be used to verify that no such requests were done.

Under the Hood

There are some low level features exposed as API that are used by Graphene internally. While not used regularly within a normal test, can be handy to write more robust tests:

JavaScript Interface

This allows you to write a Java interface which automatically translates Java API invocations to JavaScript calls:

@JavaScript
      public interface Document {
          String getTitle();
      }

Page Extensions

Page Extensions allow you to inject arbitrary JavaScript code in the page under the test. The javascript code might help you to test complex situations as well as bring completely new features for improving testing. Graphene internally uses Page Extensions for Request Guards.

Graphene Context

Graphene allows you to obtain current thread-local context of a browser session and inject it exactly where you need. No more need for driver reference propagation.

Documentation

Last but definitely not the least addition is the great documentation for all of the features above including answers for general questions like how Selenium 1, Graphene 1, Selenium WebDriver and Graphene 2 relates to each other, what’s the relation between Graphene’s, Drone and Arquillian.

Getting Started

It’s the same as with any other Arquillian extension: open the IDE, setup the Maven dependency and you are ready to start testing!

What’s next?

In the upcoming releases, we would like to focus on more new features as well as migrate some features from Graphene 1 to Graphene 2:

Forge plugin for quick start
command interceptors
parallel browser session control
jQuery/Sizzle locators
AJAX/HTTP Communication Halter
page abstraction improvements
closer integration with the Arquillian event system
helpers for writing browser specific code

Call to Action

Let us know what you think and help us shape Graphene to be what you want it to be.

What is Arquillian?

Release details

Component	Graphene
Version	2.0.0.Alpha2 view tag
Release date	2012-09-12
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.graphene

org.jboss.arquillian.graphene » graphene-build-resources jar pom
org.jboss.arquillian.graphene » graphene-component-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-drone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-drone jar pom
org.jboss.arquillian.graphene » graphene-webdriver-ftest jar pom
org.jboss.arquillian.graphene » graphene-webdriver-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-spi jar pom

Release notes and resolved issues 30

Adopting critical functionality from Graphene 1; Page Fragments

Bug

ARQGRA-6 - Using of JQuery 1.5 causes that JQuery selectors are not escaped properly
ARQGRA-151 - Graphene.getProxyForInterfaces returns wrong proxy
ARQGRA-159 - Use Drone depchain in Graphene depchain

Component Upgrade

ARQGRA-150 - Upgrade to Arquillian Core 1.0.2.Final

Feature Request

ARQGRA-40 - Support for Component Objects pattern for Selenium 2
ARQGRA-41 - Support for Java-to-JavaScript calling interfaces
ARQGRA-62 - Umbrella: Adopt Graphene for usage of WebDriver/Selenium 2 API
ARQGRA-67 - Migrate request guards to Selenium 2
ARQGRA-71 - Adopt JavaScript injection (Page Extensions) for Selenium 2
ARQGRA-74 - Support Graphene utility in original scope with Selenium 2
ARQGRA-156 - Introduce Opera and RemoteWebDriver factory wrappers
ARQGRA-157 - Support XHR interception
ARQGRA-160 - Create a configurator for Graphene 2 using arquillian.xml
ARQGRA-161 - Introduce profile to enable execution from several browsers
ARQGRA-179 - Document difference between Graphene 1 and Graphene 2 (Selenium 1 and WebDriver)
ARQGRA-180 - Document Graphene - Getting Started
ARQGRA-181 - Document Using WebDriver
ARQGRA-182 - Document Using Drone
ARQGRA-183 - Document Testing AJAX

Task

ARQGRA-132 - Add BOM usage into documentation
ARQGRA-158 - Check and complete all documentation for all features in Alpha2
ARQGRA-163 - Refactor Graphene Webdriver SPI module
ARQGRA-171 - Refactor Component Objects - mainly make Component Obejcts as POJO
ARQGRA-172 - Documentation for Page Extensions
ARQGRA-173 - Documentation for Page Fragments
ARQGRA-175 - Documentation for JavaScript interfaces
ARQGRA-176 - Documentation for GrapheneContext and proxies
ARQGRA-177 - Documentation for Request Guards
ARQGRA-178 - Documentation for Graphene utility class
ARQGRA-186 - Rename Component Objects dependencies to Page Fragments

Thanks to the following list of contributors: Jan Papoušek, Lukas Fryc, Juraj Huska, Juraj Huska, Brian Leathem

Arquillian Drone Extension 1.1.0.CR3 Released

2012-09-12T00:00:00Z

The Arquillian team is proud to announce the 1.1.0.CR3 release of the Arquillian Drone Extension component!

After some thought we realized that the current options for configuration (and implementation for that matter) were too complicated. While browserCapabilities allowed you to ignore the implementing class of WebDriver, you were still required to remember how to set up various capabilities.

We dropped the capability configuration support as you know it from CR1 and CR2 and replaced it with something much easier to use. You can now set up the capabilities directly as they come from WebDriver.

Some of the highlights in this release

Direct capability mapping. Think of any WebDriver capability, such as opera.no_restart or acceptSSLCerts, you can now specify them directly in arquillian.xml:

arquillian.xml

<extension qualifier="webdriver">
          <property name="browserCapabilities">firefox</property>
          <property name="opera.no_restart">true</property>
          <property name="acceptSSLCerts">false</property>
      </extension>

Deprecated Arquillian Drone system properties configuration in favor of the system properties configuration provided by Arquillian Core. The old style of system properties still work, but using them will produce warnings in the log and will be removed completely in a later version.

In the previous arquilian.xml snippet, browserCapabilities would map to arquillian.webdriver.browser.capabilities. The correct way to override this property is now arq.extension.webdriver.browserCapabilities. With the new properties handling you can also provide the properties in a file by spcifying the file name in the arquillian.properties system property.

The same apply to the qualifiers support. Given the following arquillian.xml snippet you would now use arq.extension.webdriver-myqualifier.browserCapabilities instead of the legacy arquillian.webdriver.myqualifier.browser.capabilities:

arquillian.xml

<extension qualifier="webdriver-myqualifier">
          <property name="browserCapabilities">chrome</property>
      </extension>

We hope that this will make Arquillian Drone easier to use, especially for people who have already tried to use browserCapabilities.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.1.0.CR3 view tag
Release date	2012-09-10
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 7

Bug

ARQ-1047 - RemoteAddress nor Remote property does not trigger remote webdriver
ARQ-1064 - Can't set WebDriver capability with name containing '_'
ARQ-1075 - Problem with Drone when configuring WebDriver via Capabilities interface
ARQ-1090 - Remove chromeSwitches from tests
ARQ-1091 - Make capability setting in Drone easier

Component Upgrade

ARQ-1088 - Upgrade and align AS7 versions in Drone tests

Thanks to the following list of contributors: Karel Piwko, Lukas Fryc, Jan Papoušek, Aslak Knutsen

Arquillian Persistence Extension 1.0.0.Alpha5 Released

2012-09-01T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha5 release of the Arquillian Persistence Extension component!

We are back with a bunch of handy new additions and some bug fixes, so keep on reading..

Big kudos goes to Tomas Hradec for his great contribution on the “JPA Cache Eviction” support. You can now control your second level cache directly from the Arquillian tests. I would also like to thank Adrian Gonzalez, Alex Holmansky, Anton Shaykin and Christoph Rohr for their feedback which led us to fix some minor annoyances and shortcomings of APE. We are proud of the vibrant and active community around Arquillian!

Some of the highlights in this release

Instead of relying on the JPA provider you can now use your custom scripts to create the schema and populate data for each test. The only thing you have to do is decorate your test class with the following annotation:

@CreateSchema({"create-schema.sql", "populate-data.sql"})

Thanks to Tomas Hradec we have taken control over the Second Level JPA cache eviction. This initial implementation gives you a possibility to evict the cache before or after your test. Just specify which persistence unit(s) should be used by APE:

@JpaCacheEviction(entityManager = { "java:comp/env/MyPersistenceUnit" })

One of the shortcomings of the previous versions was the fact that you were always forced to provide the data source name explicitly. Either through arquillian.xml or by using the @DataSource annotation. With Alpha 5 you won’t have to. If you only use one data source in the test case, it will be inferred automatically from the persistence.xml used by your test.

You can also tell DBUnit which schema needs to be used for seeding the database. Just add the schema property to your arquillian.xml configuration as illustrated in the snippet below:

arquillian.xml

<extension qualifier="persistence-dbunit">
          <property name="schema">ape</property>
      </extension>

We’ve also extended our test suite by adding the following databases to our continuous integration pipeline

MySQL 5.5.24
PostgreSQL 9.1.4

Important change: We renamed two properties used in arquillian.xml giving them more appropriate names:
initStatement became scriptsToExecuteBeforeTest
cleanupStatement became scriptsToExecuteAfterTest
Moreover you can now specify list of scripts (or files) seperated by comma.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Persistence Extension
Version	1.0.0.Alpha5 view tag
Release date	2012-08-31
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.2.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-persistence-api jar pom
org.jboss.arquillian.extension » arquillian-persistence-impl jar pom
org.jboss.arquillian.extension » arquillian-persistence-integration-tests-testng jar pom

Release notes and resolved issues 22

Bug

ARQ-872 - Integration tests are failing with Glassfish 3.1.2 embedded
ARQ-901 - NPE when using @Cleanup(strategy=CleanupStrategy.USED_ROWS_ONLY)
ARQ-1083 - Closing connection might cause memory leak

Enhancement

ARQ-763 - Introduce TestNG tests
ARQ-873 - Provide flexible maven configuration for handling combination of different containers and databases
ARQ-877 - Improve DBUnit cleanup handling
ARQ-882 - Should be possible to specify data insert strategy per @Test
ARQ-885 - Improve init/cleanupStatement handling
ARQ-1017 - Update APE to Core 1.0.1.Final
ARQ-1084 - Fix failing tests in JDK7

Feature Request

ARQ-884 - Should be possible to globally define columns to be excluded when comparing data sets.
ARQ-899 - Should be able to read data source name from persistence.xml attached to test archive
ARQ-900 - Should be able to prepare database using custom scripts
ARQ-1029 - Arquillian Persistence Extension: Use specific Schema
ARQ-1058 - Implement JPA Cache eviction control
ARQ-1065 - Improve SQL script handling

Sub-task

ARQ-878 - Make default cleanup phase globally configurable
ARQ-879 - Change default cleanup strategy back to AFTER test execution
ARQ-881 - Should be possible to exclude arbitrary tables from cleanup procedure
ARQ-886 - Rename properties to more meaningful ones
ARQ-887 - Allow to use to more than one SQL script file

Thanks to the following list of contributors: Bartosz Majsak, Aslak Knutsen, Tomas Hradec

Arquillian Spring Framework Extension 1.0.0.Beta1 Released

2012-08-18T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Beta1 release of the Arquillian Spring Framework Extension component!

The first Beta release of the Arquillian Spring extension is here.

Some of the highlights in this release

Client side application context registration
Spring transaction support

Client side tests with Spring

So far the Spring extension has only allowed application context creation and bean injection to occure when the tests were deployed in a container. We wanted to bring the same functionality to the client side. With the two new annotations @SpringClientConfiguration and @SpringClientAnnotationConfiguration it is now possible to set up the application context and inject beans into Arquillian tests that are running on the client.

An example of use would be to test a deployed REST service using the Spring RestTemplate configured in the client context.

@RunWith(Arquillian.class)
      @SpringClientConfiguration("applicationContext-rest.xml")
      public class ClientRestServiceTestCase {
      
          @Deployment(testable = false)
          @OverProtocol("Servlet 3.0")
          public static Archive createTestArchive() {
              return Deployments.createWebApplication()
                      .addAsWebInfResource("mvc/web.xml", "web.xml")
                      .addAsWebInfResource("service-servlet.xml");
          }
      
          @ArquillianResource
          private URL contextPath;
      
          @Autowired
          private RestTemplate restTemplate;
      
          @Test
          public void testGetEmployees() {
      
              Employee result = restTemplate.getForObject(contextPath + "/Employees/1", Employee.class);
      
              assertEquals("The returned employee has invalid name.", "John Smith", result.getName());
          }
      }

Spring transaction support

The recent release of the Arquillian Transaction Extension allow us to control the transactional behavior of our test methods. With the help of the Spring Extension you can now control your Spring configured transaction manager using the same API. The set up is done in the normal Spring way by defining a transaction manager in the application context.

applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
      <beans xmlns="http://www.springframework.org/schema/beans"
            xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xmlns:context="http://www.springframework.org/schema/context"
            xmlns:tx="http://www.springframework.org/schema/tx"
            xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.1.xsd http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.1.xsd">
      
         <!-- Creates local entity manager factory -->
         <bean id="entityManagerFactory" class="org.springframework.orm.jpa.LocalEntityManagerFactoryBean">
             <property name="persistenceUnitName" value="ArquillianTestUnit"/>
         </bean>
      
         <!-- Enables the declarative transaction support -->
         <tx:annotation-driven transaction-manager="txManager"/>
      
         <!-- Creates transaction manager -->
         <bean id="txManager" class="org.springframework.orm.jpa.JpaTransactionManager">
             <property name="entityManagerFactory" ref="entityManagerFactory"/>
         </bean>
      
      </beans>

You define which transaction manager to use in your test class via the manager attribute on the @Transactional annotation.

@RunWith(Arquillian.class)
      @Transactional(manager = "txManager")
      @SpringConfiguration("applicationContext.xml")
      public class JpaEmployeeRepositoryTestCase {
      
          @Autowired
          private EmployeeRepository employeeRepository;
      
          @PersistenceContext
          private EntityManager entityManager;
      
          @Test
          public void testSave() {
      
              Employee employee = new Employee();
              employee.setName("Test employee");
      
              employeeRepository.save(employee);
      
              List<Employee> result = entityManager.createQuery("from Employee").getResultList();
      
              assertEquals("Two employees were expected.", 1, result.size());
          }
      }

Migrating from 1.0.0.Alpha2

Artifact arquillian-container-spring has been renamed to arquillian-service-container-spring

We look forward to your feedback on this new release on the community forums!

What is Arquillian?

Release details

Component	Arquillian Spring Framework Extension
Version	1.0.0.Beta1 view tag
Release date	2012-08-17
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.1.Final JUnit – 4.8.1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-service-container-spring jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-2.5 jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-3 jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-common jar pom
org.jboss.arquillian.extension » arquillian-service-integration-spring jar pom
org.jboss.arquillian.extension » arquillian-service-integration-spring-inject jar pom
org.jboss.arquillian.extension » arquillian-service-integration-spring-javaconfig jar pom
org.jboss.arquillian.extension » arquillian-transaction-spring jar pom
org.jboss.arquillian.extension » arquillian-warp-spring jar pom
org.jboss.arquillian.extension » arquillian-warp-spring-ftest jar pom

Release notes and resolved issues 3

Arquillian Transaction Extension support and Client side ApplicationContext creation

Feature Request

ARQ-958 - Provide support for Spring transactions
ARQ-985 - Register the Spring Extension on client side.

Thanks to the following list of contributors: Jakub Narloch, Aslak Knutsen

Arquillian Transaction Extension 1.0.0.Alpha1 Released

2012-08-14T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha1 release of the Arquillian Transaction Extension component!

Motivation

Until this point, the only special transaction support in Arquillian has come from the Arquillian Persistence Extension. But as the extension universe expand, the need for other extensions to interact with transactions expand as well. To avoid you having to deal with the individual extensions transaction support in different ways, different apis, we concluded it was time to make Transactions it’s own top level extension.

Usage

The current API takes a declarative approach to configure the transactional behavior of the Test case. By annotating the TestClass or the TestMethod with @Transactional you control how the transaction should be handled after TestMethod execution.
Should Arquillian COMMIT, ROLLBACK or DISABLE the transaction for this method?

Example:

@RunWith(Arquillian.class)
      @Transactional
      public class GreeterTestClass {
      
          public void defaultTest() throws Exception {
              // test code
          }
      
          @Transactional(TransactionMode.ROLLBACK)
          public void rollbackTest() throws Exception {
              // test code
          }
      }

SPI integration

The extension itself does not come with any implementation for a concrete transaction API, the implementations will be provided by separate modules. During execution, the transactional handling is delegated to a TransactionProvider service implementation which is registered within Arquillian. The SPI defines a set of transaction lifecycle events ((Before|After)Transaction(Started|Ended)) and a separate transactional scope (@TransactionScope) which is bound to the executing transaction.

Implementations

Besides the JTA implementation provided by the Arquillian Persistence Extension, the next extensions which will provide support is the Spring Extension. More details to come.

What is Arquillian?

Release details

Component	Arquillian Transaction Extension
Version	1.0.0.Alpha1 view tag
Release date	2012-08-13
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final ShrinkWrap Resolvers – 2.0.0-alpha-1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-transaction-api jar pom
org.jboss.arquillian.extension » arquillian-transaction-bom pom
org.jboss.arquillian.extension » arquillian-transaction-impl-base jar pom
org.jboss.arquillian.extension » arquillian-transaction-spi jar pom

Release notes and resolved issues 2

The basic setup for rollback/commit on a TestClass with multiple Manager implementation

Feature Request

ARQ-1033 - Extract the transaction support out of Arquillian Persistence Extension

Thanks to the following list of contributors: Aslak Knutsen, Jakub Narloch, Aslak Knutsen

Arquillian Core 1.0.2.Final Released

2012-07-26T00:00:00Z

The Arquillian team is proud to announce the 1.0.2.Final release of the Arquillian Core component!

Another little maintenance release in the Arquillian 1.0 series.

The @Deployment can now be defined on private and protected methods. The same package and protected support is applicable to the SPI level for service and observer implementations.

@Deployment
      static JavaArchive createDeployment() {
         ...
      }

Using environment variables in arquillian.xml is now possible via the property expression ENV.name

<container qualifier="example">
         <property name="jbossHome">${ENV.JBOSS_HOME}</property>
      </container>

Ever run into this exception? “UnsupportedOperationException: Multiple WebArchives found in X.ear. Can not determine which to enrich.”
The exception happens when the Servlet Protocol in Arquillian attempts to enrich an EnterpriseArchive for in-container testing, but multiple WebArchives were found in the Deployment, and it can’t determine which you want to test. With the help of Robert Panzer this is now supported. You can give a Protocol a hint to which Archive is under test by using the new Testable.archiveToTest(Archive) method.

@Deployment
      static EnterpriseArchive create() {
         return ShrinkWrap.create(EnterpriseArchive.class)
            .addAsModule(...some..war..)
            .addAsModule(
               Testable.archiveToTest(
                  ShrinkWrap.create(WebArchive.class)
                     .addXYZ(...)
               )
            );
      }

What is Arquillian?

Release details

Component	Arquillian Core
Version	1.0.2.Final view tag
Release date	2012-07-23
Released by	Aslak Knutsen
Compiled against	ShrinkWrap Core – 1.0.1 ShrinkWrap Descriptors – 2.0.0-alpha-3 JUnit – 4.8.1 TestNG – 5.14.6

Published artifacts org.jboss.arquillian

org.jboss.arquillian » arquillian-bom pom
org.jboss.arquillian.config » arquillian-config-api jar pom
org.jboss.arquillian.config » arquillian-config-impl-base jar pom
org.jboss.arquillian.config » arquillian-config-spi jar pom
org.jboss.arquillian.container » arquillian-container-impl-base jar pom
org.jboss.arquillian.container » arquillian-container-spi jar pom
org.jboss.arquillian.container » arquillian-container-test-api jar pom
org.jboss.arquillian.container » arquillian-container-test-impl-base jar pom
org.jboss.arquillian.container » arquillian-container-test-spi jar pom
org.jboss.arquillian.core » arquillian-core-api jar pom
org.jboss.arquillian.core » arquillian-core-impl-base jar pom
org.jboss.arquillian.core » arquillian-core-spi jar pom
org.jboss.arquillian.junit » arquillian-junit-container jar pom
org.jboss.arquillian.junit » arquillian-junit-core jar pom
org.jboss.arquillian.junit » arquillian-junit-standalone jar pom
org.jboss.arquillian.protocol » arquillian-protocol-jmx jar pom
org.jboss.arquillian.protocol » arquillian-protocol-servlet jar pom
org.jboss.arquillian.test » arquillian-test-api jar pom
org.jboss.arquillian.test » arquillian-test-impl-base jar pom
org.jboss.arquillian.test » arquillian-test-spi jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-cdi jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-ejb jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-initialcontext jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-resource jar pom
org.jboss.arquillian.testng » arquillian-testng-container jar pom
org.jboss.arquillian.testng » arquillian-testng-core jar pom
org.jboss.arquillian.testng » arquillian-testng-standalone jar pom

Release notes and resolved issues 9

Maintenance release + Multi war support

Bug

ARQ-376 - Environment configuration is overridden by arquillian.xml
ARQ-620 - arquillian-core-impl-base needs a non-optional dependency on jboss-logmanager

Enhancement

ARQ-920 - Support @Deployment on non-public member (method or field)
ARQ-921 - Make environment variables available for property replacement in configuration

Feature Request

ARQ-990 - Update dependencies to simplify downstream Fedora Packaging
ARQ-1024 - Support package private implementation
ARQ-1035 - Should support enriching a specific module in a multi module deployment

Task

ARQ-956 - Remove dependency on jboss-logging in JMX protocol

Thanks to the following list of contributors: Aslak Knutsen, Robert.panzer, Dan Allen, Thomas Diesler

Arquillian TestRunner Spock 1.0.0.Alpha2 Released

2012-07-25T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian TestRunner Spock component!

Some of the Highlights

This minor release of the intergalactic cooperation between Spock and Arquillian comes with the following updates:

Update to the latest stable version of Spock – 0.6
Update Arquillian Core to 1.0.1.Final

Smashing bugs has never been easier!

What is Arquillian?

Release details

Component	Arquillian TestRunner Spock
Version	1.0.0.Alpha2 view tag
Release date	2012-07-23
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.1.Final

Published artifacts org.jboss.arquillian.spock

org.jboss.arquillian.spock » arquillian-spock-container jar pom
org.jboss.arquillian.spock » arquillian-spock-core jar pom
org.jboss.arquillian.spock » arquillian-spock-standalone jar pom

Release notes and resolved issues 4

Bug

ARQ-895 - Arquillian config-impl-base is not a part of spock-standalone

Enhancement

ARQ-1041 - Update Spock to the lastest (0.6) version

Task

ARQ-1039 - Update Spock Test Runner to 1.0.1.Final of Arquillian Core

Thanks to the following list of contributors: Aslak Knutsen, Bartosz Majsak, Dan Allen

Arquillian Spring Framework Extension 1.0.0.Alpha2 Released

2012-07-25T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian Spring Framework Extension component!

This release contain many improvements on the existing extension, but also some new features.

Some of the highlights in this release

Warp Spring MVC Extension
Spring Embedded Container
Separated the integration capabilities

Testing Spring MVC with Warp

Arquillian Warp is a powerful tool that let you run the functional tests against your web front end and at the same time verify the internal state of your application. With this release we are introducing the Warp extension for testing Spring MVC applications that run in a real servlet container.

Let’s dive into an example of how to test a Spring MVC application using Arquillian Warp. First we need to prepare the application descriptor.

web.xml

<web-app xmlns="http://java.sun.com/xml/ns/javaee"
               xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
               xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
               version="3.0">
      
          <servlet>
              <servlet-name>welcome</servlet-name>
              <servlet-class>org.jboss.arquillian.warp.extension.spring.servlet.WarpDispatcherServlet</servlet-class>
              <load-on-startup>1</load-on-startup>
          </servlet>
      
          <servlet-mapping>
              <servlet-name>welcome</servlet-name>
              <url-pattern>*.do</url-pattern>
          </servlet-mapping>
      
      </web-app>

You’ll notice that instead of using Spring’s DispatcherServlet we instead use the WarpDispatcherServlet.

And the testing code:

LoginControllerTestCase.java

@WarpTest
      @RunWith(Arquillian.class)
      public class LoginControllerTestCase {
      
          @Drone
          WebDriver browser;
      
          @ArquillianResource
          URL contextPath;
      
          @Test
          @RunAsClient
          public void testLoginValidationErrors() {
              browser.navigate().to(contextPath + "login.do");
      
              Warp.execute(new ClientAction() {
      
                  @Override
                  public void action() {
      
                      browser.findElement(By.id("loginForm")).submit();
                  }
              }).verify(new LoginControllerValidationErrorsVerification());
          }
      
          @Test
          @RunAsClient
          public void testLoginSuccess() {
              browser.navigate().to(contextPath + "login.do");
              browser.findElement(By.id("login")).sendKeys("warp");
              browser.findElement(By.id("password")).sendKeys("warp");
      
              Warp.execute(new ClientAction() {
      
                  @Override
                  public void action() {
      
                      browser.findElement(By.id("loginForm")).submit();
                  }
              }).verify(new LoginSuccessVerification());
          }
      
          public static class LoginControllerValidationErrorsVerification extends ServerAssertion {
      
                  private static final long serialVersionUID = 1L;
      
                  @SpringMvcResource
                  private ModelAndView modelAndView;
      
                  @SpringMvcResource
                  private Errors errors;
      
                  @AfterServlet
                  public void testGetLogin() {
      
                      assertEquals("login", modelAndView.getViewName());
                      assertNotNull(modelAndView.getModel().get("userCredentials"));
                      assertEquals("Two errors were expected.", 2, errors.getAllErrors().size());
                      assertTrue("The login hasn't been validated.", errors.hasFieldErrors("login"));
                      assertTrue("The password hasn't been validated.", errors.hasFieldErrors("password"));
                  }
              }
      
          public static class LoginSuccessVerification extends ServerAssertion {
      
              private static final long serialVersionUID = 1L;
      
              @SpringMvcResource
              private ModelAndView modelAndView;
      
              @SpringMvcResource
              private Errors errors;
      
              @AfterServlet
              public void testGetLogin() {
      
                  assertEquals("welcome", modelAndView.getViewName());
                  assertFalse(errors.hasErrors());
              }
          }
      }

In the above example we are using Arquillian Drone to navigate to the login page of our application and then filling in the login form with our user credentials.

The internal state of the DispatcherServlet is caught in a SpringMvcResult object which can be injected into the ServerAssertion. We can also inject other required objects like the ModelAndView.

Spring Embedded Container

Each development cycle may end in repeatedly re-running the integration tests, each time taking significant amount of time. The embedded container was thought to aid this situation. Running the tests embedded will decrease the execution time from seconds to milliseconds. It will help testing business objects, but since it’s not a full servlet container you won’t be able to use it for testing servlet requests in a web application.

Migrating from 1.0.0.Alpha1

1.0.0.Alpha2 comes with a couple significant changes from the previous version.

The Spring integration functionality has been separated out to its own module and is now part of the arquillian-service-integration-spring-inject module, and additional the arquillian-service-integration-spring-inject and the arquillian-service-integration-spring-javaconfig that does not target any specific Spring version, but rather provide functionality like XML or Java-based configuration.
The arquillian-service-deployer-spring module’s can still be used for autopackging the Spring artifacts.
The @SpringAnnotatedConfiguration has been renamed to @SpringAnnotationConfiguration.

Roadmap

The next release is planned to include Spring transaction support and will introduce even better Warp integration on the client side in order make REST testing even simpler.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Spring Framework Extension
Version	1.0.0.Alpha2 view tag
Release date	2012-07-21
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.1.Final JUnit – 4.8.1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-container-spring jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-2.5 jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-3 jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-common jar pom
org.jboss.arquillian.extension » arquillian-service-integration-spring jar pom
org.jboss.arquillian.extension » arquillian-service-integration-spring-inject jar pom
org.jboss.arquillian.extension » arquillian-service-integration-spring-javaconfig jar pom
org.jboss.arquillian.extension » arquillian-warp-spring jar pom
org.jboss.arquillian.extension » arquillian-warp-spring-ftest jar pom

Release notes and resolved issues 5

Spring Embedded Container + Warp

Feature Request

ARQ-219 - Implement an embedded Spring container
ARQ-945 - Extract Spring Integration out of Spring Deployer
ARQ-978 - Provide Warp with extension for testing SpringMVC.

Task

ARQ-1019 - Spring Extension: Update the Arquiilian Core to 1.0.1

Thanks to the following list of contributors: Jakub Narloch, Aslak Knutsen

Arquillian Drone Extension 1.1.0.CR2 Released

2012-07-24T00:00:00Z

The Arquillian team is proud to announce the 1.1.0.CR2 release of the Arquillian Drone Extension component!

Some of the Highlights in This Release

Drone 1.1.0.CR2 is a bugfix release form the previous 1.1.0 CR release. We fixed browserCapability usage, reusing browers sessions and Selenium Server user extensions support.

Big thanks to the community

I’d like to thank Arquillian Drone Community, especially Ste Gr and Simon Søndergaard for helping us test and patch the release by proactively using new features.
It’s a pleasure to work with you guys!

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.1.0.CR2 view tag
Release date	2012-07-18
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 6

Bug

ARQ-1021 - Internet Explorer could not be created from capabilities
ARQ-1022 - BrowserCapability overrides direct @Drone class type
ARQ-1023 - Selenium Server does not load user extensions
ARQ-1026 - Selenium session is not persisted to a file store when file does not exists
ARQ-1030 - Driving capabilities using arquillin.xml does not work
ARQ-1031 - Drone doesn't remove non-reusable sessions from the queue

Thanks to the following list of contributors: Karel Piwko, Lukas Fryc, Simon Søndergaard, Jan Papoušek

Arquillian Drone Extension 1.1.0.CR1 Released

2012-06-28T00:00:00Z

The Arquillian team is proud to announce the 1.1.0.CR1 release of the Arquillian Drone Extension component!

Some of the Highlights in This Release

underlying Selenium upgraded to 2.24.1
support for Opera browser added
webdriver configuration improved
reusable session for RemoteWebDriver introduced

Configuration Improvement

Have you ever been stucked because you didn’t remember full qualified class name of the webdriver you wanted to use in your tests? Last Drone version required setting of implementationClass property and we should admit it wasn’t really comfortable. So we present a new property called browserCapabilities which can have the following values: android, chrome, firefox, htmlUnit, internetExplorer, iphone and opera. The values correspond to the factory methods of DesiredCapabilities class.

We have also enabled webdriver configuration via Capabilities interface. Now you can use the configuration as you know it from documentation of each webdriver. Use capability prefix and camel case instead of dots in the property name to set the capability value.

So assume you want to use Firefox browser and specify the path to its binary file. We know webdriver.firefox.bin configuration property from FirefoxDriver documention.

arquillian.xml

<extension qualifier="webdriver">
          <property name="browserCapabilities">firefox</property>
          <property name="capabilityWebdriverFirefoxBin">/path/to/my/firefox/installation/firefox</property>
      </extension>

Reusable Session for RemoteWebDriver

To increase your productivity in test development Drone presents a new feature to reuse session from previous test execution. Skip creating a new session to save your time. You can check the speed-up in the following table. The table contains time needed to run a test (including deployment on JBoss AS 7.1.1.Final).

	Common Session	Reusable Session
Firefox	3.98 ± 0.27 s	2.15 ± 0.15 s
Google Chrome	4.75 ± 0.03 s	2.57 ± 0.05 s

The feature requires standalone selenium server running, remoteReusable enabled and remoteAddress pointed to your selenium server.

<extension qualifier="webdriver">
          <property name="browserCapabilities">firefox</property>
          <property name="remoteReusable">true</property>
          <property name="remoteAddress">http://localhost:4444/wd/hub</property>
      </extension>

Using the reusable session the browser stays open after the test completion, so all its settings are kept alive. If you need to debug your tests on the client side, you can easily prepare break points in the browser and run tests with remoteReusable flag.

After the proper configuration of reusable session RemoteWebDriver will be chosen automatically. That means you have to use compatible types in your test code (WebDriver ideally).

public void testMethod(@Drone WebDriver driver) {
          // test code
      }

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.1.0.CR1 view tag
Release date	2012-06-27
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 6

Support for Reusable sessions

Feature Request

ARQ-847 - Support OperaDriver in Drone
ARQ-926 - Fast development turnaround using Selenium Server and RemoteWebDriver session reusal
ARQ-995 - Allow Arquillian Drone configuration to map java.util.Map for property values

Task

ARQ-868 - Update Selenium version to 2.24.1
ARQ-970 - Drone: Merge tests for reusable remote session

Sub-task

ARQ-927 - Configuration for RemoteWebDriver Drone extension

Thanks to the following list of contributors: Lukas Fryc, Jan Papoušek, Karel Piwko, Aslak Knutsen

Arquillian Extension Byteman 1.0.0.Alpha2 Released

2012-06-06T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha2 release of the Arquillian Extension Byteman component!

What is Arquillian?

Release details

Component	Arquillian Extension Byteman
Version	1.0.0.Alpha2 view tag
Release date	2012-06-05
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.1.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-extension-byteman jar pom

Release notes and resolved issues 2

Support for Client JVM instrumentation

Feature Request

ARQ-737 - Support Byteman Rules in client mode

Thanks to the following list of contributors: Aslak Knutsen

Arquillian Core 1.0.1.Final Released

2012-06-02T00:00:00Z

The Arquillian team is proud to announce the 1.0.1.Final release of the Arquillian Core component!

The first maintenance release of the Arquillian 1.0 series is out. The release focus mainly on fixing some dependency scope problems introduced in the 1.0.0.Final Arquillian BOM.

The following components have been upgraded, which are defined in the Arquillian BOM:

ShrinkWrap 1.0.1
ShrinkWrap Resolver 1.0.0-beta-7
ShrinkWrap Descriptors 2.0.0-alpha-3

What is Arquillian?

Release details

Component	Arquillian Core
Version	1.0.1.Final view tag
Release date	2012-06-01
Released by	Aslak Knutsen
Compiled against	ShrinkWrap Core – 1.0.1 ShrinkWrap Descriptors – 2.0.0-alpha-3 JUnit – 4.8.1 TestNG – 5.14.6

Published artifacts org.jboss.arquillian

org.jboss.arquillian » arquillian-bom pom
org.jboss.arquillian.config » arquillian-config-api jar pom
org.jboss.arquillian.config » arquillian-config-impl-base jar pom
org.jboss.arquillian.config » arquillian-config-spi jar pom
org.jboss.arquillian.container » arquillian-container-impl-base jar pom
org.jboss.arquillian.container » arquillian-container-spi jar pom
org.jboss.arquillian.container » arquillian-container-test-api jar pom
org.jboss.arquillian.container » arquillian-container-test-impl-base jar pom
org.jboss.arquillian.container » arquillian-container-test-spi jar pom
org.jboss.arquillian.core » arquillian-core-api jar pom
org.jboss.arquillian.core » arquillian-core-impl-base jar pom
org.jboss.arquillian.core » arquillian-core-spi jar pom
org.jboss.arquillian.junit » arquillian-junit-container jar pom
org.jboss.arquillian.junit » arquillian-junit-core jar pom
org.jboss.arquillian.junit » arquillian-junit-standalone jar pom
org.jboss.arquillian.protocol » arquillian-protocol-jmx jar pom
org.jboss.arquillian.protocol » arquillian-protocol-servlet jar pom
org.jboss.arquillian.test » arquillian-test-api jar pom
org.jboss.arquillian.test » arquillian-test-impl-base jar pom
org.jboss.arquillian.test » arquillian-test-spi jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-cdi jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-ejb jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-initialcontext jar pom
org.jboss.arquillian.testenricher » arquillian-testenricher-resource jar pom
org.jboss.arquillian.testng » arquillian-testng-container jar pom
org.jboss.arquillian.testng » arquillian-testng-core jar pom
org.jboss.arquillian.testng » arquillian-testng-standalone jar pom

Release notes and resolved issues 5

Maintenance release

Bug

ARQ-793 - Arquillian config-impl-base is not a part of junit|testng-standalone
ARQ-889 - Arquillian BOM causes ShrinkWrap dependencies to be included in the lib folder of a WAR archive

Enhancement

ARQ-846 - Protect ExceptionProxy againts Non-Serializable origin

Feature Request

ARQ-971 - DeploymentGenerator should allow AuxiliaryArchiveAppenders to return null Archives

Thanks to the following list of contributors: Aslak Knutsen, Bernard Labno

Arquillian Warp 1.0.0.Alpha1 Released

2012-05-28T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha1 release of the Arquillian Warp component!

Have you ever wanted to test a web application using real HTTP requests, but still have the opportunity to verify server-side state and behavior?
Wouldn’t it be great to have the full power of Arquillian Drone, driving Selenium or WebDriver on the client, then combine that with an Arquillian in-container test?

Now you can!

Ike’s innovative army has created yet another powerful weapon for your testing arsenal, Arquillian Warp.

Testing on both sides of the request

Arquillian Warp fills the void between client-side and server-side testing. Using Warp, you can initiate an HTTP request using a client-side testing tool such as WebDriver and, in the same request cycle, execute in-container server-side tests. This powerful combination lets you cover integration across client and server.

Now you can send real requests that execute real application logic and render content in a real browser and test it end-to-end. Mocks? Who needs those? Imagine the debugging possibilities this opens up!

This may sound like sci-fi, but it’s a reality. It’s advanced alien technology for killing real bugs that you can get your hands on today!

Let’s warp to the code

We’ll start with a normal Arquillian Drone client-side test with one enhancement, a @WarpTest annotation on the test class. This extra annotation instructs Arquillian Warp to enhance the request.

@WarpTest
      @RunWith(Arquillian.class)
      public class BasicWarpTest {
          @Drone
          WebDriver browser;
      
          @ArquillianResource
          URL contextPath;
      
          @Deployment
          public static WebArchive createDeployment() { ... }
      
          @Test
          @RunAsClient
          public void test_initial_page() {
              // triggers a HTTP request to a server
              browser.navigate().to(contextPath);
              // stay tuned...
          }
      }

Note that you can use any HTTP client. For the sake of simplicity we’ve used @Drone to hook WebDriver (Selenium 2) into our test. Additionally, we’ve declared a web archive to be tested and injected its URL into the test case.

So far, we’ve defined a basic Drone test. Let’s start to warp this test so we can use it to test server-side logic as well. We begin by defining an implementation of ServerAssertion as an inner class of the test:

public static class InitialRequestAssertion extends ServerAssertion {
          @Inject
          TowelBean towel;
      
          @AfterPhase(RENDER_RESPONSE)
          public void test_initial_state() {
              // verify we are on right viewId
              assertEquals("/index.xhtml", FacesContext.getCurrentInstance().getViewRoot().getViewId());
      
              // assert the bean state
              assertNull(42, towelBean.getAnswerToLife());
          }
      }

An object of this assertion class will be later enriched on the server (i.e., TowelBean will be injected) and then the lifecycle method annotated with @AfterPhase will be invoked in an appropriate phase of the request (after the response is rendered in the JSF lifecycle). This lifecycle method is effectively our server-side test.

All we need to do now is hook this assertion class to the request that is initiated by the browser. To do that, we warp the Selenium call in a Warp action:

@Test
      @RunAsClient
      public void test_initial_page() {
          // define the client action which will lead to HTTP request
          Warp.execute(new ClientAction() {
              public void action() {
                  // the original request
                  browser.navigate().to(contextPath);
              }
          
          // enhance the subsequent HTTP request with ServerAssertion
          }).verify(new InitialRequestAssertion());
      }

That’s it! Here’s how it plays out:

The Selenium-controlled browser initiates an HTTP request
The request is trapped and enhanced with the InitialRequestAssertion object (which gets added as a payload of the request)
When the request arrives at the server, the InitialRequestAssertion assertion object is registered with Arquillian and the request lifecycle proceeds
After the response is rendered on the server, the InitialRequestAssertion object is enriched with all the required resources (EJB beans, CDI beans, Spring beans or Arquillian resources) and the lifecycle (test) method is invoked
Once the request is complete, the InitialRequestAssertion object is sent back to the client
If anything on the server-side failed (including assertions you defined), the failure is propagated back to the client and handled as a test failure

Currently, Warp supports lifecycle callbacks for the Servlet and JSF lifecycles, but it’s designed to be able to handle any server-side lifecycle.

Some of the highlights in this release

Support for Servlet events

Warp gives you the ability to test any Servlet lifecycle with these two lifecycle annotations:

@BeforeServlet – triggered before the request is processed by the Servlet
@AfterServlet – triggered after the request is processed by the Servlet

Support for JSF lifecycle events (Phaser extension)

Warp’s Phaser extension provides integration with the JSF lifecycle. You can use these lifecycle annotations to test the application in any JSF phase:

@BeforePhase(Phase) – triggered before the given JSF phase is executed
@AfterPhase(Phase) – triggered after the given JSF phase is executed

Compatible with any HTTP client: Warp works with any HTTP client: Selenium, HtmlUnit, HttpUnit, REST client, JavaScript test, Android device. No boundaries here!

Open to more protocols: Only the HTTP protocol is supported currently, but other protocols can be supported as well! (An SPI will be defined in a later releases)

Open to more frameworks: Warp is designed to support any server-side web framework based on the Servlets API

Need to know more?

You can find the complete Maven-based sample usage in the Arquillian Showcase.

Additionally, you can look at the functional tests in the Warp test suite:

Roadmap

In future releases, we’ll be looking into further improving the extension, most notably by providing framework-specific enrichments:

Injectable HttpServletRequest
Injectable FacesContext
etc.

Warp offers many possibilities for integration:

Support for wide range of server-side web frameworks (Wicket, Vaadin, GWT, Tapestry, …)
Support for alternative protocols (WebSockets)
Built-in support for variety of client-side testing tools

Call to action

If you would like to have support for your favorite web framework, you see features that are missing or you can see room for improvement, don’t hesitate and come to the Arquillian forums or the #arquillian channel on Freenode IRC!

We would love to hear your ideas and feedback for how to stretch Warp to reach beyond the boundaries of the test galaxy!

What is Arquillian?

Release details

Component	Arquillian Warp
Version	1.0.0.Alpha1 view tag
Release date	2012-05-24
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.0.Final ShrinkWrap Resolvers – 2.0.0-alpha-1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-warp-api jar pom
org.jboss.arquillian.extension » arquillian-warp-bom pom
org.jboss.arquillian.extension » arquillian-warp-build-resources jar pom
org.jboss.arquillian.extension » arquillian-warp-ftest jar pom
org.jboss.arquillian.extension » arquillian-warp-impl jar pom
org.jboss.arquillian.extension » arquillian-warp-phaser jar pom
org.jboss.arquillian.extension » arquillian-warp-phaser-ftest jar pom
org.jboss.arquillian.extension » arquillian-warp-spi jar pom

Release notes and resolved issues 9

First Release of Warp Extension

Bug

ARQ-935 - Should handle de-enrich of final fields
ARQ-943 - Should be able to detect Serialization problems

Enhancement

ARQ-931 - Warp: Define API/SPI
ARQ-933 - Warp: server exception propagation
ARQ-948 - Make the ServerAssertion abstract class to ensure future compatibility
ARQ-955 - Warp: Define BOM

Feature Request

ARQ-578 - Create a Extension for handling Server State assertion during normal Servlet/JSF requests
ARQ-957 - Add Warp Showcase sample

Thanks to the following list of contributors: Lukas Fryc, Aslak Knutsen, Ken Finnigan

Graphene 2.0.0.Alpha1 Released

2012-05-25T00:00:00Z

The Arquillian team is proud to announce the 2.0.0.Alpha1 release of the Graphene component!

What is Arquillian?

Release details

Component	Graphene
Version	2.0.0.Alpha1 view tag
Release date	2012-05-24
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.graphene

org.jboss.arquillian.graphene » graphene-build-resources jar pom
org.jboss.arquillian.graphene » graphene-selenium-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-drone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-impl jar pom
org.jboss.arquillian.graphene » graphene-webdriver-drone jar pom
org.jboss.arquillian.graphene » graphene-webdriver-ftest jar pom
org.jboss.arquillian.graphene » graphene-webdriver-impl jar pom

Release notes and resolved issues 3

Thread-local context support

Enhancement

ARQGRA-136 - Replace mockito dependency with cglib

Feature Request

ARQGRA-56 - Support Thread-Local Context with Selenium 2

Thanks to the following list of contributors: Lukas Fryc

Arquillian Spring Framework Extension 1.0.0.Alpha1 Released

2012-05-23T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha1 release of the Arquillian Spring Framework Extension component!

We’re moving the boundaries of Arquillian into a completely new area by including built-in support for testing applications that use the Spring Framework. This release is the first milestone for this extension. The focus so far has been on providing support for Spring’s core features (e.g., IoC container, data sources, persistence, transactions, javax.inject and EJB integration, etc.).

I’m working on the Spring extension for my Google Summer of Code 2012 project. This post also serves as my first status update. Coding began yesterday, but I’ve already been hard at work ;)

Some of the highlights in this release

Dependency injection

The extension provides three simple ways to enable Spring support in Arquillian test case. In other to create application context from XML simply add to the test @SpringConfiguration with locations of the XML files. Java-based config is supported as well with @SpringAnnotatedConfiguration which can be configured with concrete classes or names of packages to scan. The last possibility, @SpringWebConfiguration that allows to retrieve the application context of the specific DispatcherServlet running in the container, can be used only with web applications.

Custom context classes

There are situations when plain Spring context isn’t enough, so we allowed to register custom context classes that will be instantiated for each test. The context classes could be customized through annotations or through extension settings provided with arquillian.xml. A typical scenario would be for example running the Spring in JBoss AS using Snowdrop custom context classes.

Artifact packaging

The extension, by default, handles packaging of spring-context and spring-web automatically with each test.

Intuitive configuration

The extension can be easily configured through the arquillian.xml. All the settings like e.g. artifacts versions can be overridden here.

arquillian.xml

<extension qualifier="spring">
          <property name="autoPackage">true</property>
          <property name="springVersion">3.0.0.RELEASE</property>
          <property name="cglibVersion">2.2</property>
      
          <property name="includeSnowdrop">true</property>
          <property name="snowdropVersion">2.0.3.Final</property>
      
      <property name=“customContextClass”>org.jboss.spring.vfs.context.VFSClassPathXmlApplicationContext</property>

      </extension>

Here’s an example of a basic Spring test with Arquillian:

DefaultStockRepositoryTestCase.java

@RunWith(Arquillian.class)
      @SpringConfiguration("applicationContext.xml")
      public class DefaultStockRepositoryTestCase {
      
          @Deployment
          public static JavaArchive createTestArchive() {
              return ShrinkWrap.create(JavaArchive.class)
                      .addClasses(Stock.class, StockRepository.class, StockService.class,
                              DefaultStockRepository.class, DefaultStockService.class)
                      .addAsResource("applicationContext.xml");
          }
      
          @Autowired
          StockRepository stockRepository;
      
          @Test
          public void testSave() {
              Stock acme = createStock("Acme", "ACM", 123.21D, new Date());
              Stock redhat = createStock("Red Hat", "RHC", 59.61D, new Date());
      
              stockRepository.save(acme);
              stockRepository.save(redhat);
      
              assertTrue("The stock id hasn't been assigned.", acme.getId() > 0);
              assertTrue("The stock id hasn't been assigned.", redhat.getId() > 0);
          }
      }

For more examples on how to use these extensions and quickly get started with development you can take a look at prepared showcase. Additionally, you can browse the integration tests that are part of project source code.

For help with preparing this release, I’d like to especially thank Dan Allen, Marius Bogoevici and Aslak Knutsen for sharing their knowledge and providing helping hand.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Spring Framework Extension
Version	1.0.0.Alpha1 view tag
Release date	2012-05-22
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final JUnit – 4.8.1

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-service-deployer-spring-2.5 jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-3 jar pom
org.jboss.arquillian.extension » arquillian-service-deployer-spring-common jar pom

Release notes and resolved issues 2

Support for Spring enrichment in other Containers

Feature Request

ARQ-301 - Create a Spring framework integration (for non-standalone containers)

Thanks to the following list of contributors: Jakub Narloch, Aslak Knutsen

Arquillian Portal Extension 1.0.0.Alpha1 Released

2012-05-09T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha1 release of the Arquillian Portal Extension component!

This is the first release of a new Arquillian Extension for assisting in the complex task of testing portlets in a portal environment.

Some of the highlights in this release

Portal URL resource

Arquillian Extension Jacoco 1.0.0.Alpha3 Released

2012-04-25T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha3 release of the Arquillian Extension Jacoco component!

What is Arquillian?

Release details

Component	Arquillian Extension Jacoco
Version	1.0.0.Alpha3 view tag
Release date	2012-04-24
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-jacoco jar pom

Release notes and resolved issues 2

Upgrade Jacoco version

Feature Request

ARQ-738 - Update integration Jacoco integration to 0.5.6 level

Thanks to the following list of contributors: Aslak Knutsen, Samuel Santos

Bug killing proposals accepted for 2012 Google Summer of Code!

2012-04-24T00:00:00Z

The much anticipated announcement about which students were selected to participate in the 2012 Google Summer of Code program was published earlier today. In total, there are 1,212 students participating. We’d like to congratulate all the students accepted and wish you all best of luck this summer!

The JBoss Community is proud to be participating as an independent mentor organization for the first time this year. We were selected thanks to a strong showing of volunteer mentors and an overwhelming number of compelling and creative ideas. More than half of the ideas came from the Arquillian community ~:)

I’d like to extend a big thank you to everyone who came forward with ideas. Acceptances aside, these ideas are already helping shape the future of the various JBoss projects.

Accepted projects

The Arquillian project is excited to announce that we have 2 students participating this year!

Google granted the JBoss Community 8 student slots. From those 8 slots, Arquillian was allotted 2 slots—far less than the number of excellent proposals submitted. After much agonizing over the decision for the last week, the Arquillian mentors decided to award the slots to the following two student proposals:

Project #1

Title	Extend Arquillian to support Spring testing (beans and MVC controllers)
Student	Jakub Narloch
Mentor	Marius Bogoevici
Summary	Arquillian provides an extensible testing platform that can be used for testing any type of Java-based component. The initial focus for Arquillian was testing Java EE components, such as CDI beans, EJBs and JPA. However, Arquillian provides all the infrastructure and hooks necessary to make it an ideal testing platform for Spring applications. So the main of this project would be introducing suport for Spring testing.

Project #2

Title	Automated Visual Verification
Student	Jakub Dunia
Mentor	Lukas Fryc
Summary	Testing is important part of development. It is a procedure we need to perform many times, that is why there are many tools to automate it. There are cases where it is not that easy, like Visual Verification. Normally we need real person to check whether the web page looks good or not. The goal of this project is to write a tool that allows to easily review set of automatically collected screenshots generated by tests, and also improve existing comparision algorithms.

Jakub Narloch is already well on his way to bringing Spring testing support to Arquillian having implemented a prototype. You can read about the status of his prototype in the GSoC – Arquillian Spring integration forum thread.

Jakub Dunia, with his insight into problem solving, has already demonstrated he’ll be invaluable member of our community. The project he has chosen to support is extremely innovative, not only in scope of Arquillian, but in UI testing in general.

Congratulations Jakub * 2!

There’s an additional testing-related proposal, sponsored by the Errai team, that was also accepted:

Project #3

Title	A Jenkins plugin to visualize Jacoco code coverage reports
Student	Ognjen Bubalo
Mentor	Jonathan Fuerth
Summary	JaCoCo is a tool which generates code coverage reports based on Java unit tests. The project is about writing a Jenkins plugin to visualize JaCoCo code coverage reports.

Congratulations Ognjen!

Next steps

Jakub, Jakub and Ognjen, please contact your mentors immediately. Make a plan to communicate with your mentor regularly, at minimum, once each week. Since we’re big believers in openness, the best way to keep in touch is through a public channel such as the Arquillian development forum or the #arquillian channel on Freenode IRC.

We plan to publish status reports on these projects here at arquillian.org to allow the community to follow your progress and provide feedback. For those watching, stay tuned!

Promising proposals

Although we could only accept two proposals, there were many well-written proposals that truly deserved a slot (if only we had more to give). I’d like to thank the students for the time they spent preparing and submitting the proposals by highlighting them here. The rating shown under each proposal is the average rating (out of 5) given by the JBoss mentors who voted.

Unleash the Jester on integration tests by adding support for mutation testing in Arquillian: Student: Adam Sznajder
Rating: 5 / 5
Server-Side Performance Testing Framework reusing Arquillian Core: Student: Oliver Kišš
Rating: 4.8 / 5
RushEye Manager for Automated Visual Verification: Student: Udesh Liyanaarachchi
Rating: 4.5 / 5
Integrate Robotium into Arquillian Drone and Android extensions for complete automated application testing on Android: Student: Aleksey Shilin
Rating: 4.25 / 5
Provide an object-oriented format for defining test data for the Arquillian Persistence Extension: Student: Martin Skurla
Rating: 4 / 5
Automate JavaScript tests in an integration environment using Arquillian: Student: Chaitanya Nalla
Rating: 3.67 / 5
Provide an object-oriented format for defining test data for the Arquillian Persistence Extension: Student: Houssem
Rating: 3.67 / 5
Integrate Sahi into Arquillian Drone for automated browser testing: Student: Asanka Amarasinghe
Rating: 3.5 / 5

Despite the fact that these proposals were not accepted into GSoC, we really want to see them pursued. We view this program as an opportunity to interact with the next generation of the JBoss Community and to help them discover, or reinforce, their passion for open source. In fact, several students, including Chaitanya Nalla, have already expressed interest in contributing to Arquillian despite not being accepted to GSoC. That’s the spirit!

As Anil mentioned on the JBoss GSoC mailinglist, we’re exploring a diverse approach to enable students to continue their proposals, ranging from Red Hat summer internships to community-supported projects. Our plan is to closely track the GSoC schedule to keep the projects on track and to give you, the students, the experience the comes with completing a summer project (and likely increase your chance of being awarded a slot next year). Stay tuned for details.

What’s next?

Keep an eye on this blog for periodic progress reports about the GSoC student projects and any additional non-GSoC summer projects.

The first milestone is May 21st, when coding officially begins (trust me, these guys will be way ahead of that scheduled date). The mid-term evaluations happen mid July and the projects wrap up in mid August. See the official timeline for all the dates.

Even when GSoC ends, the community continues on! We hope summer students stay involved in the community long after the hacking days of summer.

The Danger of Embedded Containers

2012-04-14T00:00:00Z

In the Arquillian project, we’re all about real tests. There’s a good reason for this philosophy. If you use mocks or a substitute container when testing code that uses a programming model (i.e., CDI), all you can be sure of is that you’ve faked out enough functionality to get the test to work. You can’t be certain that your code works—really, truly works.

Obviously, we provide adapters for embedded containers (i.e., substitute containers). The reason is, they often do a decent enough job of simultating the real environment that we are willing to make the trade-off for its variations when we are working in development. I would expect, though, that you are also running the same tests in CI using a real container…just to get that peace of mind.

How do you know when not to use an embedded container?

If you write a test that you are positive should work, but instead throws some wacky exception, immediately stop and try the same test in a real container. For example, if you are using Embedded GlassFish, I would advise running the test in managed or remote GlassFish. The latter two adapters both use an authentic GlassFish instance. If the test passes, then you have answered the question of this section.

When the embedded container begins to act inconsistently, drop it.

As with all things, there are exceptions to the rule. If the code really should work on the embedded container, then it may be worth exploring why it isn’t. That may lead you to the discovery of a bug in the library you’re using. If debugging the library is your main concern, chase it down. If you are just trying to get a test written for your application, stop using the embedded container (or save debugging it for a rainy day).

Examples

See this thread in the Seam 3 forums for an example where the Embedded GlassFish container was acting more of a hindrence than a help. The thread includes the steps I took to get a green bar using a different GlassFish container adapter.

Markus Eisele identifies another hazard. He points out in a recent blog post that testing JPA using Embedded GlassFish is problematic because JPA weaving (in EclipseLink) does not occur:

[Weaving] only works when the entity classes to be weaved only exist in the application classloader. The combination of Embedded GlassFish, Arquillian and the Maven Surefire Plugin mix this up a bit and the end of the story is, that exactly none of your entities are enhanced at all.

Again, testing on Embedded GlassFish is not serving us well in this scenario. Graduate.

Closing thoughts

Code that uses Solder works fine on GlassFish 3.1.2, but it does not play very nicely with Embedded GlassFish—it’s just a hostile environment for CDI because of the visibility issues that come with starting an embedded container inside an existing Java process. The same goes for JPA. You end up in a minefield of class visibility and access problems, and far from making any progress writing tests (your ultimate goal).

If you want the container to start automatically like with embedded, then switch to a managed container. It works almost exactly the same as the remote container, except that Arquillian will start the standalone process at the beginning of the test execution and stop it at the end. In other words:

managed >>>> embedded

It’s clean. It’s true.

For speed of development:

remote > managed

With remote, you don’t have to wait for the container to start…and you can start it in debug mode very easily and keep it there. That’s why I say that the best container adapters for development are the remote adapters and the best adapters for CI are the managed adapters. I personally don’t like the embedded container adapters much (with the exception of embedded CDI since that’s mostly a pure standalone CDI environment).

Keep that advice in mind.

Arquillian Persistence Extension 1.0.0.Alpha4 Released

2012-04-13T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Alpha4 release of the Arquillian Persistence Extension component!

It’s been a while since the Alpha3 release. After three long months, we’re excited to announce Alpha 4 with a lot of improvements and enhancements suggested by our great community. Best of all, we finally have complete documentation in the reference guide!

I would especially like to thank Michael Brill for nailing down DBUnit clean up strategies, Pål Oliver Kristiansen and Jarek Gilewski for suggesting customization of DBUnit behaviour and Juergen Zimmermann for spotting a bug with transactional support. Last, but not least, many thanks to all who actively discussed the roadmap for next releases. There is plenty of great stuff on the way! Thank you very much for your feedback!

Some of the highlights in this release

Custom SQL scripts for cleanup

You can now use custom SQL scripts to clean your database before or after the test. For this purpose use the @CleanupUsingScript annotation and specify SQL files which have to be executed.

More flexible custom SQL scripts execution

We’ve removed the @UsingScript annotation and replaced it with the @ApplyScriptBefore and @ApplyScriptAfter annotations.

DBUnit insert strategies

You can tell DBUnit how it should insert your data. The following strategies are available:

INSERT – Performs insert of the data defined in provided data sets. This is the default strategy.
CLEAN_INSERT – Performs insert of the data defined in provided data sets, after removal of all data present in the tables referred in provided files.
REFRESH – During this operation, existing rows are updated and new ones are inserted. Entries already existing in the database which are not defined in the provided data set are not affected.
UPDATE – This strategy updates existing rows using data provided in the datasets. If the dataset contains a row which is not present in the database (identified by its primary key) then an exception is thrown.

DBUnit cleanup modes

You can specify when and how you would like your database to be cleaned. By default, your database is erased entirely before each test. If you want to control this behavior, use the @Cleanup annotation for this purpose. The following modes are currently supported:

STRICT – Cleans the entire database. This strategy might require turning off database constraints (e.g. referential integrity).
USED_ROWS_ONLY – Deletes only those entries that are defined in the datasets used for seeding.
USED_TABLES_ONLY – Deletes only those tables that are referenced in datasets.

You can also specify when you would like to invoke the cleanup procedure. For instance:

@Cleanup(phase = TestExecutionPhase.AFTER, strategy = CleanupStrategy.USED_ROWS_ONLY)

You can invoke cleanup BEFORE or AFTER the test. You can also disable cleanup by using TestExecutionPhase.NONE.

Column filtering for data set matching

@ShouldMatchDatSet has been enhanced with columnsToExclude list, where you can specify which columns shouldn’t be used for database content verification.

Nullable columns

For XML, JSON and YAML you can now set arbitary columns to null using [null] placeholder.

Separated configuration for core and (enhanced) DBUnit specific features

We provide configuration for all DBUnit properties and features as of Alpha 4! Moreover there is a split for core properties (such as default data source or JNDI of UserTransaction) and DBUnit related settings, as the example below illustrates:

arquillian.xml

<extension qualifier="persistence">
          <property name="defaultDataSource">java:app/datasources/mssql_ds</property>
          <property name="userTransactionJndi">java:jboss/UserTransaction</property>
          <property name="initStatement">scripts/mssql-identity-insert-on.sql</property>
          <property name="cleanupStatement">scripts/mssql-identity-insert-off.sql</property>
      </extension>
      
      <extension qualifier=“persistence-dbunit”>

          <property name=“datatypeFactory”>org.dbunit.ext.mssql.MsSqlDataTypeFactory</property>

          <property name=“useIdentityInsert”>true</property>

      </extension>

For complete list, please refer to the reference guide.

We look forward to hearing your feedback about this release in the community forums!

What is Arquillian?

Release details

Component	Arquillian Persistence Extension
Version	1.0.0.Alpha4 view tag
Release date	2012-04-12
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-persistence-api jar pom
org.jboss.arquillian.extension » arquillian-persistence-impl jar pom

Release notes and resolved issues 21

Bug

ARQ-721 - Compilation error in older version of JDK 6
ARQ-723 - TransactionalWrapper.afterTest() ignores SessionContext.setRollbackOnly()
ARQ-751 - Empty YML file is causing error whereas it should be simply skipped
ARQ-752 - Persistence extension is failing to enrich archive when there is no dataset defined
ARQ-765 - Update ShrinkWrap Descriptors dependency

Enhancement

ARQ-755 - Introduce annotation based db cleanup configuration
ARQ-756 - Improve error messages
ARQ-805 - Convert test method names from camel to underscore
ARQ-859 - Cleanup configuration - move dbunit related settings to its own configuration.

Feature Request

ARQ-718 - Customization for DBUnit
ARQ-719 - Enable column sensing for FlatXmlDataSet
ARQ-720 - Enable nulls for FlatXmlDataSet
ARQ-764 - Using DBUnit with IDENTITY or auto-increment columns
ARQ-777 - Should be possible to run custom scripts before and after test
ARQ-804 - Should be able to clean database using custom SQL script
ARQ-869 - Move JavaDoc from Field level to Method level for Configuration objects

Task

ARQ-757 - Document extension in confluence.

Sub-task

ARQ-771 - Global DBUnit configuration should be exposed in arquillian.xml
ARQ-772 - Introduce column filtering for data set matching
ARQ-806 - Should provide cleanup strategies to control what needs to be removed for the given test

Thanks to the following list of contributors: Bartosz Majsak, Aslak Knutsen

Graphene 1.0.0.Final Released

2012-04-12T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Final release of the Graphene component!

Graphene is joining rest of the Arquillian party, building on top of Arquillian testing platform Drone extension, both which reached their first stable version yesterday.

The Mission

Arquillian Graphene focuses on making real-browser automation a breeze.

The project was started to address simplification of covering AJAX-enabled applications with browser automation tests.

While Selenium project is focusing on unified API, integration with variety of browsers, Graphene project is addressing the real-world testing challenges:

rapid development
- straight-forward
- readable API
- fast turnaround
object-oriented
- type-safe API
- dependency injection of thread-local context
instabilities and speed of execution in continuous integration
- jQuery selectors
- request guards

Availability

The Graphene bits are available in JBoss Community artifact repository, dual-licensed under LGPL v2.1 (backward-compatibility) and ASL v2.0 (which uses rest of the Arquillian sub-projects).

For those who are already using Graphene in a Maven project, you can simply update the version to 1.0.0.Final.

You can start with the tests using our Getting Started with the JBoss Maven repository guide.

The Future

Right now we are heavily working on making the new version of Graphene 2 on the road.

Selenium 2 with its WebDriver API made huge progress with API accessibility and readability. It’s already pleasure to work with this API in Java world.

However still there are many shortcomings we are going to address with Graphene 2, building on top of concepts brought in Graphene 1 and adding new features, which opens world of new possibilities:

dependency injection of thread-local context
fast development turnaround
cross-cutting concerns (command interception)
request guards
page extensions
component objects
- extension of page objects concept
JavaScript test execution from within Selenium test

If you enjoy testing and you are unsatisfied with the current browser automation tooling, it’s perfect time to step in and help us to bring the future!

Project Links

What is Arquillian?

Release details

Component	Graphene
Version	1.0.0.Final view tag
Release date	2012-04-11
Released by	Lukas Fryc
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.graphene

org.jboss.arquillian.graphene » graphene-build-resources jar pom
org.jboss.arquillian.graphene » graphene-selenium-api jar pom
org.jboss.arquillian.graphene » graphene-selenium-drone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-junit-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-container jar pom
org.jboss.arquillian.graphene » graphene-selenium-ftest-testng-standalone jar pom
org.jboss.arquillian.graphene » graphene-selenium-impl jar pom

Release notes and resolved issues 8

Bug

ARQGRA-137 - SLF4J is no longer required

Component Upgrade

ARQGRA-140 - Upgrade to Arquillian Core/Drone 1.0.0.Final

Feature Request

ARQGRA-142 - Refactor Graphene 1 to allow addition of Graphene 2 bits
ARQGRA-143 - Add license file to the project
ARQGRA-144 - Add section about Drone/Graphene usage in Getting Started guide

Task

ARQGRA-93 - Add README to the GitHub repository
ARQGRA-139 - Blog about releasing Graphene 1 Final
ARQGRA-145 - Update dependency versions in docs

Thanks to the following list of contributors: Lukas Fryc

Arquillian Drone Extension 1.0.0.Final Released

2012-04-11T00:00:00Z

The Arquillian team is proud to announce the 1.0.0.Final release of the Arquillian Drone Extension component!

What is Arquillian?

Release details

Component	Arquillian Drone Extension
Version	1.0.0.Final view tag
Release date	2012-04-10
Released by	Aslak Knutsen
Compiled against	Arquillian Core – 1.0.0.Final

Published artifacts org.jboss.arquillian.extension

org.jboss.arquillian.extension » arquillian-drone-api jar pom
org.jboss.arquillian.extension » arquillian-drone-bom pom
org.jboss.arquillian.extension » arquillian-drone-configuration jar pom
org.jboss.arquillian.extension » arquillian-drone-impl jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium jar pom
org.jboss.arquillian.extension » arquillian-drone-selenium-depchain pom
org.jboss.arquillian.extension » arquillian-drone-selenium-server jar pom
org.jboss.arquillian.extension » arquillian-drone-spi jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver jar pom
org.jboss.arquillian.extension » arquillian-drone-webdriver-depchain pom

Release notes and resolved issues 3

Extension Drone - Final

Enhancement

ARQ-551 - Update Arquillian Drone docs

Task

ARQ-843 - Remove parent artifact from Arquillian-Drone-BOM

Thanks to the following list of contributors: Karel Piwko, Aslak Knutsen