Utilisation des Mock au sein d'une application Spring

Version imprimable

Bonjour,

Je suis entrain de faire mes tester unitaires sur une application Spring et là je bloque pour mes classes service.
En effet, celles-ci appel mes classe DAO et quand je Mock, je me tape un null pointer exception.
Voici ma classe de test;

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
 
public class UserServiceImplTest {
  private UserServiceImplWebService UserServiceWebService = new UserServiceImplWebService();
 
  @Autowired
  private IUserDao UserDao;
 
  private UserEntitie UserEntitie;
  @Before
  public void setUp() throws Exception {
    UserEntitie = EasyMock.createMock(UserEntitie.class);
    UserDao = EasyMock.createMock(IUserDao.class);
  }
 
  @Test
  public void enregistrerUser()
      throws EnregistrerUserException {
 
    Boolean retour;
 
    User User = new User();
    User.setNom("Test");
    User.setPrenom("Test");
 
    EasyMock.expect(UserDao.enregistrerUser(UserEntitie)).andReturn(true);
    EasyMock.replay(UserDao);
 
    retour = UserServiceWebService.enregistrerUser(User);
    EasyMock.verify(UserDao);
    Assert.assertTrue(retour);
  }
}

Classe DAO:

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
81
82
83
public class UserDaoImpl implements IUserDao {
  @PersistenceContext
  private EntityManager entityManagerFactory;
 
  /**
   * 
   */
  public List<UserEntitie> listerUser() throws ListerUserException {
    List<UserEntitie> listeUsers = null;
 
    try {
      listeUsers = (List<UserEntitie>) entityManagerFactory
          .createQuery("FROM UserEntitie", UserEntitie.class).getResultList();
    } catch (HibernateException e) {
      throw new ListerUserException("");
    }
 
    return listeUsers;
  }
 
  /**
   * 
   */
  public UserEntitie recupererUser(int identifiant)
      throws RecupererUserException {
    UserEntitie UserEntite = null;
 
    try {
      UserEntite = (UserEntitie) entityManagerFactory.find(UserEntitie.class,
          identifiant);
    } catch (HibernateException e) {
      throw new RecupererUserException("");
    }
 
    return UserEntite;
  }
 
  /**
   * 
   */
  public boolean enregistrerUser(UserEntitie User)
      throws EnregistrerUserException {
    boolean enregistrer = false;
    try {
      entityManagerFactory.persist(User);
      enregistrer = true;
    } catch (HibernateException e) {
      throw new EnregistrerUserException("");
    }
    return enregistrer;
  }
 
  /**
   * 
   */
  public boolean modifierUser(UserEntitie User)
      throws ModifierUserException {
    boolean modifier = false;
    try {
      entityManagerFactory.merge(User);
      modifier = true;
    } catch (HibernateException e) {
      throw new ModifierUserException("");
    }
    return modifier;
  }
 
  /**
   * 
   */
  public boolean supprimerUser(UserEntitie User)
      throws SupprimerUserException {
    boolean supprimer = false;
    try {
      entityManagerFactory.remove(entityManagerFactory.merge(User));
      supprimer = true;
    } catch (HibernateException e) {
      throw new SupprimerUserException("");
    }
 
    return supprimer;
  }
}

Classe Service à tester:

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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
public class UserServiceImplWebService implements IUserServiceWebService {
 
  @Autowired
  IUserDao UserDao;
 
  @Transactional(readOnly=true)
  public List<User> listerUser() throws ListerUserException {
    List<User> listeUsers = null;
 
    try {
      List<UserEntitie> listeUsersEntitie = UserDao.listerUser();
      if (listeUsersEntitie.size() == 0) {
        throw new ListerUserException("Aucun Users trouvé !");
      } else {
        listeUsers = new ArrayList<User>();
        for (UserEntitie unUser : listeUsersEntitie) {
          User User = new User();
          User.setIdentifiant(unUser.getIdentifiant());
          User.setNom(unUser.getNom());
          User.setPrenom(unUser.getPrenom());
 
          listeUsers.add(User);
        }
      }
    } catch (CannotCreateTransactionException e) {
      throw new ListerUserException("Erreur d'accès à la base de données !");
    }
 
    return listeUsers;
  }
 
  @Transactional(readOnly=true)
  public User recupererUser(int identifiant) throws RecupererUserException {
    User User = null;
 
    try {
      UserEntitie UserEntite = UserDao.recupererUser(identifiant);
      if (UserEntite == null) {
        throw new RecupererUserException(
            "Aucun Users trouvé pour l'identifiant choisit : " + identifiant + "!");
      } else {
        User = new User();
        User.setIdentifiant(UserEntite.getIdentifiant());
        User.setPrenom(UserEntite.getPrenom());
        User.setNom(UserEntite.getNom());
      }
    } catch (CannotCreateTransactionException e) {
      throw new RecupererUserException("Erreur d'accès à la base de données !");
    }
 
    return User;
  }
 
