Simple EJB Arquillian test based on JUnit running on managed JBoss AS 7

I believe that every programmer understands the need for testing. We want our code to be tested and bug free, but the time is of the essence. We need tests to be easily written and executed and as exact as possible.
From my experience, testing Java EE always required a special treatment. You could either code additional means to enable launching tests from your application, or you were left with creating a test environment using for example OpenEJB for beans, something different for transactions and something else for persistence. The second approach is better, because it is more manageable and transparent, but it's downside is that the tests are run in a different environment than the one used as runtime. This means that not everything that works in tests will work when deployed on server and vice versa.

In this post I am demonstrating the power of Arquillian.

This framework enables us to run the tests easily in the runtime container our application needs. My example uses managed Jboss AS 7, but there are other possibilities.

I spend a lot of time trying to make Arquillian work in my project and now I can definitely say that it is not the way you want to start with Arquillian. The configuration is not tricky or that difficult, but you do not want to deal with more problems than necessary. That is why I am recommending you to create a new Maven project and begin exploring the Arquillian's possibilities from the simplest setup.

First goal

My first goal wast to have one EJB with one test running on JBoss AS 7. Although I personally prefer TestNG over JUnit, this example uses JUnit because Arquillian's Getting Started guide uses it. I will demonstrate usage of TestNG on a more complex example in my next post.

Step by Step

  1. Create a Maven project
  2. Setup pom.xml to support the testing
  3. Create the EJB class
  4. Create the test class
  5. Setup arquillian.xml

 

Create a Maven project

I recommend creating a special project for the tests, because there are a lot of dependencies needed for testing, but superfluous in the rest of your application.

 

Setup pom.xml

Here is my version of pom.xml. The most important parts are arquillian bom dependency management and arq-jbossas-managed profile. Dependency in dependency management org.jboss.arquillian:arquillian-bom:1.1.0.Final contains all the essential libraries needed for the launching the test. The arq-jbossas-managed profile is responsible for executing the tests.
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
 <modelVersion>4.0.0</modelVersion>
 <groupId>cz.effy.server</groupId>
 <artifactId>junit.test</artifactId>
 <version>0.0.1-SNAPSHOT</version>
 <name>test</name>
 <properties>
  <version.junit>4.8.2</version.junit>
 </properties>
 <dependencies>
  <dependency>
   <groupId>org.jboss.spec.javax.ejb</groupId>
   <artifactId>jboss-ejb-api_3.1_spec</artifactId>
   <version>1.0.1.Final</version>
   <scope>provided</scope>
  </dependency>
  <dependency>
   <groupId>javax.enterprise</groupId>
   <artifactId>cdi-api</artifactId>
   <version>1.0-SP4</version>
   <scope>provided</scope>
   <exclusions>
    <exclusion>
     <artifactId>jboss-interceptor-api</artifactId>
     <groupId>org.jboss.interceptor</groupId>
    </exclusion>
    <exclusion>
     <artifactId>jsr250-api</artifactId>
     <groupId>javax.annotation</groupId>
    </exclusion>
   </exclusions>
  </dependency>
  <dependency>
   <groupId>junit</groupId>
   <artifactId>junit</artifactId>
   <version>${version.junit}</version>
  </dependency>
  <dependency>
   <groupId>org.jboss.arquillian.junit</groupId>
   <artifactId>arquillian-junit-container</artifactId>
  </dependency>
  <dependency>
   <groupId>org.jboss.arquillian.protocol</groupId>
   <artifactId>arquillian-protocol-servlet</artifactId>
   <scope>test</scope>
  </dependency>
 </dependencies>
 <dependencyManagement>
  <dependencies>
   <dependency>
    <groupId>org.jboss.arquillian</groupId>
    <artifactId>arquillian-bom</artifactId>
    <version>1.1.0.Final</version>
    <scope>import</scope>
    <type>pom</type>
   </dependency>
  </dependencies>
 </dependencyManagement>
 <build>
  <plugins>
   <plugin>
    <artifactId>maven-compiler-plugin</artifactId>
    <version>2.3.2</version>
    <configuration>
     <encoding>UTF-8</encoding>
     <source>1.7</source>
     <target>1.7</target>
    </configuration>
   </plugin>
  </plugins>
 </build>
 <profiles>
  <profile>
   <!-- An optional Arquillian testing profile that executes tests in your 
    JBoss AS instance -->
   <!-- This profile will start a new JBoss AS instance, and execute the 
    test, shutting it down when done -->
   <id>arq-jbossas-managed</id>
   <activation>
    <activeByDefault>true</activeByDefault>
   </activation>
   <dependencies>
    <dependency>
     <groupId>org.jboss.as</groupId>
     <artifactId>jboss-as-arquillian-container-managed</artifactId>
     <version>7.1.1.Final</version>
     <scope>test</scope>
    </dependency>
   </dependencies>
  </profile>
 </profiles>
