Arquillian: An integration testing framework for Containers

We believe that integration testing should be no more complex than writing a basic unit test. We created Arquillian to realize that goal. One of the major complaints we've heard about Seam 2 testing (i.e., SeamTest) was, not that it isn't possible, but that it isn't flexible and it's difficult to setup. We wanted to correct those shortcomings with Arquillian.

Testing needs vary greatly, which is why it's so vital that, with Arquillian (and ShrinkWrap), we have decomposed the problem into its essential elements. The result is a completely flexible and portable integration testing framework.

1.2. Architecture overview

Arquillian combines a unit testing framework (JUnit or TestNG), ShrinkWrap, and one or more supported target containers (Java EE container, servlet container, Java SE CDI environment, etc) to provide a simple, flexible and pluggable integration testing environment.

The Arquillian test infrastructure

At the core, Arquillian provides a custom test runner for JUnit and TestNG that turns control of the test execution lifecycle from the unit testing framework to Arquillian. From there, Arquillian can delegate to service providers to setup the environment to execute the tests inside or against the container. An Arquillian test case looks just like a regular JUnit or TestNG test case with two declarative enhancements, which will be covered later.

Since Arquillian works by replacing the test runner, Arquillian tests can be executed using existing test IDE, Ant and Maven test plugins without any special configuration. Test results are reported just like you would expect. That's what we mean when we say using Arquillian is no more complicated than basic unit testing.

At this point, it's appropriate to pause and define the three aspects of an Arquillian test case. This terminology will help you better understand the explainations of how Arquillian works.

1. container — a runtime environment for a deployment

2. deployment — the process of dispatching an artifact to a container to make it operational

3. archive — a packaged assembly of code, configuration and resources

The test case is dispatched to the container's environment through coordination with ShrinkWrap, which is used to declaratively define a custom Java EE archive that encapsulates the test class and its dependent resources. Arquillian packages the ShrinkWrap-defined archive at runtime and deploys it to the target container. It then negotiates the execution of the test methods and captures the test results using remote communication with the server. Finally, Arquillian undeploys the test archive. We'll go into more detail about how Arquillian works in a later chapter.

So what is the target container? Some proprietary testing container that emulates the behavior of the technology (Java EE)? Nope, it's pluggable. It can be your actual target runtime, such as JBoss AS, GlassFish or Tomcat. It can even been an embedded container such as JBoss Embedded AS, GlassFish Embedded or Weld SE. All of this is made possible by a RPC-style (or local, if applicable) communication between the test runner and the environment, negotiating which tests are run, the execution, and communicating back the results. This means two things for the developer:

• You develop Arquillian tests just like you would a regular unit test and

• the container in which you run the tests can be easily swapped, or you can use each one.

With that in mind, let's consider where we are today with integration testing in Java EE and why an easy solution is needed.

The following examples demonstrate the use of Arquillian. Currently Arquillian is distributed as a Maven only project, so you'll need to grab the examples from Git. You can choose between a JUnit example and a TestNG example. In this tutorial we show you how to use both.

git clone git://github.com/arquillian/arquillian.git arquillian
cd arquillian
git checkout 1.0.0.Alpha5

cd examples/junit

cd examples/testng

Running these tests from the command line is easy. The examples run against all the servers supported by Arquillian (of course, you must choose a container that is capable of deploying EJBs for these tests). To run the test, we'll use Maven. For this tutorial, we'll use JBoss AS 6 (currently at Milestone 3), for which we use the jbossas-remote-6 profile.

First, make sure you have a copy of JBoss AS; you can download it from jboss.org. We strongly recommend you use a clean copy of JBoss AS. Unzip JBoss AS to a directory of your choice and start it; we'll use $JBOSS_HOME to refer to this location throughout the tutorial.

$ unzip jboss-6.0.0.Final.zip && mv jboss-6.0.0.Final $JBOSS_HOME && $JBOSS_HOME/bin/run.sh

Now, we tell Maven to run the tests, for both JUnit and TestNG:

$ mvn test -Pjbossas-remote-6

$ cd ../arquillian-example-junit/
$ mvn test -Pjbossas-remote-6

You can also run the tests in an IDE. We'll show you how to run the tests in Eclipse, with m2eclipse installed, next.

Before running an Arquillian test in Eclipse, you must have the plugin for the unit testing framework you are using installed. Eclipse ships with the JUnit plugin, so you are already setup if you selected JUnit. If you are writing your tests with TestNG, you need the Eclipse TestNG plugin.

