Subversion Repositories eFlore/Applications.del

Rev

Rev 585 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
452 aurelien 1 
package org.tela_botanica.del.test.composants.moteurrecherche;
2 
 
3 
import static org.junit.Assert.*;
4 
import org.junit.Before;
5 
import org.junit.Test;
6 
import org.mockito.Mockito;
7 
import org.tela_botanica.del.client.cache.CacheClient;
602 aurelien 8 
import org.tela_botanica.del.client.composants.formulaires.autocompletion.AutoCompletionComboBoxPresenteur;
452 aurelien 9 
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;
585 jpm 10 
import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur.TypeMoteur;
553 jpm 11 
import org.tela_botanica.del.client.config.Config;
452 aurelien 12 
import org.tela_botanica.del.client.modeles.ModeRecherche;
500 aurelien 13 
import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;
452 aurelien 14 
 
15 
 
16 
import com.google.gwt.http.client.Response;
17 
import com.google.gwt.user.client.ui.HasWidgets;
18 
 
19 
public class MoteurRecherchePresenteurTest {
20 
 
21 
	MoteurRecherchePresenteur presenteurRechercheObservation;
22 
	MoteurRecherchePresenteur.Vue vueRechercheObservation;
470 aurelien 23 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsObservation;
24 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionTaxonsObservation;
452 aurelien 25 
	HasWidgets container;
26 
 
27 
	MoteurRecherchePresenteur presenteurRechercheImage;
28 
	MoteurRecherchePresenteur.Vue vueRechercheImage;
585 jpm 29 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsImage;
452 aurelien 30 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;
31 
 
470 aurelien 32 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;
33 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;
34 
 
35 
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;
36 
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;
37 
 
585 jpm 38 
	Config config;
39 
 
452 aurelien 40 
	boolean rechercheObservationEffectuee = false;
41 
	boolean rechercheImageEffectuee = false;
585 jpm 42 
	private static String NOM_SCI_COMPLETION_SERVICE = "URL_FACTICE";
452 aurelien 43 
 
44 
	@Before
45 
	public void setUp() {
46 
		vueRechercheObservation = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
585 jpm 47 
		vueAutoCompletionTaxonsObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class, Mockito.RETURNS_MOCKS);
48 
		container = Mockito.mock(HasWidgets.class, Mockito.RETURNS_MOCKS);
452 aurelien 49 
 
585 jpm 50 
		presenteurAutoCompletionTaxonsObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionTaxonsObservation, NOM_SCI_COMPLETION_SERVICE) {
452 aurelien 51 
			@Override
52 
			protected String[] parserResultatRequete(Response response) {
53 
				// TODO Auto-generated method stub
54 
				return null;
55 
			}
56 
		};
57 
 
585 jpm 58 
		vueAutoCompletionCommunesObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class, Mockito.RETURNS_MOCKS);
59 
		presenteurAutoCompletionCommunesObservation = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesObservation, NOM_SCI_COMPLETION_SERVICE) {
470 aurelien 60 
			protected String effectuerPreTraitementChaineRequete(String requete) {
61 
				return requete;
62 
			}
63 
 
64 
			@Override
65 
			protected void surSelectionSuggestion(String suggestion) {
66 
				String[] tableauCommuneDpt = suggestion.split(" ");
585 jpm 67 
				if (tableauCommuneDpt.length == 2) {
470 aurelien 68 
					setValeur(tableauCommuneDpt[0]);
69 
				}
70 
			}
71 
 
72 
			@Override
73 
			protected String[] parserResultatRequete(Response response) {
74 
				return UtilitairesAutoCompletionService.parserRetourSimple(response);
75 
			}
76 
		};
77 
 
585 jpm 78 
		this.config = Mockito.mock(Config.class, Mockito.RETURNS_MOCKS);
79 
		Mockito.when(config.getUrl("nomSciCompletionService")).thenReturn(NOM_SCI_COMPLETION_SERVICE);
80 
 
