Anotar la clase de pruebas con:

@RunWith(Arquillian.class)

Importar:

import org.jboss.arquillian.junit.Arquillian;

import org.junit.runner.RunWith;

Definir el método de la construcción del jar que contiene las clases que se van a probar. Este debe:

  • Estar anotado por @Deployment
  • Retornar un JavaArchive
  • Incluir todos los archivos que se necesitan para las prueba.

Se debe importar:

import org.jboss.arquillian.container.test.api.Deployment;

import org.jboss.shrinkwrap.api.ShrinkWrap;

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
package co.edu.uniandes.csw.nombreproyecto.persistence;
import co.edu.uniandes.csw.company.entities.XYZEntity;
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.JavaArchive;
import org.junit.After;
import org.junit.AfterClass;
import org.junit.Before;
import org.junit.BeforeClass;
import org.junit.Test;
import static org.junit.Assert.*;
import org.junit.runner.RunWith;
@RunWith(Arquillian.class)
public class XYZPersistenceTest {
/**
*
* @return Devuelve el jar que Arquillian va a desplegar en el Glassfish
* embebido. El jar contiene las clases de XYZ, el descriptor de la
* base de datos y el archivo beans.xml para resolver la inyección de
* dependencias.
*/
@Deployment
public static JavaArchive createDeployment() {
return ShrinkWrap.create(JavaArchive.class)
.addPackage(XYZEntity.class.getPackage())
.addPackage(XYZPersistence.class.getPackage())
.addAsManifestResource("META-INF/persistence.xml", "persistence.xml")
.addAsManifestResource("META-INF/beans.xml", "beans.xml");
}
public XYZPersistenceTest() {
}
@BeforeClass
public static void setUpClass() {
}
@AfterClass
public static void tearDownClass() {
}
@Before
public void setUp() {
}
@After
public void tearDown() {
}
/**
* Test of find method, of class XYZPersistence.
*/
@Test
public void testFind() throws Exception {
fail("testFind");
}
/**
* Test of findByName method, of class XYZPersistence.
*/
@Test
public void testFindByName() throws Exception {
fail("testFindByName");
}
/**
* Test of findAll method, of class XYZPersistence.
*/
@Test
public void testFindAll() throws Exception {
fail("testFindAll");
}
/**
* Test of create method, of class XYZPersistence.
*/
@Test
public void testCreate() throws Exception {
fail("testCreate");
}
/**
* Test of update method, of class XYZPersistence.
*/
@Test
public void testUpdate() throws Exception {
fail("testUpdate");
}
/**
* Test of delete method, of class XYZPersistence.
*/
@Test
public void testDelete() throws Exception {
fail("testDelete");
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Declarar las variables que se requieren para las pruebas e importar los paquetes necesarios:

  1. persistence: es el objeto de la clase que se va a probar. El contenedor inyectará una instancia de esta clase.
  2. em: un EntityManager para verificar los datos directamente sobre la base de datos
  3. utx: un UserTransactions para manipular los datos directamente sobre la base de datos
  4. data: este arreglo contendrá el conjunto de datos de prueba
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
/**
* Inyección de la dependencia a la clase XYZPersistence cuyos métodos
* se van a probar.
*/
@Inject
private XYZPersistence persistence;
/**
* Contexto de Persistencia que se va a utilizar para acceder a la Base de
* datos por fuera de los métodos que se están probando.
*/
@PersistenceContext
private EntityManager em;
/**
* Variable para martcar las transacciones del em anterior cuando se
* crean/borran datos para las pruebas.
*/
@Inject
UserTransaction utx;
/**
*
*/
private List<XYZEntity> data = new ArrayList<XYZEntity>();
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

Este método setUp anotado con @Before se ejecutará antes de cada prueba.

  1. Llama clearData() que Borra los datos en la base de datos directamente utilizando el EntityManagery la UserTransaction
  2. Llama insertData() que Crea nuevos datos
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@Before
public void setUp() {
try {
utx.begin();
em.joinTransaction();
clearData();
insertData();
utx.commit();
} catch (Exception e) {
e.printStackTrace();
try {
utx.rollback();
} catch (Exception e1) {
e1.printStackTrace();
}
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
  1. Llama clearData() que Borra los datos en la base de datos directamente utilizando el EntityManager y la UserTransaction
  2. Llama insertData() que Crea nuevos datos .
    1. Los nuevos datos son creados utilizando Podam quien crea datos aleatorios.
    2. Los datos que se crean son de la clase XYZEntity.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
private void clearData() {
em.createQuery("delete from XYZEntity").executeUpdate();
}
private void insertData() {
PodamFactory factory = new PodamFactoryImpl();
for (int i = 0; i < 3; i++) {
XYZEntity entity = factory.manufacturePojo(XYZEntity.class);
em.persist(entity);
data.add(entity);
}
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

results matching ""

    No results matching ""