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