81 
		presenteurRechercheObservation = new MoteurRecherchePresenteur(
82 
			presenteurAutoCompletionTaxonsObservation,
83 
			presenteurAutoCompletionCommunesObservation,
84 
			vueRechercheObservation,
85 
			ModeRecherche.MODE_OBSERVATION,
86 
			config) {
87 
 
452 aurelien 88 
			public void lancerRecherche() {
89 
				chercher();
90 
			}
91 
		};
92 
 
93 
		vueRechercheImage = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
94 
		vueAutoCompletionImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
95 
 
585 jpm 96 
		presenteurAutoCompletionTaxonsImage = new AutoCompletionComboBoxPresenteur(vueAutoCompletionImage, NOM_SCI_COMPLETION_SERVICE) {
452 aurelien 97 
			@Override
98 
			protected String[] parserResultatRequete(Response response) {
99 
				// TODO Auto-generated method stub
100 
				return null;
101 
			}
102 
		};
470 aurelien 103 
 
104 
		vueAutoCompletionCommunesImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
585 jpm 105 
		presenteurAutoCompletionCommunesImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesImage, NOM_SCI_COMPLETION_SERVICE) {
470 aurelien 106 
			protected String effectuerPreTraitementChaineRequete(String requete) {
107 
				return requete;
108 
			}
109 
 
110 
			@Override
111 
			protected void surSelectionSuggestion(String suggestion) {
112 
				String[] tableauCommuneDpt = suggestion.split(" ");
113 
				if(tableauCommuneDpt.length == 2) {
114 
					setValeur(tableauCommuneDpt[0]);
115 
				}
116 
			}
117 
 
118 
			@Override
119 
			protected String[] parserResultatRequete(Response response) {
120 
				return UtilitairesAutoCompletionService.parserRetourSimple(response);
121 
			}
122 
		};
452 aurelien 123 
 
585 jpm 124 
		presenteurRechercheImage = new MoteurRecherchePresenteur(
125 
				presenteurAutoCompletionTaxonsImage,
126 
				presenteurAutoCompletionCommunesImage,
127 
				vueRechercheImage,
128 
				ModeRecherche.MODE_IMAGE,
129 
				config) {
452 aurelien 130 
			public void lancerRecherche() {
131 
				chercher();
132 
			}
133 
		};
134 
	}
135 
 
136 
	private void chercher() {
137 
		rechercheObservationEffectuee = true;
138 
		rechercheImageEffectuee = true;
139 
	}
140 
 
585 jpm 141 
	//+------------------------------------------------------------------------------------------------------+
142 
	// OBSERVATIONS
143 
 
452 aurelien 144 
	@Test
585 jpm 145 
	public void testTypeMoteurParDefautEstSimpleObs() {
146 
		assertEquals(TypeMoteur.SIMPLE, presenteurRechercheObservation.getTypeMoteur());
147 
	}
148 
 
149 
	@Test
452 aurelien 150 
	public void testModeRecherche() {
151 
		assertEquals(ModeRecherche.MODE_IMAGE, presenteurRechercheImage.getMode());
152 
		assertEquals(ModeRecherche.MODE_OBSERVATION, presenteurRechercheObservation.getMode());
153 
	}
154 
 
155 
	@Test
585 jpm 156 
	public void testObsRechercheSimpleNeRetournePasLesChampsAvancee() {
157 
		presenteurRechercheObservation.go(container);
158 
		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Essai");
159 
		Mockito.when(vueRechercheObservation.getContientMots()).thenReturn("");
160 
		Mockito.when(presenteurAutoCompletionTaxonsObservation.getValeur()).thenReturn("Acer monsp.");
161 
		Mockito.when(vueRechercheObservation.getDepartement()).thenReturn("34");
162 
		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
163 
		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("Fruit, fleur, feuille");
164 
		Mockito.when(vueRechercheObservation.getDate()).thenReturn("10/02/2004");
165 
		Mockito.when(presenteurAutoCompletionCommunesObservation.getValeur()).thenReturn("Montpellier");
166 
		Mockito.when(vueRechercheObservation.getFamille()).thenReturn("Asteracae");
167 
		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("fleur, tige, épine");
168 
		Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
169 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.SIMPLE);
170 
		presenteurRechercheObservation.collecterInfosRecherche();