</project>

Create the EJB

I used the simplest enterprise bean I could think of ... Singleton.
package cz.effy.server.testng.test;

import javax.ejb.Singleton;

@Singleton
public class HelloBean {

 public String getHello() {
  return "Hi!";
 }

}

Test class

The test is a bit different from a regular unit test although the test method looks exactly as expected. The first thing you will probably notice is the @RunWith annotation that specifies the Arquilllian as the test runner. The second difference is the presence of a @Deployment annotated method. This method creates an archive to be tested. You need tu put all the essential classes into it, but the test class itself does not belong in it.
package cz.effy.server.testng.test;

import javax.inject.Inject;

import org.jboss.arquillian.container.test.api.Deployment;
import org.jboss.arquillian.junit.Arquillian;
import org.jboss.shrinkwrap.api.ShrinkWrap;
import org.jboss.shrinkwrap.api.asset.EmptyAsset;
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 HelloBeanTest {

 @Inject
 private HelloBean hello;

 @Deployment
 public static JavaArchive createTestArchive() {
  return ShrinkWrap.create(JavaArchive.class, "helloEJB.jar")
    .addClasses(HelloBean.class)
    // tested EJB
    .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml");
    // enabling CDI
 }

 @Test
 public void testHelloEJB() {
  String result = hello.getHello();
  Assert.assertEquals("Hi!", result);
 }
}

Setup arquillian.xml

This file contains a configuration for the arquillian container. And as was previously indicated ... this one deals with managed JBoss AS 7. You need to replace the jbossHome property with a value for your environment. Windows path looks like this C:\servers\jboss-as-7.1.1.Final.
<?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">
   <!-- Uncomment to have test archives exported to the file system for inspection -->
<!--    <engine>  -->
<!--       <property name="deploymentExportPath">target/</property>  -->
<!--    </engine> -->

   <!-- Force the use of the Servlet 3.0 protocol with all containers, as it is the most mature --> 
   <defaultProtocol type="Servlet 3.0" /> 

   <!-- Example configuration for a remote JBoss AS 7 instance -->
   <container qualifier="jboss" default="true">
      <!-- If you want to use the JBOSS_HOME environment variable, just delete the jbossHome property -->
      <configuration>
         <property name="jbossHome">/home/petr/servers/jboss-as-7.1.1.Final</property>
      </configuration>
   </container>
</arquillian>

Executing the test

You can run the test exactly as any other JUnit test, the added libraries will take care of the rest. Just keep in mind that the JBoss AS 7 will be launched in standalone configuration thus everything located in the deployments folder will be deployed, possibly slowing the tests.

Conclusion

The configuration might be a little complicated at first, but the result is highly rewarding. This simple test takes only 10+ seconds to execute and that is not bad in my opinion as the container only starts once per run.
I tried to keep this post simple, but it definitely got longer than planned. I do hope that it will prove useful.
I got really exited about all the possibilities arquillian offers. I plan to use arquillian for testing purposes on project right away.

Comments

Post a Comment

Popular posts from this blog

Automatic jsp recompile on Jboss AS 7

Image
Most of the applications I work on are based on jsp's and usually run on Jboss AS of various versions. And even though the newer applications are maven based and run on Jboss AS 7, almost nothing have changed in a matter of development. At least I thought that nothing have changed, but that was only because my carelessness. When you are developing web tier, there is no compiler telling you what is wrong in the real time, you depend on syntax validation only. And that enables you to do a lot of small mistakes that usually end up with error 500 and a need to redeploy the application. But this is the case only until you discover the right configuration!
Read more

Running scripts written in Clojure as an executable using Inlein

Do you sometimes wish you could create a smart, yet still simple utility? My usual dilemma is choosing whether to create a shell script to suit my needs, or to create a standard Java application. Now I have another handy alternative. I was just shown an interesting program called Inlein . Inlein lets you to run Clojure written scripts without the need to care about its dependencies. This way you have all the libraries you could wish for at your disposal and yet the utility you are writing is an easily modifiable and readable text file.
Read more

How to update XML file without reformatting it

Recently, I needed to modify content of a few thousands XML files. The modification itself was nontrivial and consisted of reading two attributes from an element and then updating a value of a previously read attribute. And to make it even more interesting, I wanted to keep the formatting of all files intact. My goal was creating a reusable utility that could be used also in the future, should such a need rise again. Because of the need to preserve the formatting, I rejected all tools I usually use (Dom4j, SAX, Jaxb) and started to search for a suitable tool. Finally I found the answer in a form of a recommendation on http://stackoverflow.com , the tool recommended was VTD-XML (or on github ).
Read more