Since the examples in this guide are based on a Maven 2 project, you will also need the m2eclipse plugin. Instructions for using the m2eclipse update site to add the m2eclipse plugin to Eclipse are provided on the m2eclipse home page. For more, read the m2eclipse reference guide.

Once the plugins are installed, import your Maven project into the Eclipse workspace. Before executing the test, you need to enable the profile for the target container, as we did on the command line. We'll go ahead and activate the profile globally for the project (we also need the default profile, read the note above for more). Right click on the project and select Properties. Select the Maven property sheet and in the first form field, enter jbossas-remote-6; you also need to tell Maven to not resolve dependencies from the workspace (this interferes with resource loading):

Maven settings for project

Click OK and accept the project changes. Before we execute tests, make sure that Eclipse has properly processed all the resource files by running a full build on the project by selecting Clean from Project menu. Now you are ready to execute tests.

Assuming you have JBoss AS started from running the tests on the command line, you can now execute the tests. Right click on the InjectionTestCase.java file in the Package Explorer and select Run As... > JUnit Test or Run As... > TestNG Test depending on which unit testing framework the test is using.

Running the test from Eclipse using TestNG

You can now execute all the tests from Eclipse!

import javax.ejb.EJB;

import org.jboss.arquillian.api.Deployment;

import org.jboss.arquillian.junit.Arquillian;

import org.jboss.shrinkwrap.api.ShrinkWrap;

import org.jboss.shrinkwrap.api.spec.JavaArchive;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;


@RunWith(Arquillian.class)

public class InjectionTestCase {

   @Deployment

   public static JavaArchive createTestArchive() {

      return ShrinkWrap.create(JavaArchive.class, "test.jar")

         .addClasses(GreetingManager.class, GreetingManagerBean.class);

   }


   @EJB

   private GreetingManager greetingManager;


   @Test

   public void shouldBeAbleToInjectEJB() throws Exception {

      String userName = "Earthlings";

      Assert.assertEquals(Hello " + userName, greetingManager.greet(userName));

   }

}

import javax.enterprise.inject.spi.BeanManager;

import javax.inject.Inject;

import org.jboss.arquillian.api.Deployment;

import org.jboss.arquillian.junit.Arquillian;

import org.jboss.shrinkwrap.api.ShrinkWrap;

import org.jboss.shrinkwrap.api.ArchivePaths;

import org.jboss.shrinkwrap.api.spec.JavaArchive;

import org.jboss.shrinkwrap.api.asset.EmptyAsset;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;

import com.acme.ejb.GreetingManager;

import com.acme.ejb.GreetingManagerBean;


@RunWith(Arquillian.class)

public class InjectionTestCase

{

   @Deployment

   public static JavaArchive createTestArchive() {

      return ShrinkWrap.create(JavaArchive.class, "test.jar")

         .addClasses(GreetingManager.class, GreetingManagerBean.class)

         .addAsManifestResource(EmptyAsset.INSTANCE, ArchivePaths.create("beans.xml"));

   }


   @Inject GreetingManager greetingManager;


   @Inject BeanManager beanManager;


   @Test

   public void shouldBeAbleToInjectCDI() throws Exception {

      String userName = "Earthlings";

      Assert.assertNotNull("Should have the injected the CDI bean manager", beanManager);

      Assert.assertEquals("Hello " + userName, greetingManager.greet(userName));

   }

}

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="1.0"

   xmlns="http://java.sun.com/xml/ns/persistence"

   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

   xsi:schemaLocation="

      http://java.sun.com/xml/ns/persistence

      http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">

   <persistence-unit name="users" transaction-type="JTA">

      <provider>org.hibernate.ejb.HibernatePersistence</provider>

      <jta-data-source>java:/DefaultDS</jta-data-source>

      <properties>

         <property name="hibernate.hbm2ddl.auto" value="create-drop" />

         <property name="hibernate.dialect" value="org.hibernate.dialect.HSQLDialect" />

      </properties>

   </persistence-unit>

</persistence>

public @Stateless class UserRepositoryBean implements UserRepository {

   @PersistenceContext EntityManager em;


   public void storeAndFlush(User u) {

      em.persist(u);

      em.flush();

   }


   public List<User> findByLastName(String lastName) {

      return em.createQuery("select u from User u where u.lastName = :lastName")

         .setParameter("lastName", lastName)

         .getResultList();

   }

}

public class UserRepositoryTest extends Arquillian {

   @Deployment

   public static JavaArchive createTestArchive() {

      return ShrinkWrap.create(JavaArchive.class, "test.jar")

         .addClasses(User.class, UserRepository.class, UserRepositoryBean.class)

         .addAsManifestResource(

            "test-persistence.xml", 

            ArchivePaths.create("persistence.xml"));

   }