171 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
172 
 
173 
		assertTrue(rechercheObservationEffectuee);
174 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
175 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getTaxon());
176 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getDepartement());
177 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
178 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
179 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getDate());
180 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getCommune());
181 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
182 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
183 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
184 
	}
185 
 
186 
	@Test
187 
	public void testObsRechercheAvanceeUtiliseChampContientMots() {
188 
		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Simple");
189 
		Mockito.when(vueRechercheObservation.getContientMots()).thenReturn("Avancee");
190 
		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
191 
 
192 
		presenteurRechercheObservation.go(container);
193 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
194 
		presenteurRechercheObservation.collecterInfosRecherche();
195 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
196 
 
197 
		assertTrue(rechercheObservationEffectuee);
198 
		assertEquals("Avancee", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
199 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
200 
	}
201 
 
202 
	@Test
452 aurelien 203 
	public void testLancerRechercheLibreObs() {
204 
		presenteurRechercheObservation.go(container);
533 jpm 205 
		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Essai");
452 aurelien 206 
		presenteurRechercheObservation.collecterInfosRecherche();
207 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
208 
 
209 
		assertTrue(rechercheObservationEffectuee);
210 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
211 
	}
212 
 
213 
	@Test
214 
	public void testLancerRechercheDepartementObs() {
215 
		presenteurRechercheObservation.go(container);
216 
		Mockito.when(vueRechercheObservation.getDepartement()).thenReturn("34");
585 jpm 217 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 218 
		presenteurRechercheObservation.collecterInfosRecherche();
219 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
220 
 
221 
		assertTrue(rechercheObservationEffectuee);
222 
		assertEquals("34", CacheClient.getInstance().getInformationsRechercheObservation().getDepartement());
223 
	}
224 
 
225 
	@Test
226 
	public void testLancerRechercheTaxonObs() {
227 
		presenteurRechercheObservation.go(container);
470 aurelien 228 
		Mockito.when(presenteurAutoCompletionTaxonsObservation.getValeur()).thenReturn("Acer monsp.");
585 jpm 229 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 230 
		presenteurRechercheObservation.collecterInfosRecherche();
231 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
232 
 
233 
		assertTrue(rechercheObservationEffectuee);
234 
		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheObservation().getTaxon());
235 
	}
236 
 
237 
	@Test
238 
	public void testLancerRechercheGenreObs() {
239 
		presenteurRechercheObservation.go(container);
240 
		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
585 jpm 241 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 242 
		presenteurRechercheObservation.collecterInfosRecherche();
243 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
244 
 
245 
		assertTrue(rechercheObservationEffectuee);
246 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
247 
	}
248 
 
249 
	@Test
250 
	public void testLancerRechercheMotCleObs() {
251 
		presenteurRechercheObservation.go(container);
252 
		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("Fruit, fleur, feuille");
585 jpm 253 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 254 
		presenteurRechercheObservation.collecterInfosRecherche();
255 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
256 
 
257 
		assertTrue(rechercheObservationEffectuee);
258 
		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
259 
	}
260 
 
261 
	@Test
262 
	public void testLancerRechercheDateObs() {
263 
		presenteurRechercheObservation.go(container);
264 
		Mockito.when(vueRechercheObservation.getDate()).thenReturn("10/02/2004");
585 jpm 265 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 266 
		presenteurRechercheObservation.collecterInfosRecherche();
267 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
268 
 
269 
		assertTrue(rechercheObservationEffectuee);
270 
		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheObservation().getDate());
271 
	}
272 
 
273 
	@Test
