Pruebas Unitarias a JPA y servicios REST con Arquillian + Payara. Parte 1

Por Diego Silva
Publicado en Agosto 2018

Revisado por Mario Escobar



Parte 1

Las pruebas unitarias son buenas y necesarias. Nos permiten evaluar ciertas porciones del proyecto antes de integrar y ejecutarlo todo. No vamos a esperar construir todo un auto para probar si funciona. Por tanto, solo probamos cada parte y nos aseguramos que cada prueba cumpla con ciertas características. Estas características son las que se definen en las Pruebas Unitarias. Si pasan estas características - o condiciones - recién se puede construir el proyecto.

Aprovechando las fases de construcción de Maven, podemos implementar pruebas unitarias para que - si aprueban las restricciones - podamos construir el proyecto sin problema.

Pero ¿si necesitamos probar accesos a JPA o lógicas creadas en servicios RESTful? o inclusive: ¿cómo podemos probar en un ambiente Java EE sin necesidad de desplegar un servidor Java EE? Aquí es donde entra  Arquillian.

En esta serie de publicaciones veremos desde preparar un ambiente Java EE para Arquillian, hasta hacer pruebas con JPA y RESTful. Al final lo integraremos para usarlo como microservicio con Payara Micro.

 


Estructura del Proyecto


Para empezar, creemos un proyecto, para este post estoy usando un proyecto web.
Este tendrá la siguiente estructura (considerar los subdirectorios tal como se indica).


El archivo index.html es un texto simple, no le vamos a dar importancia. Ahora veremos los archivos de configuración.

 



Dependencias y configuración recursos del archivo pom.xml


Consideraremos las propiedades del proyecto.


<properties> <endorsed.dir>${project.build.directory}/endorsed</endorsed.dir> <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> <payara.version>4.1.2.174</payara.version> </properties>

 

Necesitamos el administrador de dependencias para agregar Arquillian.


<dependencyManagement> <dependencies> <dependency> <groupId>org.jboss.arquillian</groupId> <artifactId>arquillian-bom</artifactId> <version>1.1.13.Final</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement>

 

Debido a que usaremos JUnit, es necesario agregar su dependencia:


<dependency> <groupId>junit</groupId> <artifactId>junit</artifactId> <version>4.12</version> <scope>test</scope> </dependency>

 

Ahora bien, como usaremos Payara para hacer las pruebas unitarias (ya que simularemos un entorno Java EE con Payara), debemos agregar las dependencias correspondientes. Arquillian está diseñado para JBoss / Wildfly, pero también permite usar Payara.


<dependency> <groupId>fish.payara.extras</groupId> <artifactId>payara-embedded-all</artifactId> <version>${payara.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>fish.payara.api</groupId> <artifactId>payara-api</artifactId> <version>${payara.version}</version> <scope>test</scope> </dependency> <dependency> <groupId>org.jboss.arquillian.container</groupId> <artifactId>arquillian-glassfish-embedded-3.1</artifactId> <version>1.0.1</version> <scope>test</scope> </dependency>

 

Y, para terminar con las dependencias, utilizamos las propias para Arquillian.


<dependency> <groupId>org.jboss.arquillian.junit</groupId> <artifactId>arquillian-junit-container</artifactId> <scope>test</scope> </dependency> <dependency> <groupId>org.jboss.arquillian.extension</groupId> <artifactId>arquillian-persistence-dbunit</artifactId> <version>1.0.0.Alpha7</version> <scope>test</scope> </dependency>

 

Además, Arquillian utiliza slf4j para mostrar los logs del entorno, por tanto,  agregaremos solo la implementación para log4j.


<dependency> <groupId>org.slf4j</groupId> <artifactId>slf4j-log4j12</artifactId> <version>1.7.25</version> <scope>test</scope> </dependency>

 

En la sección <build> debemos considerar los recursos para nuestro proyecto y para las pruebas. Son dos directorios diferentes ya que los recursos que usaremos para las pruebas no necesariamente deben ser iguales al del proyecto terminado.


<resources> <resource> <directory>src/main/resources</directory> </resource> </resources> <testResources> <testResource> <directory>src/test/resources</directory> </testResource> </testResources>

 



Recursos para pruebas


Crearemos el archivo arquillian.xml que deberá estar dentro de src/test/resources. El contenido es como sigue:


<?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"> <defaultProtocol type="Servlet 3.0"/> <container qualifier="glassfish-embedded"> <configuration> <property name="bindHttpPort">7979</property> </configuration> </container> </arquillian>

 

Como vemos, allí se establece el puerto para nuestro Payara de prueba. Y, como vimos hace unos párrafos, necesitamos log4j. Para ello, incluimos dentro de la misma carpeta el archivo log4j.properties con el siguiente contenido.


log4j.rootLogger=info, stdout log4j.logger.com.apuntesdejava=debug # Direct log messages to stdout log4j.appender.stdout=org.apache.log4j.ConsoleAppender log4j.appender.stdout.Target=System.out log4j.appender.stdout.layout=org.apache.log4j.PatternLayout log4j.appender.stdout.layout.ConversionPattern=%d{yyyy-MM-dd HH:mm:ss} %-5p %c{1}:%L - %m%n

 



Clase de prueba


Aquí comenzamos con lo interesante: las pruebas unitarias. Dentro de la carpeta src/test/java crearemos la clase ArquillianTest.java. Esa clase deber tener la notación @RunWith(Arquillian.class) para poder decirle al JUnit que usaremos un tester específico. Además, debemos crear el método de despliegue que se usará en el entorno Java EE. Ese método deberá tener la anotación @Deployment. Y, finalmente, necesitamos las pruebas en sí. Estos métodos deben tener la anotación @Test.
Con este código lo podremos entender mejor:


package com.apuntesdejava.payara.arquillian; 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.spec.WebArchive; import org.junit.Test; import org.junit.runner.RunWith; import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** * * @author Tu */ @RunWith(Arquillian.class) public class ArquillianTest { private static final Logger LOGGER = LoggerFactory.getLogger(ArquillianTest.class); @Deployment public static WebArchive createDeployment() { return ShrinkWrap.create(WebArchive.class, "payara-arquillian.war"); } @Test public void test01() { LOGGER.info("Test 01"); } }


Y listo..!!! ¿Lo probamos?.

Desde la línea de comandos (o desde nuestro IDE) ejecutemos:

mvn clean test

Y este debe ser el resultado:

 



Conclusión


Por ahora hemos configurado el entorno de Arquillian y hemos hecho una prueba. En el siguiente post veremos cómo probar JPA cargándole datos.



Código fuente


El código fuente para este proyecto lo puedes obtener vía git desde el siguiente repositorio:

https://bitbucket.org/apuntesdejava/payara-arquillian




Diego Silva. En Noviembre de 2013 obtuvo el Oracle Certified Associate Java SE 7 Programmer.
Ha Trabajado para el Estado peruano, desarrollando y llevando a producción sistemas de información en vía web. Actualmente trabaja en una empresa privada desarrollando aplicaciones Java Web con Oracle ADF y con la plataforma Liferay.

Este artículo ha sido revisado por el equipo de productos Oracle y se encuentra en cumplimiento de las normas y prácticas para el uso de los productos Oracle.