   private static final String FIRST_NAME = "Agent";

   private static final String LAST_NAME = "Kay";


   @EJB

   private UserRepository userRepository;


   @Test

   public void testCanPersistUserObject() {

      User u = new User(FIRST_NAME, LAST_NAME);

      userRepository.storeAndFlush(u);

      

      List<User> users = userRepository.findByLastName(LAST_NAME);


      Assert.assertNotNull(users);

      Assert.assertTrue(users.size() == 1);


      Assert.assertEquals(users.get(0).getLastName(), LAST_NAME);

      Assert.assertEquals(users.get(0).getFirstName(), FIRST_NAME); 

   }

}

      

import javax.annotation.Resource;

import javax.jms.*;

import org.jboss.arquillian.api.Deployment;

import org.jboss.arquillian.junit.Arquillian;

import org.jboss.shrinkwrap.api.ShrinkWrap;

import org.jboss.shrinkwrap.api.spec.JavaArchive;

import org.junit.Assert;

import org.junit.Test;

import org.junit.runner.RunWith;

import com.acme.ejb.MessageEcho;

import com.acme.util.jms.QueueRequestor;


@RunWith(Arquillian.class)

public class InjectionTestCase {

   @Deployment

   public static JavaArchive createTestArchive() {

      return ShrinkWrap.create(JavaArchive.class, "test.jar")

         .addClasses(MessageEcho.class, QueueRequestor.class);

   }


   @Resource(mappedName = "/queue/DLQ")

   private Queue dlq;


   @Resource(mappedName = "/ConnectionFactory")

   private ConnectionFactory factory;


   @Test

