Subversion Repositories eFlore/Applications.del

Rev

Rev 533 | Rev 580 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 533 Rev 553
1 
package org.tela_botanica.del.test.composants.moteurrecherche;
 1 
package org.tela_botanica.del.test.composants.moteurrecherche;
2 
 
 2 
 
3 
import static org.junit.Assert.*;
 3 
import static org.junit.Assert.*;
4 
import org.junit.Before;
 4 
import org.junit.Before;
5 
import org.junit.Test;
 5 
import org.junit.Test;
6 
import org.mockito.Mockito;
 6 
import org.mockito.Mockito;
7 
import org.tela_botanica.del.client.cache.CacheClient;
 7 
import org.tela_botanica.del.client.cache.CacheClient;
8 
import org.tela_botanica.del.client.composants.formulaires.AutoCompletionComboBoxPresenteur;
 8 
import org.tela_botanica.del.client.composants.formulaires.AutoCompletionComboBoxPresenteur;
9 
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;
 9 
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;
- 
 
 10 
import org.tela_botanica.del.client.config.Config;
10 
import org.tela_botanica.del.client.modeles.ModeRecherche;
 11 
import org.tela_botanica.del.client.modeles.ModeRecherche;
11 
import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;
 12 
import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;
12 
 
 13 
 
13 
 
 14 
 
14 
import com.google.gwt.http.client.Response;
 15 
import com.google.gwt.http.client.Response;
15 
import com.google.gwt.user.client.ui.HasWidgets;
 16 
import com.google.gwt.user.client.ui.HasWidgets;
16 
 
 17 
 
17 
public class MoteurRecherchePresenteurTest {
 18 
public class MoteurRecherchePresenteurTest {
18 
 
 19 
 
19 
	MoteurRecherchePresenteur presenteurRechercheObservation;
 20 
	MoteurRecherchePresenteur presenteurRechercheObservation;
20 
	MoteurRecherchePresenteur.Vue vueRechercheObservation;
 21 
	MoteurRecherchePresenteur.Vue vueRechercheObservation;
21 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsObservation;
 22 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsObservation;
22 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionTaxonsObservation;
 23 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionTaxonsObservation;
23 
	HasWidgets container;
 24 
	HasWidgets container;
24
25
25 
	MoteurRecherchePresenteur presenteurRechercheImage;
 26 
	MoteurRecherchePresenteur presenteurRechercheImage;
26 
	MoteurRecherchePresenteur.Vue vueRechercheImage;
 27 
	MoteurRecherchePresenteur.Vue vueRechercheImage;
27 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionImage;
 28 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionImage;
28 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;
 29 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;
29
30
30 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;
 31 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;
31 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;
 32 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;
32
33
33 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;
 34 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;
34 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;
 35 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;
35
36
36 
	boolean rechercheObservationEffectuee = false;
 37 
	boolean rechercheObservationEffectuee = false;
37 
	boolean rechercheImageEffectuee = false;
 38 
	boolean rechercheImageEffectuee = false;
38
39
39 
	@Before
 40 
	@Before
40 
	public void setUp() {
 41 
	public void setUp() {
41
- 
 
- 
 
 42 
		Config config = new Config();
- 
 
 43 
		String nomSciCompletionService = config.getUrl("nomSciCompletionService");
42 
		vueRechercheObservation = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
 44 
		vueRechercheObservation = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
43 
		vueAutoCompletionTaxonsObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
 45 
		vueAutoCompletionTaxonsObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
44 
		container = Mockito.mock(HasWidgets.class ,Mockito.RETURNS_MOCKS);
 46 
		container = Mockito.mock(HasWidgets.class ,Mockito.RETURNS_MOCKS);
45
47
46 
		presenteurAutoCompletionTaxonsObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionTaxonsObservation, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
 48 
		presenteurAutoCompletionTaxonsObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionTaxonsObservation, nomSciCompletionService) {
47
49
48 
			@Override
 50 
			@Override
49 
			protected String[] parserResultatRequete(Response response) {
 51 
			protected String[] parserResultatRequete(Response response) {
50 
				// TODO Auto-generated method stub
 52 
				// TODO Auto-generated method stub
51 
				return null;
 53 
				return null;
52 
			}
 54 
			}
53 
		};
 55 
		};
54
56
55 
		vueAutoCompletionCommunesObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
 57 
		vueAutoCompletionCommunesObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
56 
		presenteurAutoCompletionCommunesObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesObservation, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
 58 
		presenteurAutoCompletionCommunesObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesObservation, nomSciCompletionService) {
57
59
58 
			protected String effectuerPreTraitementChaineRequete(String requete) {
 60 
			protected String effectuerPreTraitementChaineRequete(String requete) {
59 
				return requete;
 61 
				return requete;
60 
			}
 62 
			}
61
63
62 
			@Override
 64 
			@Override
63 
			protected void surSelectionSuggestion(String suggestion) {
 65 
			protected void surSelectionSuggestion(String suggestion) {
64 
				String[] tableauCommuneDpt = suggestion.split(" ");
 66 
				String[] tableauCommuneDpt = suggestion.split(" ");
65 
				if(tableauCommuneDpt.length == 2) {
 67 
				if(tableauCommuneDpt.length == 2) {
66 
					setValeur(tableauCommuneDpt[0]);
 68 
					setValeur(tableauCommuneDpt[0]);
67 
				}
 69 
				}
68 
			}
 70 
			}
69 
 
 71 
 
70 
			@Override
 72 
			@Override
71 
			protected String[] parserResultatRequete(Response response) {
 73 
			protected String[] parserResultatRequete(Response response) {
72 
				return UtilitairesAutoCompletionService.parserRetourSimple(response);
 74 
				return UtilitairesAutoCompletionService.parserRetourSimple(response);
73 
			}
 75 
			}
74 
		};
 76 
		};
