Subversion Repositories eFlore/Applications.del

Rev

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