Persistance JPA, test unitaire

Version imprimable

Bonjour à tous,

je me suis lancé dans la persistance Java avec JPA, j'ai donc créé une petite base de donnée et créé les entity correspondantes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
package com.persistance.tuto.entities;
 
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
 
@Entity
@Table(name = "file_type")
public class FileType {
	@Id
	@GeneratedValue(strategy = GenerationType.AUTO)
	private Integer id_file_type;
	private String file_type;
 
	/*Getter et Setter*/
 
}

J'ai ensuite créé un DAO générique et un DAO spécifique à cette entité :

DAO générique :

Code:

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
 
package com.persistance.tuto.dao;
 
import java.util.List;
 
import javax.persistence.EntityManager;
import javax.persistence.EntityNotFoundException;
import javax.persistence.PersistenceContext;
import javax.persistence.Query;
 
import org.apache.log4j.Logger;
 
import com.persistance.tuto.exception.MyException;
 
public abstract class Dao<T> {
	@PersistenceContext(unitName = "pfr_PU")
	private EntityManager em;
	private Logger logger = Logger.getLogger(this.getClass());
 
	public EntityManager getEm() {
		return em;
	}
 
	public void setEm(EntityManager em) {
		this.em = em;
	}
 
	protected void create(T newObject) {
		em.persist(newObject);
		logger.debug("Nouvelle insertion réalisé.");
	}
 
	@SuppressWarnings("unchecked")
	protected T find(Integer id) {
		return (T) em.find(this.getClass(), id);
	}
 
	@SuppressWarnings("unchecked")
	protected T getReference(Integer id) throws MyException {
		try {
			return (T) em.getReference(this.getClass(), id);
		} catch (EntityNotFoundException e) {
			throw new MyException(e, this.getClass().getName() + "getReference() : L'état de l'entité ne peut pas être consulté.");
		}
	}
 
	@SuppressWarnings("unchecked")
	protected List<T> sendQuery(String query) {
		Query q = em.createQuery(query);
 
		return (List<T>) q.getResultList();
	}
 
	@SuppressWarnings("unchecked")
	protected Boolean update(Integer id, T newEntity) {
		Boolean isUpdate = false;
		T classFind = null;
 
		classFind = (T) em.find(this.getClass(), id);
		if (classFind != null) {
			classFind = newEntity;
			em.flush();
			isUpdate = true;
		}
		return isUpdate;
	}
 
	@SuppressWarnings("unchecked")
	protected Boolean remove(Integer id) {
		Boolean isRemove = false;
		T classFind = null;
 
		classFind = (T) em.find(this.getClass(), id);
		if (classFind != null) {
			em.remove(classFind);
			isRemove = true;
		}
		return isRemove;
	}
}

DAO spécifique :

Code:

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
package com.persistance.tuto.dao;
 
import com.persistance.tuto.entities.FileType;
import com.persistance.tuto.exception.MyException;
 
public class FileTypeDao extends Dao<FileType> {
	public FileTypeDao() {
		super();
	}
 
	public void create(FileType newFileType) {
		super.create(newFileType);
	}
 
	public FileType find(Integer id) {
		return super.find(id);
	}
 
	public FileType getReference(Integer id) throws MyException {
		return super.getReference(id);
	}
 
	public Boolean update(Integer id, FileType newFileType) {
		return super.update(id, newFileType);
	}
 
	public Boolean remove(Integer id) {
		return super.remove(id);
	}
}

Mon fichier persistance.xml

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<?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="pfr_PU" transaction-type="RESOURCE_LOCAL">
		<provider>org.hibernate.ejb.HibernatePersistence</provider>
		<class>com.persistence.tuto.entities.FileType</class>
		<exclude-unlisted-classes />
 
		<properties>
			<property name="javax.persistence.jdbc.url" value="jdbc:postgresql://localhost:5432/pfr" />
			<property name="javax.persistence.jdbc.driver" value="org.postgresql.Driver"/>
			<property name="javax.persistence.jdbc.user" value="postgres" />
			<property name="javax.persistence.jdbc.password" value="xxxxxxx" />
		</properties>
	</persistence-unit>
</persistence>

et enfin ma classe de test junit :

Code:

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
package com.persistence.tuto.dao;
 
import javax.persistence.EntityManager;
import javax.persistence.Persistence;
 
import junit.framework.TestCase;
 
import org.apache.log4j.Logger;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;
 
import com.persistence.tuto.entities.FileType;
 
public class FileTypeDaoTest extends TestCase {
	private FileTypeDao ftd;
	private EntityManager em;
	private Logger logger = Logger.getLogger(this.getClass());
 