75
77
76 
		presenteurRechercheObservation = new MoteurRecherchePresenteur(presenteurAutoCompletionTaxonsObservation, presenteurAutoCompletionCommunesObservation, vueRechercheObservation, ModeRecherche.MODE_OBSERVATION) {
 78 
		presenteurRechercheObservation = new MoteurRecherchePresenteur(presenteurAutoCompletionTaxonsObservation, presenteurAutoCompletionCommunesObservation, vueRechercheObservation, ModeRecherche.MODE_OBSERVATION) {
77 
			public void lancerRecherche() {
 79 
			public void lancerRecherche() {
78 
				chercher();
 80 
				chercher();
79 
			}
 81 
			}
80 
		};
 82 
		};
81
83
82 
		vueRechercheImage = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
 84 
		vueRechercheImage = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
83 
		vueAutoCompletionImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
 85 
		vueAutoCompletionImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
84
86
85 
		presenteurAutoCompletionImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionImage, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
 87 
		presenteurAutoCompletionImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionImage, nomSciCompletionService) {
86
88
87 
			@Override
 89 
			@Override
88 
			protected String[] parserResultatRequete(Response response) {
 90 
			protected String[] parserResultatRequete(Response response) {
89 
				// TODO Auto-generated method stub
 91 
				// TODO Auto-generated method stub
90 
				return null;
 92 
				return null;
91 
			}
 93 
			}
92 
		};
 94 
		};
93
95
94 
		vueAutoCompletionCommunesImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
96 
		vueAutoCompletionCommunesImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
95 
		presenteurAutoCompletionCommunesImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesImage, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
 97 
		presenteurAutoCompletionCommunesImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesImage, nomSciCompletionService) {
96
98
97 
			protected String effectuerPreTraitementChaineRequete(String requete) {
 99 
			protected String effectuerPreTraitementChaineRequete(String requete) {
98 
				return requete;
 100 
				return requete;
99 
			}
 101 
			}
100
102
101 
			@Override
 103 
			@Override
102 
			protected void surSelectionSuggestion(String suggestion) {
 104 
			protected void surSelectionSuggestion(String suggestion) {
103 
				String[] tableauCommuneDpt = suggestion.split(" ");
 105 
				String[] tableauCommuneDpt = suggestion.split(" ");
104 
				if(tableauCommuneDpt.length == 2) {
 106 
				if(tableauCommuneDpt.length == 2) {
105 
					setValeur(tableauCommuneDpt[0]);
 107 
					setValeur(tableauCommuneDpt[0]);
106 
				}
 108 
				}
107 
			}
 109 
			}
108 
 
 110 
 
109 
			@Override
 111 
			@Override
110 
			protected String[] parserResultatRequete(Response response) {
 112 
			protected String[] parserResultatRequete(Response response) {
111 
				return UtilitairesAutoCompletionService.parserRetourSimple(response);
 113 
				return UtilitairesAutoCompletionService.parserRetourSimple(response);
112 
			}
 114 
			}
113 
		};
 115 
		};