274 
	public void testLancerRechercheCommuneObs() {
275 
		presenteurRechercheObservation.go(container);
470 aurelien 276 
		Mockito.when(presenteurAutoCompletionCommunesObservation.getValeur()).thenReturn("Montpellier");
585 jpm 277 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 278 
		presenteurRechercheObservation.collecterInfosRecherche();
279 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
280 
 
281 
		assertTrue(rechercheObservationEffectuee);
282 
		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheObservation().getCommune());
283 
	}
284 
 
285 
	@Test
286 
	public void testLancerRechercheFamilleObs() {
287 
		presenteurRechercheObservation.go(container);
288 
		Mockito.when(vueRechercheObservation.getFamille()).thenReturn("Asteracae");
585 jpm 289 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 290 
		presenteurRechercheObservation.collecterInfosRecherche();
291 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
292 
 
293 
		assertTrue(rechercheObservationEffectuee);
294 
		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
295 
	}
296 
 
297 
	@Test
298 
	public void testLancerRechercheTagObs() {
299 
		presenteurRechercheObservation.go(container);
580 gduche 300 
		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("fleur, tige, épine");
585 jpm 301 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 302 
		presenteurRechercheObservation.collecterInfosRecherche();
303 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
304 
 
305 
		assertTrue(rechercheObservationEffectuee);
580 gduche 306 
		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
452 aurelien 307 
	}
308 
 
309 
	@Test
310 
	public void testLancerRechercheAuteurObs() {
311 
		presenteurRechercheObservation.go(container);
312 
		Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
585 jpm 313 
		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 314 
		presenteurRechercheObservation.collecterInfosRecherche();
315 
		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
316 
 
317 
		assertTrue(rechercheObservationEffectuee);
318 
		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
319 
	}
320 
 
585 jpm 321 
	//+------------------------------------------------------------------------------------------------------+
322 
	// IMAGES
323 
 
452 aurelien 324 
	@Test
585 jpm 325 
	public void testTypeMoteurParDefautEstSimpleImage() {
326 
		assertEquals(TypeMoteur.SIMPLE, presenteurRechercheImage.getTypeMoteur());
327 
	}
328 
 
329 
	@Test
452 aurelien 330 
	public void testLancerRechercheLibreImage() {
331 
		presenteurRechercheImage.go(container);
533 jpm 332 
		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Essai");
452 aurelien 333 
		presenteurRechercheImage.collecterInfosRecherche();
334 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
335 
 
336 
		assertTrue(rechercheImageEffectuee);
337 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
338 
	}
339 
 
340 
	@Test
585 jpm 341 
	public void testImageLancerRechercheSimpleNeRetournePasLesChampsAvancee() {
342 
		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Essai");
343 
		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Acer monsp.");
344 
		Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
345 
		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
346 
		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("Fruit, fleur, feuille");
347 
		Mockito.when(vueRechercheImage.getDate()).thenReturn("10/02/2004");
348 
		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Montpellier");
349 
		Mockito.when(vueRechercheImage.getFamille()).thenReturn("Asteracae");
350 
		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("fleur, tige, épine");
351 
		Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
352 
 
353 
		presenteurRechercheImage.go(container);
354 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.SIMPLE);
355 
		presenteurRechercheImage.collecterInfosRecherche();
356 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
357 
 
358 
		assertTrue(rechercheImageEffectuee);
359 
		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
360 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getTaxon());
361 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getDepartement());
362 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getGenre());
363 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
364 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getDate());
365 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getCommune());
366 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getFamille());
367 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
368 
		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
369 
	}
370 
 
371 
	@Test
372 
	public void testImageRechercheAvanceeUtiliseChampContientMots() {
373 
		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Simple");
374 
		Mockito.when(vueRechercheImage.getContientMots()).thenReturn("Avancee");
375 
		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
376 
 
377 
		presenteurRechercheImage.go(container);
378 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
379 
		presenteurRechercheImage.collecterInfosRecherche();
380 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
381 
 
382 
		assertTrue(rechercheImageEffectuee);
383 
		assertEquals("Avancee", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
384 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheImage().getGenre());
385 
	}