  @Transactional(readOnly=true)
  public boolean enregistrerUser(User User)
      throws EnregistrerUserException {
    boolean enregistrer = false;
 
    if (User.getNom() == null || User.getPrenom() == null) {
      throw new EnregistrerUserException(
          "Une ou plusieurs valeurs n'autorisent pas les valeurs nulles !");
    } else {
      UserEntitie UserEntitie = new UserEntitie();
      UserEntitie.setPrenom(User.getPrenom());
      UserEntitie.setNom(User.getNom());
 
      try {
        enregistrer = UserDao.enregistrerUser(UserEntitie);
      } catch (CannotCreateTransactionException e) {
        throw new EnregistrerUserException("Erreur d'accès à la base de données !");
      }
    }
    return enregistrer;
  }
 
  @Transactional(readOnly=true)
  public boolean modifierUser(User User) throws ModifierUserException {
    boolean modifier = false;
 
    if (User.getNom() == null || User.getPrenom() == null) {
      throw new ModifierUserException(
          "Une ou plusieurs valeurs n'autorisent pas les valeurs nulles !");
    } else {
      UserEntitie UserEntitie = new UserEntitie();
      UserEntitie.setIdentifiant(User.getIdentifiant());
      UserEntitie.setPrenom(User.getPrenom());
      UserEntitie.setNom(User.getNom());
 
      try {
        modifier = UserDao.modifierUser(UserEntitie);
      } catch (CannotCreateTransactionException e) {
        throw new ModifierUserException("Erreur d'accès à la base de données !");
      }
    }
    return modifier;
  }
 
  @Transactional(readOnly=true)
  public boolean supprimerUser(User User)
      throws SupprimerUserException {
    boolean supprimer = false;
    if (User.getNom() == null || User.getPrenom() == null) {
      throw new SupprimerUserException(
          "Une ou plusieurs valeurs n'autorisent pas les valeurs nulles !");
    } else {
      UserEntitie UserEntitie = new UserEntitie();
      UserEntitie.setIdentifiant(User.getIdentifiant());
      UserEntitie.setPrenom(User.getPrenom());
      UserEntitie.setNom(User.getNom());
 
      try {
        supprimer = UserDao.supprimerUser(UserEntitie);
      } catch (CannotCreateTransactionException e) {
        throw new SupprimerUserException("Erreur d'accès à la base de données !");
      }
    }
    return supprimer;
  }
 
}

Cela me proovque un null pointer exception sur enregistrer = UserDao.enregistrerUser(UserEntitie);
J'ai l'impression que c'est à cause de EntityManagerFactory qui est null dans la DAO mais comme je mock la DAO, je suis pas censé avoir de problème. Je ne souhaite pas avoir de contact avec la bd quand je test ma classe service si j'ai bien compris le système de mock

Merci de votre aide

31/10/2016, 10h15
Pill_S

Tu mock mais tu ne l'injectes jamais... normal que ça soit null en face...
31/10/2016, 10h49
totot

Je doit l'injecter ou?

Bah tant qu'à faire, autant le faire dans la partie d'initialisation du test... :roll:
Code:

1 2 3 4 5 6 @Before public void setUp() throws Exception { UserEntitie = EasyMock.createMock(UserEntitie.class); UserDao = EasyMock.createMock(IUserDao.class); UserServiceWebService.setUserDao(UserDao); }
EDIT: avec Mockito, tu pourrais utiliser les annotations @Mock et @InjectMocks pour simplifier cette partie. En EasyMock, je sais pas si c'est dispo

31/10/2016, 11h15
totot
Dans ma classe service, j'ai ceci:
Code:

1 2 @Autowired IUserDao UserDao;
Je vois ne comprend pas pourquoi ici, il faut que je face un setDao alors que dans l'application telle quelle je n'en fait pas
31/10/2016, 11h53
andry.aime

Bonjour,

Je ne vois pas l’intérêt d'utiliser d'easymock si l'objectif n'est que de ne pas insérer les données de test dans la base. Je te conseille d'abord de lire cette documentation.

A+.
31/10/2016, 11h54
totot

Il faut donc que je face comment?
31/10/2016, 12h04
andry.aime

Il faut que tu lises d'abord la documentation, corriger tes classes de tests et service (oui il y a pas mal de truc pas logique mais je ne vais pas te le dire). Tu devrais comprendre ce que tu devrais faire après que tu auras lu la doc.

A+.
31/10/2016, 12h41
totot