114
116
115 
		presenteurRechercheImage = new MoteurRecherchePresenteur(presenteurAutoCompletionImage, presenteurAutoCompletionCommunesImage, vueRechercheImage, ModeRecherche.MODE_IMAGE) {
 117 
		presenteurRechercheImage = new MoteurRecherchePresenteur(presenteurAutoCompletionImage, presenteurAutoCompletionCommunesImage, vueRechercheImage, ModeRecherche.MODE_IMAGE) {
116 
			public void lancerRecherche() {
 118 
			public void lancerRecherche() {
117 
				chercher();
 119 
				chercher();
118 
			}
 120 
			}
119 
		};
 121 
		};
120 
	}
 122 
	}
121
123
122
124
123 
	private void chercher() {
 125 
	private void chercher() {
124 
		rechercheObservationEffectuee = true;
 126 
		rechercheObservationEffectuee = true;
125 
		rechercheImageEffectuee = true;
 127 
		rechercheImageEffectuee = true;
126 
	}
 128 
	}
127
129
128 
	@Test
 130 
	@Test
129 
	public void testModeRecherche() {
 131 
	public void testModeRecherche() {
130 
		assertEquals(ModeRecherche.MODE_IMAGE, presenteurRechercheImage.getMode());
 132 
		assertEquals(ModeRecherche.MODE_IMAGE, presenteurRechercheImage.getMode());
131 
		assertEquals(ModeRecherche.MODE_OBSERVATION, presenteurRechercheObservation.getMode());
 133 
		assertEquals(ModeRecherche.MODE_OBSERVATION, presenteurRechercheObservation.getMode());
132 
	}
 134 
	}
133
135
134 
	@Test
 136 
	@Test
135 
	public void testLancerRechercheLibreObs() {
137 
	public void testLancerRechercheLibreObs() {
136 
		presenteurRechercheObservation.go(container);
 138 
		presenteurRechercheObservation.go(container);
137 
		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Essai");
 139 
		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Essai");
138 
		presenteurRechercheObservation.collecterInfosRecherche();
 140 
		presenteurRechercheObservation.collecterInfosRecherche();
139 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 141 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
140
142
141 
		assertTrue(rechercheObservationEffectuee);
 143 
		assertTrue(rechercheObservationEffectuee);
142 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
 144 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
143 
	}
 145 
	}
144
146
145 
	@Test
 147 
	@Test
146 
	public void testLancerRechercheDepartementObs() {
148 
	public void testLancerRechercheDepartementObs() {
147 
		presenteurRechercheObservation.go(container);
 149 
		presenteurRechercheObservation.go(container);
148 
		Mockito.when(vueRechercheObservation.getDepartement()).thenReturn("34");
 150 
		Mockito.when(vueRechercheObservation.getDepartement()).thenReturn("34");
149 
		presenteurRechercheObservation.collecterInfosRecherche();
 151 
		presenteurRechercheObservation.collecterInfosRecherche();
150 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 152 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
151
153
152 
		assertTrue(rechercheObservationEffectuee);
 154 
		assertTrue(rechercheObservationEffectuee);
153 
		assertEquals("34", CacheClient.getInstance().getInformationsRechercheObservation().getDepartement());
 155 
		assertEquals("34", CacheClient.getInstance().getInformationsRechercheObservation().getDepartement());
154 
	}
 156 
	}
155
157
156 
	@Test
 158 
	@Test
157 
	public void testLancerRechercheTaxonObs() {
159 
	public void testLancerRechercheTaxonObs() {
158 
		presenteurRechercheObservation.go(container);
 160 
		presenteurRechercheObservation.go(container);
159 
		Mockito.when(presenteurAutoCompletionTaxonsObservation.getValeur()).thenReturn("Acer monsp.");
 161 
		Mockito.when(presenteurAutoCompletionTaxonsObservation.getValeur()).thenReturn("Acer monsp.");
160 
		presenteurRechercheObservation.collecterInfosRecherche();
 162 
		presenteurRechercheObservation.collecterInfosRecherche();
161 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 163 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
162
164
163 
		assertTrue(rechercheObservationEffectuee);
 165 
		assertTrue(rechercheObservationEffectuee);
164 
		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheObservation().getTaxon());
 166 
		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheObservation().getTaxon());
165 
	}
 167 
	}
166
168
167 
	@Test
 169 
	@Test