386 
 
387 
	@Test
452 aurelien 388 
	public void testLancerRechercheDepartementImage() {
389 
		presenteurRechercheImage.go(container);
390 
		Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
585 jpm 391 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 392 
		presenteurRechercheImage.collecterInfosRecherche();
393 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
394 
 
395 
		assertTrue(rechercheImageEffectuee);
396 
		assertEquals("34", CacheClient.getInstance().getInformationsRechercheImage().getDepartement());
397 
	}
398 
 
399 
	@Test
400 
	public void testLancerRechercheTaxonImage() {
401 
		presenteurRechercheImage.go(container);
585 jpm 402 
		Mockito.when(presenteurAutoCompletionTaxonsImage.getValeur()).thenReturn("Acer monsp.");
403 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 404 
		presenteurRechercheImage.collecterInfosRecherche();
405 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
406 
 
407 
		assertTrue(rechercheImageEffectuee);
408 
		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheImage().getTaxon());
409 
	}
410 
 
411 
	@Test
412 
	public void testLancerRechercheGenreImage() {
413 
		presenteurRechercheImage.go(container);
414 
		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
585 jpm 415 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 416 
		presenteurRechercheImage.collecterInfosRecherche();
417 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
418 
 
419 
		assertTrue(rechercheImageEffectuee);
420 
		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheImage().getGenre());
421 
	}
422 
 
423 
	@Test
424 
	public void testLancerRechercheMotCleImage() {
425 
		presenteurRechercheImage.go(container);
426 
		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("Fruit, fleur, feuille");
585 jpm 427 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 428 
		presenteurRechercheImage.collecterInfosRecherche();
429 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
430 
 
431 
		assertTrue(rechercheImageEffectuee);
432 
		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
433 
	}
434 
 
435 
	@Test
436 
	public void testLancerRechercheDateImage() {
437 
		presenteurRechercheImage.go(container);
438 
		Mockito.when(vueRechercheImage.getDate()).thenReturn("10/02/2004");
585 jpm 439 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 440 
		presenteurRechercheImage.collecterInfosRecherche();
441 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
442 
 
443 
		assertTrue(rechercheImageEffectuee);
444 
		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheImage().getDate());
445 
	}
446 
 
447 
	@Test
448 
	public void testLancerRechercheCommuneImage() {
449 
		presenteurRechercheImage.go(container);
470 aurelien 450 
		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Montpellier");
585 jpm 451 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 452 
		presenteurRechercheImage.collecterInfosRecherche();
453 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
454 
 
455 
		assertTrue(rechercheImageEffectuee);
456 
		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheImage().getCommune());
457 
	}
458 
 
459 
	@Test
460 
	public void testLancerRechercheFamilleImage() {
461 
		presenteurRechercheImage.go(container);
462 
		Mockito.when(vueRechercheImage.getFamille()).thenReturn("Asteracae");
585 jpm 463 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 464 
		presenteurRechercheImage.collecterInfosRecherche();
465 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
466 
 
467 
		assertTrue(rechercheImageEffectuee);
468 
		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheImage().getFamille());
469 
	}
470 
 
471 
	@Test
472 
	public void testLancerRechercheTagImage() {
473 
		presenteurRechercheImage.go(container);
580 gduche 474 
		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("fleur, tige, épine");
585 jpm 475 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 476 
		presenteurRechercheImage.collecterInfosRecherche();
477 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
478 
 
479 
		assertTrue(rechercheImageEffectuee);
580 gduche 480 
		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
452 aurelien 481 
	}
482 
 
483 
	@Test
484 
	public void testLancerRechercheAuteurImage() {
485 
		presenteurRechercheImage.go(container);
486 
		Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
585 jpm 487 
		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
452 aurelien 488 
		presenteurRechercheImage.collecterInfosRecherche();
489 
		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
490 
 
491 
		assertTrue(rechercheImageEffectuee);
492 
		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
493 
	}
494 
}