Subversion Repositories eFlore/Applications.del

Rev

Go to most recent revision | Details | 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;
8
import org.tela_botanica.del.client.composants.formulaires.AutoCompletionComboBoxPresenteur;
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
}