168 
	public void testLancerRechercheGenreObs() {
170 
	public void testLancerRechercheGenreObs() {
169 
		presenteurRechercheObservation.go(container);
 171 
		presenteurRechercheObservation.go(container);
170 
		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
 172 
		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
171 
		presenteurRechercheObservation.collecterInfosRecherche();
 173 
		presenteurRechercheObservation.collecterInfosRecherche();
172 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 174 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
173
175
174 
		assertTrue(rechercheObservationEffectuee);
 176 
		assertTrue(rechercheObservationEffectuee);
175 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
 177 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
176 
	}
 178 
	}
177
179
178 
	@Test
 180 
	@Test
179 
	public void testLancerRechercheMotCleObs() {
181 
	public void testLancerRechercheMotCleObs() {
180 
		presenteurRechercheObservation.go(container);
 182 
		presenteurRechercheObservation.go(container);
181 
		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("Fruit, fleur, feuille");
 183 
		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("Fruit, fleur, feuille");
182 
		presenteurRechercheObservation.collecterInfosRecherche();
 184 
		presenteurRechercheObservation.collecterInfosRecherche();
183 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 185 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
184
186
185 
		assertTrue(rechercheObservationEffectuee);
 187 
		assertTrue(rechercheObservationEffectuee);
186 
		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
 188 
		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
187 
	}
 189 
	}
188
190
189 
	@Test
 191 
	@Test
190 
	public void testLancerRechercheDateObs() {
192 
	public void testLancerRechercheDateObs() {
191 
		presenteurRechercheObservation.go(container);
 193 
		presenteurRechercheObservation.go(container);
192 
		Mockito.when(vueRechercheObservation.getDate()).thenReturn("10/02/2004");
 194 
		Mockito.when(vueRechercheObservation.getDate()).thenReturn("10/02/2004");
193 
		presenteurRechercheObservation.collecterInfosRecherche();
 195 
		presenteurRechercheObservation.collecterInfosRecherche();
194 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 196 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
195
197
196 
		assertTrue(rechercheObservationEffectuee);
 198 
		assertTrue(rechercheObservationEffectuee);
197 
		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheObservation().getDate());
 199 
		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheObservation().getDate());
198 
	}
 200 
	}
199
201
200 
	@Test
 202 
	@Test
201 
	public void testLancerRechercheCommuneObs() {
203 
	public void testLancerRechercheCommuneObs() {
202 
		presenteurRechercheObservation.go(container);
 204 
		presenteurRechercheObservation.go(container);
203 
		Mockito.when(presenteurAutoCompletionCommunesObservation.getValeur()).thenReturn("Montpellier");
 205 
		Mockito.when(presenteurAutoCompletionCommunesObservation.getValeur()).thenReturn("Montpellier");
204 
		presenteurRechercheObservation.collecterInfosRecherche();
 206 
		presenteurRechercheObservation.collecterInfosRecherche();
205 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 207 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
206
208
207 
		assertTrue(rechercheObservationEffectuee);
 209 
		assertTrue(rechercheObservationEffectuee);
208 
		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheObservation().getCommune());
 210 
		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheObservation().getCommune());
209 
	}
 211 
	}
210
212
211 
	@Test
 213 
	@Test
212 
	public void testLancerRechercheFamilleObs() {
214 
	public void testLancerRechercheFamilleObs() {
213 
		presenteurRechercheObservation.go(container);
 215 
		presenteurRechercheObservation.go(container);
214 
		Mockito.when(vueRechercheObservation.getFamille()).thenReturn("Asteracae");
 216 
		Mockito.when(vueRechercheObservation.getFamille()).thenReturn("Asteracae");
215 
		presenteurRechercheObservation.collecterInfosRecherche();
 217 
		presenteurRechercheObservation.collecterInfosRecherche();
216 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 218 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
217
219
218 
		assertTrue(rechercheObservationEffectuee);
 220 
		assertTrue(rechercheObservationEffectuee);
219 
		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
 221 
		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
220 
	}
 222 
	}
221
223
222 
	@Test
 224 
	@Test
223 
	public void testLancerRechercheTagObs() {
225 
	public void testLancerRechercheTagObs() {
224 
		presenteurRechercheObservation.go(container);
 226 
		presenteurRechercheObservation.go(container);
225 
		Mockito.when(vueRechercheObservation.getTag()).thenReturn("fleur, tige, épine");
 227 
		Mockito.when(vueRechercheObservation.getTag()).thenReturn("fleur, tige, épine");
226 
		presenteurRechercheObservation.collecterInfosRecherche();
 228 
		presenteurRechercheObservation.collecterInfosRecherche();
227 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 229 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
228
230
229 
		assertTrue(rechercheObservationEffectuee);
 231 
		assertTrue(rechercheObservationEffectuee);
230 
		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheObservation().getTag());
 232 
		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheObservation().getTag());
