Testing with Arquillian and Embedded Glassfish 3.1 - Part 2

We are configured our project to create and run tests with Arquillian. Here i will explain how to create a simple test using Arquillian and JPA.

We have created a data source with JNDI-name "jdbc/sample" in part 1, we will use it for our JPA test, i have used an API to make generic DAOs and hibernate-entity-manager as an entitity manager, needed dependencies therefore :

1. <dependency>
2.     <groupId>org.hibernate</groupId>
3.     <artifactId>hibernate-entitymanager</artifactId>
4.     <version>3.6.7.Final</version>
5.     <exclusions>
6.         <exclusion>
7.             <artifactId>slf4j-api</artifactId>
8.             <groupId>org.slf4j</groupId>
9.         </exclusion>
10.     </exclusions>
11. </dependency>
12. <dependency>
13.     <groupId>org.hibernate</groupId>
14.     <artifactId>hibernate-core</artifactId>
15.     <version>3.6.7.Final</version>
16.     <exclusions>
17.         <exclusion>
18.             <artifactId>slf4j-api</artifactId>
19.             <groupId>org.slf4j</groupId>
20.         </exclusion>
21.     </exclusions>
22. </dependency>
23. <!-- generic DAO dependencies -->
24. <!-- This first dependency includes all the JPA implementations for the DAOs -->
25. <dependency>
26.     <groupId>com.googlecode.genericdao</groupId>
27.     <artifactId>dao</artifactId>
28.     <version>1.0.0</version>
29. </dependency>
30. <!-- This second one includes the Hibernate Entity Manager plugin for the framework -->
31. <dependency>
32.     <groupId>com.googlecode.genericdao</groupId>
33.     <artifactId>search-jpa-hibernate</artifactId>
34.     <version>1.0.0</version>
35. </dependency>
36. <!-- end of generic DAO dependencies -->

I've created a BaseDAO interface and then the a specific interface to provide CRUD operations for users.

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public interface BaseDAO<T, ID extends Serializable> extends GenericDAO<T, ID> {
8.     public Collection<T> findByExample(T example);
9.    
10.     public T findByExampleUnique(T example);
11. }

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public interface UserDAO extends BaseDAO<User, Long> {
8. }

And an abstract class for JPA implementations :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public abstract class JPAGenericDAO<T, ID extends Serializable> extends GenericDAOImpl<T, ID> implements
7.         BaseDAO<T, ID> {
9.     private static final Logger logger = LoggerFactory.getLogger(JPAGenericDAO.class);
10.    
11.     @PersistenceContext(unitName="sample")
12.     private EntityManager entityManager;
13.    
14.     public JPAGenericDAO(){
15.         super();
16.     }
17.    
18.     @PostConstruct
19.     public void initialized(){
20.          this.setEntityManager(entityManager);
21.         JPASearchProcessor searchProcessor = new JPASearchProcessor(new JPAAnnotationMetadataUtil());
22.         this.setSearchProcessor(searchProcessor);
23.     }
25.     @Override
26.     public T findByExampleUnique(T example) {
27.         Search s = this.createSearch(example);
28.         return searchUnique(s);
29.     }
31.     @Override
32.     public Collection<T> findByExample(T example) {
33.         Search s = this.createSearch(example);
34.         return search(s);
35.     }
36.    
37.     protected Search createSearch(T example) {
38.         Search s = new Search(example.getClass());
39.         s.addFilter(this._getFilterFromExample(example));
40.         return s;
41.     }
42. }

As you remember we are created a persistence-unit named "sample" while injecting the entity-manager at this point, we are used this unit for our DAOs :

1. @PersistenceContext(unitName="sample")
2. private EntityManager entityManager

And a reference implementation for our JPA DAO :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. @Singleton
7. public class JPAUserDAO extends JPAGenericDAO<User, Long> implements UserDAO {
9.     public JPAUserDAO(){
10.         super();
11.     }
12. }

We are now ready to implement an Arquillian Test for our JPA class.The most important section to create a static method annotated with @Deployment to build a ShrinkWrap, here is a sample method:

1. /**
2. * Since Arquillian actually creates JAR files under the covers with
3. * ShrinkWrap, the @Deployment is your way of controlling what is included
4. * in that Archive. Note, each class utilized in your test case - whether
5. * directly or indirectly - must be added to the deployment archive.
6. */
7. @Deployment
8. public static Archive<?> createTestArchive() {
9.     return ShrinkWrap
10.         .create(JavaArchive.class, "test.jar")
11.         .addAsResource("arquillian.xml")
12.         .addPackages(true, UserDAO.class.getPackage())
13.         .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml")
14.         .addAsManifestResource("META-INF/persistence.xml",
15.         ArchivePaths.create("persistence.xml"));
16. }

We must add our arquillian configuration too, otherwise ShrinkWrap reads the default configuration and ignores our configuration.

I've created an abstract class which is extended by all test-classes :

1. /**
2.  *
3.  * @author Hasan Oezdemir
4.  * @since 02.10.2011
5.  *
6.  */
7. public class AbstractJPATest {
9.     /**
10.      * Since Arquillian actually creates JAR files under the covers with
11.      * ShrinkWrap, the @Deployment is your way of controlling what is included
12.      * in that Archive. Note, each class utilized in your test case - whether
13.      * directly or indirectly - must be added to the deployment archive.
14.      */
15.     @Deployment
16.     public static Archive<?> createTestArchive() {
17.         return ShrinkWrap
18.                 .create(JavaArchive.class, "test.jar")
19.                 .addAsResource("arquillian.xml")
20.                 .addAsResource("log4j.xml")
21.                 .addPackages(true, UserDAO.class.getPackage())
22.                 .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml")
23.                 .addAsManifestResource("META-INF/persistence.xml",
24.                         ArchivePaths.create("persistence.xml"));
25.     }
27.     @Inject
28.     protected UserTransaction userTransaction;
30.     public AbstractJPATest() {
31.         super();
32.     }
34.     /**
35.      * @throws java.lang.Exception
36.      */
37.     @Before
38.     public void setUp() throws Exception {
39.         this.userTransaction.begin();
40.     }
42.     /**
43.      * @throws java.lang.Exception
44.      */
45.     @After
46.     public void tearDown() throws Exception {
47.         try {
48.             this.userTransaction.rollback();
49.         } catch (Exception e) {
50.             throw new Exception(e);
51.         }
52.     }
54.     /**
55.      * @return a test user.
56.      */
57.     protected User createUser() {
58.         User user = new User();
59.         user.setEmail("hasan@hotmail.com");
60.         user.setName("hasan");
61.         user.setPassword("12345");
62.         return user;
63.     }
64. }

Transaction management may be better but this is enought for now :)

We must run our tests with Arquillian.class therefore we should add @RunWith(Arquillian.class) for each our tests-classes, here is a sample :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. @RunWith(Arquillian.class)
7. public class JPAUserDAOTest extends AbstractJPATest {
8.    
9.     @Inject
10.     private JPAUserDAO jpaUserDAO;
12.     /**
13.      * Test method for
14.      * {@link com.citecompany.dao.jpa.JPAGenericDAO#findByExampleUnique(java.lang.Object)}
15.      * .
16.      */
17.     @Test
18.     public void testFindByExampleUnique() {
19.         User user = this.createUser();
21.         this.jpaUserDAO.save(user);
22.         User found = this.jpaUserDAO.findByExampleUnique(user);
23.         assertNotNull("Expected user " + user + " is not found in data source.", found);
24.         assertEquals(user.getName(), found.getName());
25.     }
26. }

So our test class is ready to start, you start it either with maven or in eclipse.