Tests JUnit avec deux exceptions pour une même méthode

Version imprimable

Bonsoir,

Je suis actuellement en train de développer en Java un petit exercice qu'on a à faire dans le cadre d'un module de S3. Avec mon binôme, on a créé des exceptions personnalisées, jusque là, pas de soucis, et les profs nous ont demandé de programmer également les tests unitaires. Sauf que là, on fait face à bien des soucis : on a une méthode calculMoyenne(Matiere) dans une classe Etudiant qui se charge de calculer la moyenne d'un étudiant dans une matière appartenant à sa formation.
Pour cela, voici notre classe Etudiant :

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
121
122
123
124
125
 
package code;
import java.util.*;
 
public class Etudiant {
 
	private Identite id;
	private Formation form;
	private HashMap<Matiere,ArrayList<Integer>> notes;
 
	public Etudiant(Identite id,Formation f) {
		this.id=id;
		this.form=f;
		this.notes=new HashMap<Matiere,ArrayList<Integer>>();
		Set<Matiere> s = f.getMatieres().keySet();
		for (Matiere m :s) {
			notes.put(m, new ArrayList<Integer>());			
		}
	}
 
	public void ajouterNote(Matiere m, Integer note) {
		if(notes.containsKey(m)) {
			if(note<20 && note>0) {
				notes.get(m).add(note);
			}
		}
	}
 
	public double calculeMoyenne(Matiere m) throws MatiereAbsenteException, NotesAbsentesException {
		int total = 0;
		ArrayList<Integer> notesM = this.notes.get(m);
		if(notesM.size()==0) {
			throw new NotesAbsentesException(m);
		}
		if(!this.notes.containsKey(m)) {
			throw new MatiereAbsenteException();
		}
		for (Integer integer : notesM) {
				total += integer;
		}
		return total/notesM.size();
	}
 
	public double calculeMoyenneGenerale() {
		int total = 0;
		Set<Matiere> s = this.notes.keySet();
		int coeff = 0;
		int sommeCoeff = 0;
		for (Matiere m :s) {
			try {
				coeff = form.getCoefficient(m);
				sommeCoeff+=form.getCoefficient(m);
				total += calculeMoyenne(m)*coeff;
			} catch (MatiereAbsenteException mae) {
				mae.printStackTrace();
			} catch (NotesAbsentesException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
		}
		return total/sommeCoeff;
	}
 
	public Identite getId() {
		return id;
	}
 
	public void setId(Identite id) {
		this.id = id;
	}
 
	public Formation getForm() {
		return form;
	}
 
	public void setForm(Formation form) {
		this.form = form;
	}
 
	public HashMap<Matiere, ArrayList<Integer>> getNotes() {
		return notes;
	}
 
	public void setNotes(HashMap<Matiere, ArrayList<Integer>> notes) {
		this.notes = notes;
	}
 
	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + ((form == null) ? 0 : form.hashCode());
		result = prime * result + ((id == null) ? 0 : id.hashCode());
		result = prime * result + ((notes == null) ? 0 : notes.hashCode());
		return result;
	}
 
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Etudiant other = (Etudiant) obj;
		if (form == null) {
			if (other.form != null)
				return false;
		} else if (!form.equals(other.form))
			return false;
		if (id == null) {
			if (other.id != null)
				return false;
		} else if (!id.equals(other.id))
			return false;
		if (notes == null) {
			if (other.notes != null)
				return false;
		} else if (!notes.equals(other.notes))
			return false;
		return true;
	}
 
}

Et on ne sait pas comment traiter les deux exceptions pouvant être levées par la méthode calculMoyenne(Matiere) dans JUnit ! Nous savons faire avec une, mais pas deux, et apparemment, ça ne fonctionne pas de la même manière, puisque ça ne fonctionne pas. D'autre part, chose plutôt étonnante, lorsque j'essaie de ne traiter qu'une exception, Eclipse, l'IDE que nous utilisons, nous signale une erreur de type "Unhandled exception type MatiereAbsenteException" (un de nos 2 exceptions personnalisées).

Merci de bien vouloir nous aider, nous sommes désespérés ! :aie:

Ca ne devrait pas poser de problème impossible. Tu peux nous montrer le junit que tu as créé?

Si tu veux tester qu'une exception est bien levée, en général j'utilise cette structure simple
Code:

1 2 3 4 5 6 try{ //code a tester qui lance un exception throw new AssertionError("Je m'attendais à une exception") } catch (ExceptionAttendue e){ // rien à faire, on a l'exception attendue }
Si tu coupe bien test tests, tu peux laisser junit traiter l'attente de l'exception
Code:

1 2 3 4 @Test(expected = ExceptionAttendue .class) public testAvecException() throws ExceptionAttendue { //code a tester qui lance un exception }
Enfin, si tu veux juste tester que tu n'a pas d'exception, contente toi de renvoyer ça depuis le unit test
Code:

1 2 3 4 @Test() public testAvecException() throws ExceptionInattendue { //code a tester qui ne devrais pas lancer un exception }

Voici le code JUnit ci-dessous, par contre il est sûrement faux parce que j'ai fait beaucoup de modifications dessus... :

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
 
package tests;
import static org.junit.Assert.*;
 
import org.hamcrest.CoreMatchers;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.ExpectedException;
 
import code.*;
 
public class TestEtudiant {
 
	private Identite id;
	private Formation form;
	private Etudiant etu;
	private Matiere m1, m2;
 
	@Before
	public void init() {
		this.id = new Identite("120978425f", "Durand", "Jean");
		this.form = new Formation("MMI");
		this.m1 = new Matiere("Probabilités et statistiques");
		this.m2 = new Matiere("Conception et programmation objet avancées");
		this.form.ajouterMatiere(m1, 3);
		this.form.ajouterMatiere(m2, 4);
		etu = new Etudiant(id, form);
	}
 
	@Rule
	public ExpectedException thrown = ExpectedException.none();
 
	@Test
	public void testConstructeurEtudiant() {
		assertEquals("l'étudiant devrait avoir pour numero NIP 120978425f", "120978425f", etu.getId().getNIP());
		assertEquals("le nom de famille de l'eéudiant devrait être Durand", "Durand", etu.getId().getNom());
		assertEquals("le prenom de l'étudiant devrait être Jean", "Jean", etu.getId().getPrenom());
		assertEquals("l'etudiant devrait être en formation MMI", "MMI", etu.getForm().getIdentifiant());
	}
 
	@Test
	public void testAjouterNote() {
		this.etu.ajouterNote(m1, 15);
		this.etu.ajouterNote(m1, 12);
		this.etu.ajouterNote(m2, 17);
		this.etu.ajouterNote(m2, 15);
 
		assertEquals("la matière Probabilités et statistiques devrait contenir des notes", 2, this.etu.getNotes().get(m1).size());
		assertEquals("la matière Conception et programmation objet avancées devrait contenir des notes", 2, this.etu.getNotes().get(m2).size());
		assertEquals("la première note obtenue en Probabilités et statistiques devrait être 15", 15, (int)this.etu.getNotes().get(m1).get(0));
		assertEquals("la première note obtenue en Probabilités et statistiques devrait être 12", 12, (int)this.etu.getNotes().get(m1).get(1));
		assertEquals("la première note obtenue en Conception et programmation objet avancées devrait être 17", 17, (int)this.etu.getNotes().get(m2).get(0));
		assertEquals("la première note obtenue en Conception et programmation objet avancées devrait être 15", 15, (int)this.etu.getNotes().get(m2).get(1));
	}
 
	@Test
	public void testCalculMoyenneMatieresExistantes() {
		this.etu.ajouterNote(m1, 15);
		this.etu.ajouterNote(m1, 12);
		this.etu.ajouterNote(m2, 17);
		this.etu.ajouterNote(m2, 15);
 
		try {
			assertEquals(13.50, etu.calculeMoyenne(m1), 0.0);
			assertEquals(16.00, etu.calculeMoyenne(m2), 0.0);
		} catch (NotesAbsentesException e) {
			e.printStackTrace();
		} catch (MatiereAbsenteException e) {
		}
 
	}
 
	@Test (expected = MatiereAbsenteException.class)
	public void testCalculMoyenneMatieresInexistantes() {
		Matiere m3 = new Matiere("Expression-communication");
		thrown.expect(MatiereAbsenteException.class);
		thrown.expectMessage(CoreMatchers.containsString("matiere inexistante"));
			/*assertEquals(13.5, etu.calculeMoyenne(m1), 0.0);
			assertEquals(0, etu.calculeMoyenne(m2), 0.0);*/
		this.etu.ajouterNote(m3, 15);
		this.etu.ajouterNote(m3, 12);
		this.etu.calculeMoyenne(m3);
		/*fail("Devrait lever une exception de type MatiereAbsenteException");*/
	}
 
	@Test (expected = MatiereAbsenteException.class)
	public void testCalculMoyenneNotesInexistantes() {
		Matiere m3 = new Matiere("Expression-communication");
		/*thrown.expect(MatiereAbsenteException.class);
		thrown.expectMessage(CoreMatchers.containsString("matiere inexistante"));*/
			/*assertEquals(13.5, etu.calculeMoyenne(m1), 0.0);
			assertEquals(0, etu.calculeMoyenne(m2), 0.0);*/
		this.etu.ajouterNote(m3, 15);
		this.etu.ajouterNote(m3, 12);
		this.etu.calculeMoyenne(m3);
		/*fail("Devrait lever une exception de type MatiereAbsenteException");*/
	}
 
	@Test
	public void testCalculMoyenneGenerale() {
		// RAJOUTER LA METHODE AJOUTERNOTE(MATIERE, INT) DANS LA CLASSE ETUDIANT !!!
		this.etu.ajouterNote(m1, 15);
		this.etu.ajouterNote(m1, 12);
		this.etu.ajouterNote(m2, 17);
		this.etu.ajouterNote(m2, 15);
 
		assertEquals(14.25, etu.calculeMoyenneGenerale(), 0.0); 
	}
 
	@Test (expected = Exception.class)
	public void testCalculMoyenneGeneraleSansNote() {
		// TRAITER UNE EXCEPTION EN CAS DE NOTES INEXISTANTES ?
		assertEquals(0, etu.calculeMoyenneGenerale(), 0.0);
	}
}

Merci d'avance pour votre réponse ! ;-)

Je remplacerais ça
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 @Test public void testCalculMoyenneMatieresExistantes() { this.etu.ajouterNote(m1, 15); this.etu.ajouterNote(m1, 12); this.etu.ajouterNote(m2, 17); this.etu.ajouterNote(m2, 15); try { assertEquals(13.50, etu.calculeMoyenne(m1), 0.0); assertEquals(16.00, etu.calculeMoyenne(m2), 0.0); } catch (NotesAbsentesException e) { e.printStackTrace(); } catch (MatiereAbsenteException e) { } }
Par ça
Code:

1 2 3 4 5 6 7 8 9 10 11 @Test public void testCalculMoyenneMatieresExistantes() throws NotesAbsentesException, MatiereAbsenteException { this.etu.ajouterNote(m1, 15); this.etu.ajouterNote(m1, 12); this.etu.ajouterNote(m2, 17); this.etu.ajouterNote(m2, 15); assertEquals(13.50, etu.calculeMoyenne(m1), 0.0); assertEquals(16.00, etu.calculeMoyenne(m2), 0.0); }
Tu n'es pas censé traiter directement tes exceptions, sauf celles volontairement déclenchées pour le scénario, dans le test. Une exception non attendue doit être traitée comme un échec du test. Le plus simple c'est de la propager vers junit. Ton test ne peux pas être à la fois "si ça réussi j'ai 16.00" et "ou alors j'ai une exception". Ton test dois être "j'attends 16.00 en retour et tout autre comportement est une erreur mettant le test en rouge"

07/10/2017, 20h42
bgreme

C'est surtout pour le test testCalculMoyenneMatieresInexistantes() où j'ai quelques soucis... ;)
07/10/2017, 20h47
tchize_

Tu ne peux pas utiliser le @Test(expected=....) et le @Rule ExpectedException en même temps. Soit l'un soit l'autre. Ta rule pour le moment fait "ho c'est bien l'exception que j'attendais, tout va bien, pas d'erreur" puis junit dit "ben elle est où l'exception que je suis censé avoir?"
07/10/2017, 20h49
bgreme

Oui oui, je l'avais compris ça, c'est juste que j'ai essayé les deux et j'ai omis d'en enlever un. J'avais prévenu, le code serait faux à cause de nombreuses solutions que j'ai testées !
07/10/2017, 20h52
bgreme

Mais comment faire pour par exemple faire @Test (expected=MatiereAbsenteException.class | NotesAbsentesException.class) même si cette notation est fausse ?
En plus, Éclipse me demande malgré le @Test(expected...) de mettre un try/catch ou throws, je ne comprends plus rien !
08/10/2017, 00h49
tchize_

Si tu ne sais pas quelle exception tu va chopper, c'est que ton test est mal pensé. Ton test dois tester un ensemble de conditions et un résultat précis attendu. Ce résultat peut être NotesAbsentesException ou MatiereAbsenteException mais pas les deux en même temps, puisque tu ne peux lancer qu'une exception à la fois. Donc tu devrais avoir 2 tests unitaires: un qui instaure les conditions pour déclencher une NotesAbsentesException et un autre qui instaure les conditions pour une MatiereAbsenteException
08/10/2017, 00h51
bgreme

Citation:

Envoyé par tchize_

Si tu ne sais pas quel exception tu va chopper, c'est que ton test est mal pensé. Ton test dois tester un ensemble de condition et un résultat précis attendu. Ce résultat peut être NotesAbsentesException ou MatiereAbsenteException mais pas les deux en même temps, puisque tu ne peux lancer qu'un exception à la fois. Donc tu devrais avoir 2 test unitaires: un qui instaure les conditions pour déclencher une NotesAbsentesException et un autre qui instaure les conditions pour une MatiereAbsenteException

Ok, c'est bien ce que je pensais faire de base, mais je suis tout à fait d'accord, le test a été mal pensé. Je testerai ça demain matin et je reviendrai vers vous pour voir si ça fonctionne bien, merci en tout cas pour votre aide précieuse !