231 
	}
 233 
	}
232
234
233 
	@Test
 235 
	@Test
234 
	public void testLancerRechercheAuteurObs() {
236 
	public void testLancerRechercheAuteurObs() {
235 
		presenteurRechercheObservation.go(container);
 237 
		presenteurRechercheObservation.go(container);
236 
		Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
 238 
		Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
237 
		presenteurRechercheObservation.collecterInfosRecherche();
 239 
		presenteurRechercheObservation.collecterInfosRecherche();
238 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 240 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
239
241
240 
		assertTrue(rechercheObservationEffectuee);
 242 
		assertTrue(rechercheObservationEffectuee);
241 
		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
 243 
		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
242 
	}
 244 
	}
243
245
244 
	@Test
 246 
	@Test
245 
	public void testLancerRechercheLibreImage() {
247 
	public void testLancerRechercheLibreImage() {
246 
		presenteurRechercheImage.go(container);
 248 
		presenteurRechercheImage.go(container);
247 
		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Essai");
 249 
		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Essai");
248 
		presenteurRechercheImage.collecterInfosRecherche();
 250 
		presenteurRechercheImage.collecterInfosRecherche();
249 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 251 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
250
252
251 
		assertTrue(rechercheImageEffectuee);
 253 
		assertTrue(rechercheImageEffectuee);
252 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
 254 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
253 
	}
 255 
	}
254
256
255 
	@Test
 257 
	@Test
256 
	public void testLancerRechercheDepartementImage() {
258 
	public void testLancerRechercheDepartementImage() {
257 
		presenteurRechercheImage.go(container);
 259 
		presenteurRechercheImage.go(container);
258 
		Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
 260 
		Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
259 
		presenteurRechercheImage.collecterInfosRecherche();
 261 
		presenteurRechercheImage.collecterInfosRecherche();
260 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 262 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
261
263
262 
		assertTrue(rechercheImageEffectuee);
 264 
		assertTrue(rechercheImageEffectuee);
263 
		assertEquals("34", CacheClient.getInstance().getInformationsRechercheImage().getDepartement());
 265 
		assertEquals("34", CacheClient.getInstance().getInformationsRechercheImage().getDepartement());
264 
	}
 266 
	}
265
267
266 
	@Test
 268 
	@Test
267 
	public void testLancerRechercheTaxonImage() {
269 
	public void testLancerRechercheTaxonImage() {
268 
		presenteurRechercheImage.go(container);
 270 
		presenteurRechercheImage.go(container);
269 
		Mockito.when(presenteurAutoCompletionImage.getValeur()).thenReturn("Acer monsp.");
 271 
		Mockito.when(presenteurAutoCompletionImage.getValeur()).thenReturn("Acer monsp.");
270 
		presenteurRechercheImage.collecterInfosRecherche();
 272 
		presenteurRechercheImage.collecterInfosRecherche();
271 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 273 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
272
274
273 
		assertTrue(rechercheImageEffectuee);
 275 
		assertTrue(rechercheImageEffectuee);
274 
		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheImage().getTaxon());
 276 
		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheImage().getTaxon());
275 
	}
 277 
	}
276
278
277 
	@Test
 279 
	@Test
278 
	public void testLancerRechercheGenreImage() {
280 
	public void testLancerRechercheGenreImage() {
279 
		presenteurRechercheImage.go(container);
 281 
		presenteurRechercheImage.go(container);
280 
		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
 282 
		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
281 
		presenteurRechercheImage.collecterInfosRecherche();
 283 
		presenteurRechercheImage.collecterInfosRecherche();
282 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 284 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
283
285
284 
		assertTrue(rechercheImageEffectuee);
 286 
		assertTrue(rechercheImageEffectuee);
285 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheImage().getGenre());
 287 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheImage().getGenre());
286 
	}
 288 
	}
287
289
288 
	@Test
 290 
	@Test