	@Before
	protected void setUp(){
		logger.debug("Création de Entity Manager.");
		em = Persistence.createEntityManagerFactory("pfr_PU").createEntityManager();
		logger.debug("Création de Entity Manager ok.");
 
		ftd = new FileTypeDao();
		ftd.setEm(em);
	}
 
	@After
	protected void tearDown(){
		if (ftd.getEm() != null)
			ftd.setEm(null);
		ftd = null;
	}
 
	@Test
	public final void testCreateClassOfFileType() {
		FileType ft = new FileType();
 
		ft.setFile_type("test");
 
		ftd.create(ft);
	}
}

C'est cette classe de test qui me pose problème, quand je l'exécute, rien ne se passe, elle m'affiche "Création de Entity Manager." et c'est tout!!

Je pense qu'il me manque hibernate mais je ne sais pas l'utiliser dans mon context, quelqu'un pourrait m'aider??

Merci

27/01/2011, 12h31
salber
Remarques :
1-tu n’as initié aucune transaction et vu que tu es en mode transaction-type="RESOURCE_LOCAL"> (le seul mode possible d’ailleurs), aucun enregistrement ne sera fait en base.
Exemple de transaction
Code:

1 2 3 4 em.getTransaction().begin(); em.persist(newObject); em.getTransaction().commit();
Les méthodes em.persit et em.merge doivent être encadrées par de transaction.begin et transaction.commit
2-Dans ta méthode update. Evite de jouer sur les références (classFind = newEntity; :nono:) et utilise une em.merge
28/01/2011, 17h03
Dragna_x

Merci de m'avoir répondu, depuis le 25 j'ai quand même beaucoup avancé et beaucoup lu de tuto!

Mon DAO fonctionne parfaitement maintenant, il me manquait des dépendances au niveau de maven mais également (comme tu le fait remarquer) les ouvertures et fermetures de transaction.

Mon update a également beaucoup changé et j'utilise em.merge().

Encore merci de ta réponse.

J'ai maintenant un autre petit soucis.

J'ai créé les classes me permettant de tester les DAO et je voudrais les lancer à la suite et initialiser ma BDD avec DBunit. J'ai fait une solution qui fonctionne mais je pense que ce n'est pas la bonne méthode à faire....

Voici le code :

Code:

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
 
public class InitDBUnit extends DBTestCase {
 
	private final String driver = "org.postgresql.Driver";
	private final String urlConnexion = "jdbc:postgresql://localhost:5432/db";
	private final String userName = "user";
	private final String userPassword = "mdp";
	private final String pathXmlDataSet = "." + File.separator + "src" + File.separator + "test" + File.separator + "resources" + File.separator + "dataset.xml";
 
	public InitDBUnit(String name) {
		super(name);
		System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_DRIVER_CLASS, driver);
		System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_CONNECTION_URL, urlConnexion);
		System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_USERNAME, userName);
		System.setProperty(PropertiesBasedJdbcDatabaseTester.DBUNIT_PASSWORD, userPassword);
	}
 
	@Override
	protected void setUpDatabaseConfig(DatabaseConfig config) {
		super.setUpDatabaseConfig(config);
		config.setProperty(DatabaseConfig.PROPERTY_BATCH_SIZE, new Integer(97));
		config.setProperty(DatabaseConfig.FEATURE_BATCHED_STATEMENTS, true);
	}
 
	@Override
	protected IDataSet getDataSet() throws Exception {
		return new FlatXmlDataSetBuilder().build(new FileInputStream(pathXmlDataSet));
	}
 
	@Override
	protected DatabaseOperation getSetUpOperation() throws Exception {
		return DatabaseOperation.CLEAN_INSERT;
	}
 
	@Override
	protected DatabaseOperation getTearDownOperation() throws Exception {
		return DatabaseOperation.DELETE_ALL;
	}
 
	@Test
	public void testSuite() {
		TestRunner.run(RefreshModeDaoTest.class);
		TestRunner.run(VersionDaoTest.class);
		TestRunner.run(PolicyDaoTest.class);
		TestRunner.run(MecTypeDaoTest.class);
		TestRunner.run(VersionComponentDaoTest.class);
		TestRunner.run(MecVersionDaoTest.class);
		TestRunner.run(MECDaoTest.class);
		TestRunner.run(ComponentDaoTest.class);
		TestRunner.run(FileDaoTest.class);
		TestRunner.run(ComponentTypeDaoTest.class);
		TestRunner.run(FileTypeDaoTest.class);
	}
}

Quelqu'un pourrait m'aider à faire un jolie testSuite?? Merci