WebSVN – eFlore/Applications.del – Diff – /trunk/src/org/tela_botanica/del/test/composants/moteurrecherche/MoteurRecherchePresenteurTest.java

 package org.tela_botanica.del.test.composants.moteurrecherche;
 import static org.junit.Assert.*;
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mockito;
 import org.tela_botanica.del.client.cache.CacheClient;
 import org.tela_botanica.del.client.composants.formulaires.AutoCompletionComboBoxPresenteur;
 import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;
+import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur.TypeMoteur;
 import org.tela_botanica.del.client.config.Config;
 import org.tela_botanica.del.client.modeles.ModeRecherche;
 import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;
 import com.google.gwt.http.client.Response;
 import com.google.gwt.user.client.ui.HasWidgets;
 public class MoteurRecherchePresenteurTest {
 	MoteurRecherchePresenteur presenteurRechercheObservation;
 	MoteurRecherchePresenteur.Vue vueRechercheObservation;
 	AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsObservation;
 	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionTaxonsObservation;
 	HasWidgets container;
 	MoteurRecherchePresenteur presenteurRechercheImage;
 	MoteurRecherchePresenteur.Vue vueRechercheImage;
-	AutoCompletionComboBoxPresenteur presenteurAutoCompletionImage;
+	AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsImage;
 	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;
 	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;
 	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;
 	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;
 	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;
+	Config config;
 	boolean rechercheObservationEffectuee = false;
+	boolean rechercheImageEffectuee = false;
-	boolean rechercheImageEffectuee = false;
+	private static String NOM_SCI_COMPLETION_SERVICE = "URL_FACTICE";
 	@Before
 	public void setUp() {
-		Config config = new Config();
-		String nomSciCompletionService = config.getUrl("nomSciCompletionService");
 		vueRechercheObservation = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
-		vueAutoCompletionTaxonsObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
+		vueAutoCompletionTaxonsObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class, Mockito.RETURNS_MOCKS);
-		container = Mockito.mock(HasWidgets.class ,Mockito.RETURNS_MOCKS);
+		container = Mockito.mock(HasWidgets.class, Mockito.RETURNS_MOCKS);
-		presenteurAutoCompletionTaxonsObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionTaxonsObservation, nomSciCompletionService) {
 		presenteurAutoCompletionTaxonsObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionTaxonsObservation, NOM_SCI_COMPLETION_SERVICE) {
 			@Override
 			protected String[] parserResultatRequete(Response response) {
 				// TODO Auto-generated method stub
 				return null;
+			}
 		};
-		vueAutoCompletionCommunesObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
+		vueAutoCompletionCommunesObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class, Mockito.RETURNS_MOCKS);
-		presenteurAutoCompletionCommunesObservation  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesObservation, nomSciCompletionService) {
 		presenteurAutoCompletionCommunesObservation = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesObservation, NOM_SCI_COMPLETION_SERVICE) {
 			protected String effectuerPreTraitementChaineRequete(String requete) {
 				return requete;
+			}
 			@Override
 			protected void surSelectionSuggestion(String suggestion) {
 				String[] tableauCommuneDpt = suggestion.split(" ");
-				if(tableauCommuneDpt.length == 2) {
+				if (tableauCommuneDpt.length == 2) {
 					setValeur(tableauCommuneDpt[0]);
+				}
+			}
 			@Override
 			protected String[] parserResultatRequete(Response response) {
 				return UtilitairesAutoCompletionService.parserRetourSimple(response);
+			}
 		};
+		this.config = Mockito.mock(Config.class, Mockito.RETURNS_MOCKS);
+		Mockito.when(config.getUrl("nomSciCompletionService")).thenReturn(NOM_SCI_COMPLETION_SERVICE);
+		presenteurRechercheObservation = new MoteurRecherchePresenteur(
+			presenteurAutoCompletionTaxonsObservation,
+			presenteurAutoCompletionCommunesObservation,
+			vueRechercheObservation,
+			ModeRecherche.MODE_OBSERVATION,
+			config) {
 		presenteurRechercheObservation = new MoteurRecherchePresenteur(presenteurAutoCompletionTaxonsObservation, presenteurAutoCompletionCommunesObservation, vueRechercheObservation, ModeRecherche.MODE_OBSERVATION) {
 			public void lancerRecherche() {
 				chercher();
+			}
 		};
 		vueRechercheImage = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
 		vueAutoCompletionImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
-		presenteurAutoCompletionImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionImage, nomSciCompletionService) {
 		presenteurAutoCompletionTaxonsImage = new AutoCompletionComboBoxPresenteur(vueAutoCompletionImage, NOM_SCI_COMPLETION_SERVICE) {
 			@Override
 			protected String[] parserResultatRequete(Response response) {
 				// TODO Auto-generated method stub
 				return null;
+			}
 		};
 		vueAutoCompletionCommunesImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
-		presenteurAutoCompletionCommunesImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesImage, nomSciCompletionService) {
+		presenteurAutoCompletionCommunesImage  = new AutoCompletionComboBoxPresenteur(vueAutoCompletionCommunesImage, NOM_SCI_COMPLETION_SERVICE) {
 			protected String effectuerPreTraitementChaineRequete(String requete) {
 				return requete;
+			}
 			@Override
 			protected void surSelectionSuggestion(String suggestion) {
 				String[] tableauCommuneDpt = suggestion.split(" ");
 				if(tableauCommuneDpt.length == 2) {
 					setValeur(tableauCommuneDpt[0]);
+				}
+			}
 			@Override
 			protected String[] parserResultatRequete(Response response) {
 				return UtilitairesAutoCompletionService.parserRetourSimple(response);
+			}
 		};
+		presenteurRechercheImage = new MoteurRecherchePresenteur(
+				presenteurAutoCompletionTaxonsImage,
+				presenteurAutoCompletionCommunesImage,
+				vueRechercheImage,
+				ModeRecherche.MODE_IMAGE,
-		presenteurRechercheImage = new MoteurRecherchePresenteur(presenteurAutoCompletionImage, presenteurAutoCompletionCommunesImage, vueRechercheImage, ModeRecherche.MODE_IMAGE) {
+				config) {
 			public void lancerRecherche() {
 				chercher();
+			}
 		};
+	}
 	private void chercher() {
 		rechercheObservationEffectuee = true;
 		rechercheImageEffectuee = true;
+	}
+	//+------------------------------------------------------------------------------------------------------+
+	// OBSERVATIONS
+	@Test
+	public void testTypeMoteurParDefautEstSimpleObs() {
+		assertEquals(TypeMoteur.SIMPLE, presenteurRechercheObservation.getTypeMoteur());
+	}
 	@Test
 	public void testModeRecherche() {
 		assertEquals(ModeRecherche.MODE_IMAGE, presenteurRechercheImage.getMode());
 		assertEquals(ModeRecherche.MODE_OBSERVATION, presenteurRechercheObservation.getMode());
+	}
 	@Test
+	public void testObsRechercheSimpleNeRetournePasLesChampsAvancee() {
+		presenteurRechercheObservation.go(container);
+		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Essai");
+		Mockito.when(vueRechercheObservation.getContientMots()).thenReturn("");
+		Mockito.when(presenteurAutoCompletionTaxonsObservation.getValeur()).thenReturn("Acer monsp.");
+		Mockito.when(vueRechercheObservation.getDepartement()).thenReturn("34");
+		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
+		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("Fruit, fleur, feuille");
+		Mockito.when(vueRechercheObservation.getDate()).thenReturn("10/02/2004");
+		Mockito.when(presenteurAutoCompletionCommunesObservation.getValeur()).thenReturn("Montpellier");
+		Mockito.when(vueRechercheObservation.getFamille()).thenReturn("Asteracae");
+		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("fleur, tige, épine");
+		Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.SIMPLE);
+		presenteurRechercheObservation.collecterInfosRecherche();
+		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
+		assertTrue(rechercheObservationEffectuee);
+		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getTaxon());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getDepartement());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getDate());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getCommune());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
+	}
+	@Test
+	public void testObsRechercheAvanceeUtiliseChampContientMots() {
+		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Simple");
+		Mockito.when(vueRechercheObservation.getContientMots()).thenReturn("Avancee");
+		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
+		presenteurRechercheObservation.go(container);
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
+		presenteurRechercheObservation.collecterInfosRecherche();
+		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
+		assertTrue(rechercheObservationEffectuee);
+		assertEquals("Avancee", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
+		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
+	}
+	@Test
 	public void testLancerRechercheLibreObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getValeurRechercheSimple()).thenReturn("Essai");
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheObservation().getRechercheLibre());
+	}
 	@Test
 	public void testLancerRechercheDepartementObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getDepartement()).thenReturn("34");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("34", CacheClient.getInstance().getInformationsRechercheObservation().getDepartement());
+	}
 	@Test
 	public void testLancerRechercheTaxonObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(presenteurAutoCompletionTaxonsObservation.getValeur()).thenReturn("Acer monsp.");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheObservation().getTaxon());
+	}
 	@Test
 	public void testLancerRechercheGenreObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getGenre()).thenReturn("Acer");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheObservation().getGenre());
+	}
 	@Test
 	public void testLancerRechercheMotCleObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("Fruit, fleur, feuille");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
+	}
 	@Test
 	public void testLancerRechercheDateObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getDate()).thenReturn("10/02/2004");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheObservation().getDate());