289 
	public void testLancerRechercheMotCleImage() {
291 
	public void testLancerRechercheMotCleImage() {
290 
		presenteurRechercheImage.go(container);
 292 
		presenteurRechercheImage.go(container);
291 
		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("Fruit, fleur, feuille");
 293 
		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("Fruit, fleur, feuille");
292 
		presenteurRechercheImage.collecterInfosRecherche();
 294 
		presenteurRechercheImage.collecterInfosRecherche();
293 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 295 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
294
296
295 
		assertTrue(rechercheImageEffectuee);
 297 
		assertTrue(rechercheImageEffectuee);
296 
		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
 298 
		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
297 
	}
 299 
	}
298
300
299 
	@Test
 301 
	@Test
300 
	public void testLancerRechercheDateImage() {
302 
	public void testLancerRechercheDateImage() {
301 
		presenteurRechercheImage.go(container);
 303 
		presenteurRechercheImage.go(container);
302 
		Mockito.when(vueRechercheImage.getDate()).thenReturn("10/02/2004");
 304 
		Mockito.when(vueRechercheImage.getDate()).thenReturn("10/02/2004");
303 
		presenteurRechercheImage.collecterInfosRecherche();
 305 
		presenteurRechercheImage.collecterInfosRecherche();
304 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 306 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
305
307
306 
		assertTrue(rechercheImageEffectuee);
 308 
		assertTrue(rechercheImageEffectuee);
307 
		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheImage().getDate());
 309 
		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheImage().getDate());
308 
	}
 310 
	}
309
311
310 
	@Test
 312 
	@Test
311 
	public void testLancerRechercheCommuneImage() {
313 
	public void testLancerRechercheCommuneImage() {
312 
		presenteurRechercheImage.go(container);
 314 
		presenteurRechercheImage.go(container);
313 
		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Montpellier");
 315 
		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Montpellier");
314 
		presenteurRechercheImage.collecterInfosRecherche();
 316 
		presenteurRechercheImage.collecterInfosRecherche();
315 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 317 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
316
318
317 
		assertTrue(rechercheImageEffectuee);
 319 
		assertTrue(rechercheImageEffectuee);
318 
		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheImage().getCommune());
 320 
		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheImage().getCommune());
319 
	}
 321 
	}
320
322
321 
	@Test
 323 
	@Test
322 
	public void testLancerRechercheFamilleImage() {
324 
	public void testLancerRechercheFamilleImage() {
323 
		presenteurRechercheImage.go(container);
 325 
		presenteurRechercheImage.go(container);
324 
		Mockito.when(vueRechercheImage.getFamille()).thenReturn("Asteracae");
 326 
		Mockito.when(vueRechercheImage.getFamille()).thenReturn("Asteracae");
325 
		presenteurRechercheImage.collecterInfosRecherche();
 327 
		presenteurRechercheImage.collecterInfosRecherche();
326 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 328 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
327
329
328 
		assertTrue(rechercheImageEffectuee);
 330 
		assertTrue(rechercheImageEffectuee);
329 
		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheImage().getFamille());
 331 
		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheImage().getFamille());
330 
	}
 332 
	}
331
333
332 
	@Test
 334 
	@Test
333 
	public void testLancerRechercheTagImage() {
335 
	public void testLancerRechercheTagImage() {
334 
		presenteurRechercheImage.go(container);
 336 
		presenteurRechercheImage.go(container);
335 
		Mockito.when(vueRechercheImage.getTag()).thenReturn("fleur, tige, épine");
 337 
		Mockito.when(vueRechercheImage.getTag()).thenReturn("fleur, tige, épine");
336 
		presenteurRechercheImage.collecterInfosRecherche();
 338 
		presenteurRechercheImage.collecterInfosRecherche();
337 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 339 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
338
340
339 
		assertTrue(rechercheImageEffectuee);
 341 
		assertTrue(rechercheImageEffectuee);
340 
		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheImage().getTag());
 342 
		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheImage().getTag());
341 
	}
 343 
	}
342
344
343 
	@Test
 345 
	@Test
344 
	public void testLancerRechercheAuteurImage() {
346 
	public void testLancerRechercheAuteurImage() {
345 
		presenteurRechercheImage.go(container);
 347 
		presenteurRechercheImage.go(container);
346 
		Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
 348 
		Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
347 
		presenteurRechercheImage.collecterInfosRecherche();
 349 
		presenteurRechercheImage.collecterInfosRecherche();
348 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 350 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
349
351
350 
		assertTrue(rechercheImageEffectuee);
 352 
		assertTrue(rechercheImageEffectuee);
351 
		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
 353 
		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
352 
	}
 354 
	}
353 
}
 355 
}