Je l'ai lu et je ne vois pas ou est le problème
31/10/2016, 13h21
Pill_S

Citation:

Envoyé par totot

Je vois ne comprend pas pourquoi ici, il faut que je face un setDao alors que dans l'application telle quelle je n'en fait pas

@Autowired (ou @Inject, qui serait un peu meilleure) est une annotation qui marche uniquement si ton objet est sous le contrôle d'un framework d'injection (Spring ou autres).

Puisque dans ton cas, tu instancies toi-même l'objet avec un "new" explicite, il est hors-scope de Spring. Ce n'est pas un bean, donc tu ne peux pas bénéficier des fonctionnalités proposées par Spring, que cela soit l'injection des dépendances ou l'AoP, donc, tu dois faire l'injection (= mise en relation des objets les uns avec les autres) toi-même.

Sinon, tel qu'indiqué précédemment, il serait peut être mieux de juste configurer les transactions pour forcer un rollback à la fin de chaque test, ou alors monter une datasource de test (type hsqldb ou h2, éventuellement sous contrôle de DBUnit) et faire tests avec celle-là.

Tout dépend de ce que tu veux tester (l'intégration entre tes services/dao avec une db réelle => DAO réels + DB de test + év. DBUnit, ou alors le code business de tes services, de façon unitaire => DAO mocks)

;)
31/10/2016, 13h29
totot

Je veux tester le code business de tes services, de façon unitaire => DAO mocks)
31/10/2016, 14h46
totot

As tu une idée de comment il faut faire
31/10/2016, 15h28
Pill_S

je te l'ai dit... garde tout comme c'est, mais injecte manuellement les références qui vont bien de tous les objets qui ne sont pas managés par spring.
31/10/2016, 15h31
totot

Comment je fait pour injecter car là je suis perdu.
Car je me suis mi en mode débug et c'est le EntityManager entityManagerFactory qui est null
31/10/2016, 15h36
Pill_S
~~que l'entity manager soit null c'est normal...~~ euh non en fait c'est bizarre, si tu es vraiment dans un mock, tu ne devrais même pas voir de référence à un entity manager...

injecter manuellement = faire le mapping soit même des objets. C'est ce que j'avais indiqué dans mon deuxième post, ajouter la ligne:
Code:

1 2 3 4 ... UserServiceWebService.setUserDao(UserDao); ...
PS: au passage, regarde un peu les convention de nommage de java: une référence ne doit jamais commencer par une majuscule...
31/10/2016, 15h48
totot

Du coup, je créer une méthode setUserDao dans le serveir?

Non, le mieux c'est de faire de l'injection par constructeur - ça évite de prendre le risque d'avoir des objets incohérents à un instant T.

Donc:
Code:

1 2 3 4 5 6 7 8 9 10 public class UserServiceImplWebService implements IUserServiceWebService { private final IUserDao UserDao; @Autowired public UserServiceImplWebService(IUserDao userDao) { Validate.notNull(userDao); this.UserDao = userDao; } ...
;)

31/10/2016, 16h02
totot

J'ai fait dans la classe de test:

Code:

private UserServiceImplWebService userServiceWebService = new UserServiceImplWebService(userDao);

Et j'ai toujours mon null pointer exception
31/10/2016, 16h04
Pill_S

bah poste tout le code que tu as... si tu as mocké ton DAO correctement, tu ne peux plus avoir de nullpointer sur une référence vers un EntityManager, pour la simple et bonne raison que le mock ne fait pas de JPA et ne connais rien à JPA...

donc si ça pète, c'est sûrement qu'à la place d'avoir un mock, tu as instancié un DAO concret...

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
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = { "classpath*:/applicationContext-test.xml" })
public class UserServiceImplTest {
  private IUserDao userDao;
 
  private UserServiceImplWebService userServiceWebService = new UserServiceImplWebService(userDao);
 
  @Test
  public void enregistrerUserr() {
 
    Boolean retour;
 
    UserEntitie userEntite = new UserEntitie ();
    userEntite .setIdentifiant(1);
    userEntite .setNom("Test");
    userEntite .setPrenom("Test");
 
    User user = new User ();
    user .setNom("Test");
    user .setPrenom("Test");
 
    EasyMock.expect(userDao.enregistrerUser(userEntite)).andReturn(true);
    EasyMock.replay(userDao);
 
    retour = userServiceWebService.enregistrerUser(user);
 
    Assert.assertTrue(retour);
  }
}

Tu ne peux pas instancier ton service avant d'avoir mocké ton dao.......... sinon tu as null en face........
Code:

1 2 3 4 5 6 7 8 9 10 11 12 public class UserServiceImplTest { private IUserDao userDao; private UserServiceImplWebService userServiceWebService; @Before public void setUp() { userDao = EasyMock.mock(IUserDao.class); userServiceWebService = new UserServiceImplWebService(userDao); } ...
PS: ton contexte spring il sert à quoi? Tu n'as plus rien d'autowired!!!

31/10/2016, 17h06
totot

Si je passe par le constructeur côté test unitaire, côté application je doit faire comment? Car je passe par autowired
31/10/2016, 17h09
Pill_S

Pas de soucis côté application, Spring et les autres savent faire de l'injection par constructeur
31/10/2016, 17h11
totot

Mais par contre, je laisse bien la déclaration de mes beans dans le application.-context.xml ?
31/10/2016, 17h12
Pill_S

Non, aucun intérêt, tu n'utilises rien qui ne soit pas initialisé dans le test...
31/10/2016, 17h14
totot

Je parle pas de l'application context test mais de l'application context normal
31/10/2016, 17h16
Pill_S

alors oui, ces fichiers là restent... normal, puisque ce sont ceux qui décrivent le comportement normal de l'application, quelles classes instancier, etc.
31/10/2016, 17h20
totot

Donc je garde sa dans mes deux applications-context.xml et applications-context-test.xml
<bean id="userDao"
class="com.UserDaoImpl" />
31/10/2016, 17h20
Pill_S

oui, entre autres...
31/10/2016, 17h51
Pill_S

Ton service n'a jamais invoqué la méthode attendue de ton dao...
31/10/2016, 17h52
totot

Je peux même enlever mes bean des fichiers xml, sa fonctionne
31/10/2016, 17h54
totot

C'est bizarre là part contre
31/10/2016, 17h56
Pill_S

Est-ce que ta question originale est résolue?

Si oui, merci de mettre le sujet en résolu. Sinon, merci de nous dire ce que l'on peut faire d'autre pour ton problème de mock.

Si tu as d'autres questions, sur d'autres sujets, merci d'ouvrir un nouveau topic (ou mieux, de lire la doc au préalable...)
31/10/2016, 17h58
totot

La question de mock est résolu. Maintenant faut que je regarde l'assertion

1-

Citation:

Envoyé par totot

Je peux même enlever mes bean des fichiers xml, sa fonctionne

Copie ce que tu as dans ton applicationContext.xml dans applicationContext-test.xml. Tu peux utiliser la même base ou utiliser une autre en modifiant les fichiers de configuration de test. Ainsi tu peux bien tester si les beans sont injectés correctement et les transactions sont bonnes.
2-

Citation:

Code:

classpath*:/applicationContext-test.xml

Je déconseille l'utilisation de classpath*, s'il ne trouve pas le fichier applicationContext-test.xml, tu n'auras pas d'erreur mais aucun chargement de context n'est fait, du coup t'auras des NullPointerException. Utilise classpath:applicationContext-test.xml, une exception est lancée s'il ne trouve pas le fichier applicationContext-test.xml.

3-

Citation:

Code:

private UserServiceImpl userService;

Citation:

Code:

private UserServiceImplWebService userServiceWebService

Qu'est ce que t'as réellement?

4-
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 @RunWith(SpringJUnit4ClassRunner.class) @ContextConfiguration(locations = {"classpath:applicationContext-test.xml"}) @Transactional public class UserServiceImplTest { @Autowired private UserServiceImpl userService; @Autowired private IUserDao userDao; @Rollback @Test public void enregistrerUserDao() throws EnregistrerUserException { Boolean retour; UserEntitie userEntite = new UserEntitie(); userEntite.setNom("Nom"); userEntite.setPrenom("Prenom"); retour = userDao.enregistrerUser(userEntite); Assert.assertTrue(retour); } @Rollback @Test public void enregistrerUserService() throws EnregistrerUserException { Boolean retour; User user = new User(); user.setNom("Nom"); user.setPrenom("Prenom"); retour = userService.enregistrerUser(user); Assert.assertTrue(retour); } }
T'auras un erreur dans le test enregistrerUserService() puisque ton service n'est pas bon.

A+.

01/11/2016, 11h04
totot

mon service enregistrerUser est correct puisque mon application fonctionne.
J'ai l'impression qu'il y a un problème avec les mocks que je veux retourner un type Boolean
01/11/2016, 11h13
andry.aime
Citation:
Code:

1 2 @Transactional(readOnly=true) public boolean enregistrerUser(User User)
Tu le met en ReadOnly et tu n'as pas d'erreur quand tu tentes d'écrire dans la base :koi:. Et puis, pourquoi utiliser un mock si tes interfaces sont toutes implémentées?
01/11/2016, 11h18
totot

J'ai supprimer le readOnly
01/11/2016, 16h29
totot

Personne pour m'aider