   public void shouldBeAbleToSendMessage() throws Exception {


      String messageBody = "ping";


      Connection connection = factory.createConnection();

      Session session = connection.createSession(false, Session.AUTO_ACKNOWLEDGE);

      QueueRequestor requestor = new QueueRequestor((QueueSession) session, dlq);


      connection.start();


      Message request = session.createTextMessage(messageBody);

      Message response = requestor.request(request, 5000);


      Assert.assertEquals("Should have responded with same message", messageBody, ((TextMessage) response).getText());

   }

}

That should give you a taste of what Arquillian tests look like. To learn how to setup Arquillian in your application and start developing tests with it, refer to the Chapter 3, Getting started chapter.

We've promised you that integration testing with Arquillian is no more complicated than writing a unit test. Now it's time to prove it to you. In this chapter, we'll look at what is required to setup Arquillian in your project, how to write an Arquillian test case, how to execute the test case and how the test results are displayed. That sounds like a lot, but you'll be writing your own Arquillian tests in no time. (You'll also learn about Chapter 7, Debugging remote tests in Chapter 7).

<properties>

   <arquillian.version>1.0.0.Alpha5</arquillian.version>

</properties>

<dependency> 

   <groupId>javax.enterprise</groupId> 

   <artifactId>cdi-api</artifactId> 

   <version>1.0-SP1</version>  

</dependency>

<dependency> 

   <groupId>junit</groupId> 

   <artifactId>junit</artifactId> 

   <version>4.8.1</version> 

   <scope>test</scope> 

</dependency> 



<dependency>

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

   <artifactId>arquillian-junit</artifactId>

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

   <scope>test</scope>

</dependency>

<dependency> 

   <groupId>org.testng</groupId> 

   <artifactId>testng</artifactId> 

   <version>5.12.1</version> 

   <scope>test</scope> 

</dependency> 



<dependency>

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

   <artifactId>arquillian-testng</artifactId>

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

   <scope>test</scope>

</dependency>

public class TemperatureConverter {


   public double convertToCelsius(double f) {

      return ((f - 32) * 5 / 9);

   }


   public double convertToFarenheit(double c) {

      return ((c * 9 / 5) + 32);

   }


}

public static Archive<?> methodName();

@Deployment

public static JavaArchive createTestArchive() {

   return ShrinkWrap.create(JavaArchive.class, "test.jar")

      .addClasses(TemperatureConverter.class)

      .addAsManifestResource(

            new ByteArrayAsset("<beans/>".getBytes()), 

            ArchivePaths.create("beans.xml"));

}

@RunWith(Arquillian.class)

public class TemperatureConverterTest {

   @Inject

   private TemperatureConverter converter;


   @Deployment

   public static JavaArchive createTestArchive() {

      return ShrinkWrap.create(JavaArchive.class, "test.jar")

         .addClasses(TemperatureConverter.class)

         .addAsManifestResource(

            EmptyAsset.INSTANCE, 

            ArchivePaths.create("beans.xml")); 

   }


   @Test

   public void testConvertToCelsius() {

      Assert.assertEquals(converter.convertToCelsius(32d), 0d);

      Assert.assertEquals(converter.convertToCelsius(212d), 100d);

   }


   @Test

   public void testConvertToFarenheit() {

      Assert.assertEquals(converter.convertToFarenheit(0d), 32d);

      Assert.assertEquals(converter.convertToFarenheit(100d), 212d);

   }

}

public class TemperatureConverterTest extends Arquillian {

   @Inject

   private TemperatureConverter converter;


   @Deployment

   public static JavaArchive createTestArchive() {

      return ShrinkWrap.create(JavaArchive.class, "test.jar")

         .addClasses(TemperatureConverter.class)

         .addAsManifestResource(

            EmptyAsset.INSTANCE,, 

            ArchivePaths.create("beans.xml")); 

   }


   @Test

   public void testConvertToCelsius() {

      Assert.assertEquals(converter.convertToCelsius(32d), 0d);

      Assert.assertEquals(converter.convertToCelsius(212d), 100d);

   }


   @Test

   public void testConvertToFarenheit() {

      Assert.assertEquals(converter.convertToFarenheit(0d), 32d);

      Assert.assertEquals(converter.convertToFarenheit(100d), 212d);

   }

}

java.naming.factory.initial=org.jnp.interfaces.NamingContextFactory
java.naming.factory.url.pkgs=org.jboss.naming:org.jnp.interfaces 
java.naming.provider.url=jnp://localhost:1099

<profiles>

   <profile>

      <id>jbossas-remote-6</id>

      <dependencies>

         <dependency>

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

            <artifactId>arquillian-jbossas-remote-6</artifactId>

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

         </dependency>

        <dependency>

            <groupId>org.jboss.jbossas</groupId>

            <artifactId>jboss-as-client</artifactId>

            <version>6.0.0.Final</version>

            <type>pom</type>

        </dependency>

      </dependencies>

   </profile>

</profiles>

mvn test -Pjbossas-remote-6

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running TemperatureConverterTest
Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.964 sec

Results :

Tests run: 2, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESSFUL
[INFO] ------------------------------------------------------------------------

3.4. Setting up and running the test in Eclipse

Before running an Arquillian test in Eclipse, you must have the plugin for the unit testing framework you are using installed. Eclipse ships with the JUnit plugin, so you are already setup if you selected JUnit. If you are writing your tests with TestNG, you need the Eclipse TestNG plugin.

Note

Since the example in this guide is based on a Maven 2 project, you will also need the m2eclipse plugin. Instructions for using the m2eclipse update site to add the m2eclipse plugin to Eclipse are provided on the m2eclipse home page. For more, read the m2eclipse reference guide.

Once the plugins are installed, import your Maven project into the Eclipse workspace. Before executing the test, you need to enable the profile for the target container, as you did in the previous section. We'll go ahead and activate the profile globally for the project. Right click on the project and select Properties. Select the Maven property sheet and in the first form field, enter jbossas-remote-6; you also need to tell Maven to not resolve depedencies from the workspace (this interferes with resource loading):

Maven settings for project

Click OK and accept the project changes. Before we execute tests, make sure that Eclipse has properly processed all the resource files by running a full build on the project by selecting Clean from Project menu. Now you are ready to execute tests.

Right click on the TemperatureConverterTest.java file in the Package Explorer and select Run As... > JUnit Test or Run As... > TestNG Test depending on which unit testing framework the test is using.

Running the the JUnit test in Eclipse

3.5. Setting up and running the test in NetBeans

Things get even simpler when using NetBeans 6.8 or better. NetBeans ships with native Maven 2 support and, rather than including a test plugin for each unit testing framework, it has a generic test plugin which delegates to the Maven surefire plugin to execute the tests.

Import your Maven project into NetBeans. Then, look for a select menu in the main toolbar, which you can use to set the active Maven profile. Select the jbossas-remote-6 profile as shown here:

NetBeans project configuration

Now you are ready to test. Simply right click on the TemperatureConverter.java file in the Projects pane and select Test File. NetBeans will delegate to the Maven surefire plugin to execute the tests and then display the results in a result windown, showing us a pretty green bar!

Successful test report in NetBeans

As you can see, there was no special configuration necessary to execute the tests in either Eclipse or NetBeans.

Arquillian's forte is not only in its ease of use, but also in its flexibility. Good integration testing is not just about testing in any container, but rather testing in the container you are targeting. It's all too easy to kid ourselves by validating components in a specialized testing container, only to realize that the small variations causes the components fail when it comes time to deploy to the application for real. To make tests count, you want to execute them in the real container.

Arquillian supports a variety of target containers out of the box, which will be covered in this chapter. If the container you are using isn't supported, Arquillian makes it very easy to plug in your own implementation.

<profile>

   <id>%artifactId%</id>

   <dependencies>

      <dependency>

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

         <artifactId>%artifactId%</artifactId>

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

      </dependency>

   </dependencies>

</profile>

<?xml version="1.0"?>

    

<arquillian xmlns="http://jboss.com/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">



 <container qualifier="jbossas" default="true">

     <configuration>

        <property name="providerUrl">jnp://test.example.com:1099</property>

     </configuration>

     <protocol type="Servlet 3.0">

        <configuration>

            <property name="host">test.example.com</property>

            <property name="port">8181</property>

        </configuration>

     </protocol>

 </container>

</arquillian>

When you use a unit testing framework like JUnit or TestNG, your test case lives in a world on its own. That makes integration testing pretty difficult because it means the environment in which the business logic executes must be self-contained within the scope of the test case (whether at the suite, class or method level). The bonus of setting up this environment in the test falls on the developer's shoulders.

With Arquillian, you no longer have to worry about setting up the execution environment because that is all handled for you. The test will either be running in a container or a local CDI environment. But you still need some way to hook your test into this environment.

A key part of in-container integration testing is getting access the container-managed components that you plan to test. Using the Java new operator to instantiate the business class is not suitable in this testing scenario because it leaves out the declaratives services that get applied to the component at runtime. We want the real deal. Arquillian uses test enrichment to give us access to the real deal. The visible result of test enrichment is injection of container resources and beans directly into the test class.

"java:global/test.ear/test/" + fieldType.getSimpleName() + "Bean",
"java:global/test.ear/test/" + fieldType.getSimpleName(),
"java:global/test/" + fieldType.getSimpleName(),
"java:global/test/" + fieldType.getSimpleName() + "Bean",
"java:global/test/" + fieldType.getSimpleName() + "/no-interface",
"test/" + unqualified interface name + "Bean/local",
"test/" + unqualified interface name + "Bean/remote",
"test/" + unqualified interface name + "/no-interface",
unqualified interface name + "Bean/local",
unqualified interface name + "Bean/remote",
unqualified interface name + "/no-interface"

@Deployment

public static JavaArchive createTestArchive() {

   return ShrinkWrap.create("test.jar", JavaArchive.class)

      .addClass(NameOfClassUnderTest.class)

      .addAsManifestResource(new ByteArrayAsset(new byte[0]), Paths.create("beans.xml"))

This chapter walks through the details of test execution, covering both the remote and local container cases.

@Deployment(testable = true)

@Deployment(testable = false)

@RunWith(Arquillian.class)

public class LocalRunServletTestCase

{

   @Deployment(testable = false)

   public static WebArchive createDeployment() 

   {

      return ShrinkWrap.create("test.war", WebArchive.class)

               .addClass(TestServlet.class);

   }

   

   @Test

   public void shouldBeAbleToCallServlet(@ArquillianResource(TestServlet.class) URL baseUrl) throws Exception

   {

      // http://localhost:8080/test/

      String body = readAllAndClose(new URL(baseUrl, "/Test").openStream());

      

      Assert.assertEquals(

            "Verify that the servlet was deployed and returns the expected result",

            "hello",

            body);

   }

}

@Deployment(testable = true)

public static WebArchive create() 

{

}


@Test // runs in container

public void shouldBeAbleToRunOnClientSide() throws Exception 

{

}


@Test @RunAsClient // runs as client

public void shouldBeAbleToRunOnClientSide() throws Exception 

{

}

While Arquillian tests can be easily executing using existing IDE, Ant and Maven test plugins, debugging tests are not as straightforward (but by no means difficult). The extra steps documented in this chapter are only relevant for tests which are not executed in the same JVM as the test runner. These steps to not apply to tests that are run in a local bean container (e.g., Weld SE), which can be debugged just like any other unit test.

We'll assume in this chapter that you are already using Eclipse and you already have the test plugin installed for the testing framework you are using (JUnit or TestNG).

JAVA_OPTS="$JAVA_OPTS
            -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n"

set JAVA_OPTS="%JAVA_OPTS% -Xrunjdwp:transport=dt_socket,address=8787,server=y,suspend=n"

JAVA_OPTS="$JAVA_OPTS -ea"

set "JAVA_OPTS=%JAVA_OPTS% -ea"

Just because the Arquillian project uses Maven doesn't mean you have to use it to run your Arquillian tests. Arquillian is designed to have seamless integration with JUnit and TestNG without any necessary test framework configuration. That means you can use any build system that has a JUnit or TestNG task to execute your Arquillian test cases. Since most of this guide focuses on using Arquillian in a Maven build, this chapter is going to be about alternative build systems, namely Gradle and Ant.

apply plugin: JavaPlugin

apply plugin: JavaPlugin

repositories {
   mavenCentral()
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/groups/public'
}

apply plugin: JavaPlugin

buildDir = 'target/gradle-build'

repositories {
   mavenCentral()
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/groups/public'
}

apply plugin: JavaPlugin

buildDir = 'target/gradle-build'

libraryVersions = [
   junit: '4.8.1', arquillian: '1.0.0.Alpha4', jbossJavaeeSpec: '1.0.0.Beta7', weld: '1.0.1-Final',
   slf4j: '1.5.8', log4j: '1.2.14', jbossas: '6.0.0.Final', glassfish: '3.0.1-b20', cdi: '1.0-SP1'
]

...

dependencies {
   testCompile group: 'junit', name: 'junit', version: libraryVersions.junit
   testCompile group: 'org.jboss.arquillian', name: 'arquillian-junit', version: libraryVersions.arquillian
}

configurations {
   compileOnly
}

sourceSets {
   main {
      compileClasspath = configurations.compile + configurations.compileOnly
   }
   test {
      compileClasspath = compileClasspath + configurations.compileOnly
   }
}

apply plugin: JavaPlugin

buildDir = 'target/gradle-build'

libraryVersions = [
   junit: '4.8.1', arquillian: '1.0.0.Alpha3', jbossJavaeeSpec: '1.0.0.Beta7', weld: '1.0.1-Final',
   slf4j: '1.5.8', log4j: '1.2.14', jbossas: '6.0.0.Final', glassfish: '3.0.1-b20', cdi: '1.0-SP1'
]

repositories {
   mavenCentral()
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/groups/public'
}

configurations {
   compileOnly
}

sourceSets {
   main {
      compileClasspath = configurations.compile + configurations.compileOnly
   }
   test {
      compileClasspath = compileClasspath + configurations.compileOnly
   }
}

configurations {
   compileOnly
   weldEmbeddedTestRuntime { extendsFrom testRuntime }
}

dependencies {
   compileOnly group: 'javax.enterprise', name: 'cdi-api', version: libraryVersions.cdi

   testCompile group: 'junit', name: 'junit', version: libraryVersions.junit
   testCompile group: 'org.jboss.arquillian', name: 'arquillian-junit', version: libraryVersions.arquillian

   // temporarily downgrade the weld-ee-embedded-1.1 container
   weldEmbeddedTestRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-weld-ee-embedded-1.1', version: '1.0.0.Alpha3'
   weldEmbeddedTestRuntime group: 'org.jboss.spec', name: 'jboss-javaee-6.0', version: libraryVersions.jbossJavaeeSpec
   weldEmbeddedTestRuntime group: 'org.jboss.weld', name: 'weld-core', version: libraryVersions.weld
   weldEmbeddedTestRuntime group: 'org.slf4j', name: 'slf4j-log4j12', version: libraryVersions.slf4j
   weldEmbeddedTestRuntime group: 'log4j', name: 'log4j', version: libraryVersions.log4j
}

task weldEmbeddedTest(type: Test) {
   testClassesDir = sourceSets.test.classesDir
   classpath = sourceSets.test.classes + sourceSets.main.classes + configurations.weldEmbeddedTestRuntime
}

gradle weldEmbeddedTest

gradle wET

apply plugin: JavaPlugin

buildDir = 'target/gradle-build'

libraryVersions = [
   junit: '4.8.1', arquillian: '1.0.0.Alpha4', jbossJavaeeSpec: '1.0.0.Beta7', weld: '1.0.1-Final',
   slf4j: '1.5.8', log4j: '1.2.14', jbossas: '6.0.0.Final', glassfish: '3.0.1-b20', cdi: '1.0-SP1'
]

repositories {
   mavenCentral()
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/groups/public'
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/repositories/deprecated'
}

configurations {
   compileOnly
   weldEmbeddedTestRuntime { extendsFrom testRuntime }
   jbossasRemoteTestRuntime { extendsFrom testRuntime, compileOnly }
   glassfishEmbeddedTestRuntime { extendsFrom testRuntime }
}

dependencies {
   compileOnly group: 'javax.enterprise', name: 'cdi-api', version: libraryVersions.cdi

   testCompile group: 'junit', name: 'junit', version: libraryVersions.junit
   testCompile group: 'org.jboss.arquillian', name: 'arquillian-junit', version: libraryVersions.arquillian

   // temporarily downgrade the weld-ee-embedded-1.1 container
   weldEmbeddedTestRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-weld-ee-embedded-1.1', version: '1.0.0.Alpha3'
   weldEmbeddedTestRuntime group: 'org.jboss.spec', name: 'jboss-javaee-6.0', version: libraryVersions.jbossJavaeeSpec
   weldEmbeddedTestRuntime group: 'org.jboss.weld', name: 'weld-core', version: libraryVersions.weld
   weldEmbeddedTestRuntime group: 'org.slf4j', name: 'slf4j-log4j12', version: libraryVersions.slf4j
   weldEmbeddedTestRuntime group: 'log4j', name: 'log4j', version: libraryVersions.log4j

   jbossasRemoteTestRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-jbossas-remote-6', version: libraryVersions.arquillian
   jbossasRemoteTestRuntime group: 'org.jboss.jbossas', name: 'jboss-as-server', classifier: 'client', version: libraryVersions.jbossas, transitive: false
   jbossasRemoteTestRuntime group: 'org.jboss.jbossas', name: 'jboss-as-profileservice', classifier: 'client', version: libraryVersions.jbossas

   glassfishEmbeddedTestRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-glassfish-embedded-3', version: libraryVersions.arquillian
   glassfishEmbeddedTestRuntime group: 'org.glassfish.extras', name: 'glassfish-embedded-all', version: libraryVersions.glassfish
}

sourceSets {
   main {
      compileClasspath = configurations.compile + configurations.compileOnly
   }
   test {
      compileClasspath = compileClasspath + configurations.compileOnly
   }
}

task weldEmbeddedTest(type: Test) {
   testClassesDir = sourceSets.test.classesDir
   classpath = sourceSets.test.classes + sourceSets.main.classes + configurations.weldEmbeddedTestRuntime
}

task jbossasRemoteTest(type: Test) {
   testClassesDir = sourceSets.test.classesDir
   classpath = sourceSets.test.classes + sourceSets.main.classes + files('src/test/resources-jbossas') + configurations.jbossasRemoteTestRuntime
}

task glassfishEmbeddedTest(type: Test) {
   testClassesDir = sourceSets.test.classesDir
   classpath = sourceSets.test.classes + sourceSets.main.classes + configurations.glassfishEmbeddedTestRuntime
}

gradle weldEmbeddedTest jbossasRemoteTest glassfishEmbeddedTest

apply plugin: JavaPlugin

buildDir = 'target/gradle-build'

libraryVersions = [
   junit: '4.8.1', arquillian: '1.0.0.Alpha3', jbossJavaeeSpec: '1.0.0.Beta7', weld: '1.0.1-Final',
   slf4j: '1.5.8', log4j: '1.2.14', jbossas: '6.0.0.Final', glassfish: '3.0.1-b20', cdi: '1.0-SP1'
]

repositories {
   mavenCentral()
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/groups/public'
}

configurations {
   compileOnly
}

dependencies {
   group: 'org.jboss.spec', name: 'jboss-javaee-6.0', version: libraryVersions.jbossJavaeeSpec
}

sourceSets {
   main {
      compileClasspath = configurations.compile + configurations.compileOnly
   }
   test {
      compileClasspath = compileClasspath + configurations.compileOnly
   }
}

dependencies {
   // temporarily downgrade the weld-ee-embedded-1.1 container
   testRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-weld-ee-embedded-1.1', version: '1.0.0.Alpha3'
   testRuntime group: 'org.jboss.spec', name: 'jboss-javaee-6.0', version: libraryVersions.jbossJavaeeSpec
   testRuntime group: 'org.jboss.weld', name: 'weld-core', version: libraryVersions.weld
   testRuntime group: 'org.slf4j', name: 'slf4j-log4j12', version: libraryVersions.slf4j
   testRuntime group: 'log4j', name: 'log4j', version: libraryVersions.log4j
}

dependencies {
   testRuntime group: 'javax.enterprise', name: 'cdi-api', version: libraryVersions.cdi
   testRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-jbossas-remote-6', version: libraryVersions.arquillian
   testRuntime group: 'org.jboss.jbossas', name: 'jboss-as-server', classifier: 'client', version: libraryVersions.jbossas, transitive: false
   testRuntime group: 'org.jboss.jbossas', name: 'jboss-as-profileservice', classifier: 'client', version: libraryVersions.jbossas
}

test {
   classpath = sourceSets.test.classes + sourceSets.main.classes + files('src/test/resources-jbossas') + configurations.testRuntime
}

dependencies {
   testRuntime group: 'org.jboss.arquillian.container', name: 'arquillian-glassfish-embedded-3', version: libraryVersions.arquillian
   testRuntime group: 'org.glassfish.extras', name: 'glassfish-embedded-all', version: libraryVersions.glassfish
}

apply plugin: JavaPlugin

buildDir = 'target/gradle-build'

libraryVersions = [
   junit: '4.8.1', arquillian: '1.0.0.Alpha4', jbossJavaeeSpec: '1.0.0.Beta7', weld: '1.0.1-Final',
   slf4j: '1.5.8', log4j: '1.2.14', jbossas: '6.0.0.Final', glassfish: '3.0.1-b20', cdi: '1.0-SP1'
]

apply from: profile + '-profile.gradle'

repositories {
   mavenCentral()
   mavenRepo urls: 'http://repository.jboss.org/nexus/content/groups/public'
}

configurations {
   compileOnly
}

dependencies {
   compileOnly group: 'javax.enterprise', name: 'cdi-api', version: libraryVersions.cdi

   testCompile group: 'junit', name: 'junit', version: libraryVersions.junit
   testCompile group: 'org.jboss.arquillian', name: 'arquillian-junit', version: libraryVersions.arquillian
}

sourceSets {
   main {
      compileClasspath = configurations.compile + configurations.compileOnly
   }
   test {
      compileClasspath = compileClasspath + configurations.compileOnly
   }
}

gradle test -Pprofile=weld-ee-embedded

This chapter walks through some more advanced features and use cases you can have Arquillian do for you.

@Deployment(order = 1)

public static Descriptor createDep1() 

{

  return Descriptors.create(DataSourceDescriptor.class);

}


@Deployment(order = 2)

public static WebArchive createDep2() {}


@Test

public void testDataBase() {}

@ArquillianResource

private URL baseURL;


@ArquillianResource(MyServlet.class)

private URL baseServerURL;


@Test

private void shouldDoX(@ArquillianResource(MyServlet.class) URL baseURL) 

{

}

@Deployment(name = "dep1", order = 1)

public static WebArchive createDep1() {}


@Deployment(name = "dep2", order = 2)

public static WebArchive createDep2() {}


@Test @OperateOnDeployment("dep1")

public void testRunningInDep1() {}


@Test @OperateOnDeployment("dep2")

public void testRunningInDep2() {}

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>

<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">

    <group qualifier="tomcat-cluster">

        <container qualifier="container-1" default="true">

            <configuration>

                <property name="tomcatHome">target/tomcat-embedded-6-standby</property>

                <property name="workDir">work</property>

                <property name="bindHttpPort">8880</property>

                <property name="unpackArchive">true</property>

            </configuration>

            <dependencies>

                <dependency>org.jboss.arquillian.container:arquillian-tomcat-embedded-6:1.0.0.Alpha5</dependency>

                <dependency>org.apache.tomcat:catalina:6.0.29</dependency>

                <dependency>org.apache.tomcat:coyote:6.0.29</dependency>

                <dependency>org.apache.tomcat:jasper:6.0.29</dependency>

            </dependencies>

        </container>

        <container qualifier="container-2">

            <configuration>

                <property name="tomcatHome">target/tomcat-embedded-6-active-1</property>

                <property name="workDir">work</property>

                <property name="bindHttpPort">8881</property>

                <property name="unpackArchive">true</property>

            </configuration>

            <dependencies>

                <dependency>org.jboss.arquillian.container:arquillian-tomcat-embedded-6:1.0.0.Alpha5</dependency>

                <dependency>org.apache.tomcat:catalina:6.0.29</dependency>

                <dependency>org.apache.tomcat:coyote:6.0.29</dependency>

                <dependency>org.apache.tomcat:jasper:6.0.29</dependency>

            </dependencies>

        </container>

    </group>

</arquillian>

@Deployment(name = "dep1") @TargetsContainer("container-1")

public static WebArchive createDep1() {}


@Deployment(name = "dep2")  @TargetsContainer("container-2")

public static WebArchive createDep2() {}


@Test @OperateOnDeployment("dep1")

public void testRunningInDep1() {}


@Test @OperateOnDeployment("dep2")

public void testRunningInDep2() {}

@Deployment @OverProtocol("MyCustomProtocol")

public static WebArchive createDep1() {}


@Test

public void testExecutedUsingCustomProtocol() {}

Arquillian is designed to be very extensible. This is accomplished through the use of Service Provider Interfaces (SPIs). The following diagram shows how the various SPIs in Arquillian tie into the test execution.

Arquillian test execution and SPI overview