+	}
 	@Test
 	public void testLancerRechercheCommuneObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(presenteurAutoCompletionCommunesObservation.getValeur()).thenReturn("Montpellier");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheObservation().getCommune());
+	}
 	@Test
 	public void testLancerRechercheFamilleObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getFamille()).thenReturn("Asteracae");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
+	}
 	@Test
 	public void testLancerRechercheTagObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getMotCle()).thenReturn("fleur, tige, épine");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheObservation().getMotClef());
+	}
 	@Test
 	public void testLancerRechercheAuteurObs() {
 		presenteurRechercheObservation.go(container);
 		Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
+		presenteurRechercheObservation.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheObservation.collecterInfosRecherche();
 		presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheObservationEffectuee);
 		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
+	}
+	//+------------------------------------------------------------------------------------------------------+
+	// IMAGES
+	@Test
+	public void testTypeMoteurParDefautEstSimpleImage() {
+		assertEquals(TypeMoteur.SIMPLE, presenteurRechercheImage.getTypeMoteur());
+	}
 	@Test
 	public void testLancerRechercheLibreImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Essai");
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
+	}
 	@Test
+	public void testImageLancerRechercheSimpleNeRetournePasLesChampsAvancee() {
+		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Essai");
+		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Acer monsp.");
+		Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
+		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
+		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("Fruit, fleur, feuille");
+		Mockito.when(vueRechercheImage.getDate()).thenReturn("10/02/2004");
+		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Montpellier");
+		Mockito.when(vueRechercheImage.getFamille()).thenReturn("Asteracae");
+		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("fleur, tige, épine");
+		Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
+		presenteurRechercheImage.go(container);
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.SIMPLE);
+		presenteurRechercheImage.collecterInfosRecherche();
+		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
+		assertTrue(rechercheImageEffectuee);
+		assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getTaxon());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getDepartement());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getGenre());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getDate());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getCommune());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getFamille());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
+		assertEquals(null, CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
+	}
+	@Test
+	public void testImageRechercheAvanceeUtiliseChampContientMots() {
+		Mockito.when(vueRechercheImage.getValeurRechercheSimple()).thenReturn("Simple");
+		Mockito.when(vueRechercheImage.getContientMots()).thenReturn("Avancee");
+		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
+		presenteurRechercheImage.go(container);
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
+		presenteurRechercheImage.collecterInfosRecherche();
+		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
+		assertTrue(rechercheImageEffectuee);
+		assertEquals("Avancee", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
+		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheImage().getGenre());
+	}
+	@Test
 	public void testLancerRechercheDepartementImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("34", CacheClient.getInstance().getInformationsRechercheImage().getDepartement());
+	}
 	@Test
 	public void testLancerRechercheTaxonImage() {
 		presenteurRechercheImage.go(container);
-		Mockito.when(presenteurAutoCompletionImage.getValeur()).thenReturn("Acer monsp.");
+		Mockito.when(presenteurAutoCompletionTaxonsImage.getValeur()).thenReturn("Acer monsp.");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Acer monsp.", CacheClient.getInstance().getInformationsRechercheImage().getTaxon());
+	}
 	@Test
 	public void testLancerRechercheGenreImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getGenre()).thenReturn("Acer");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Acer", CacheClient.getInstance().getInformationsRechercheImage().getGenre());
+	}
 	@Test
 	public void testLancerRechercheMotCleImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("Fruit, fleur, feuille");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Fruit, fleur, feuille", CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
+	}
 	@Test
 	public void testLancerRechercheDateImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getDate()).thenReturn("10/02/2004");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("10/02/2004", CacheClient.getInstance().getInformationsRechercheImage().getDate());
+	}
 	@Test
 	public void testLancerRechercheCommuneImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(presenteurAutoCompletionCommunesImage.getValeur()).thenReturn("Montpellier");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Montpellier", CacheClient.getInstance().getInformationsRechercheImage().getCommune());
+	}
 	@Test
 	public void testLancerRechercheFamilleImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getFamille()).thenReturn("Asteracae");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheImage().getFamille());
+	}
 	@Test
 	public void testLancerRechercheTagImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getMotCle()).thenReturn("fleur, tige, épine");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheImage().getMotClef());
+	}
 	@Test
 	public void testLancerRechercheAuteurImage() {
 		presenteurRechercheImage.go(container);
 		Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
+		presenteurRechercheImage.setTypeMoteur(TypeMoteur.AVANCEE);
 		presenteurRechercheImage.collecterInfosRecherche();
 		presenteurRechercheImage.afficherRequeteEtLancerRecherche();
 		assertTrue(rechercheImageEffectuee);
 		assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
+	}
+}

Subversion Repositories eFlore/Applications.del

(root)/trunk/src/org/tela_botanica/del/test/composants/moteurrecherche/MoteurRecherchePresenteurTest.java @ 621 – Rev 580 → 585