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.autocompletion.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 presenteurAutoCompletionTaxonsImage;
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;
	
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;
	
	AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;
	AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;
	
	Config config;
	
	boolean rechercheObservationEffectuee = false;
	boolean rechercheImageEffectuee = false;
	private static String NOM_SCI_COMPLETION_SERVICE = "URL_FACTICE";
	
	@Before
	public void setUp() {
		vueRechercheObservation = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
		vueAutoCompletionTaxonsObservation = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class, Mockito.RETURNS_MOCKS);
		container = Mockito.mock(HasWidgets.class, Mockito.RETURNS_MOCKS);
		
		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);
		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) {
					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) {
			
			public void lancerRecherche() {
				chercher();
			}
		};
		
		vueRechercheImage = Mockito.mock(MoteurRecherchePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
		vueAutoCompletionImage = Mockito.mock(AutoCompletionComboBoxPresenteur.Vue.class ,Mockito.RETURNS_MOCKS);
		
		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, 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, 
				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(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 @ 533 – Rev 585 → 602

Rev 585		Rev 602
1	`package org.tela_botanica.del.test.composants.moteurrecherche;`	1	`package org.tela_botanica.del.test.composants.moteurrecherche;`
2		2
3	`import static org.junit.Assert.*;`	3	`import static org.junit.Assert.*;`
4	`import org.junit.Before;`	4	`import org.junit.Before;`
5	`import org.junit.Test;`	5	`import org.junit.Test;`
6	`import org.mockito.Mockito;`	6	`import org.mockito.Mockito;`
7	`import org.tela_botanica.del.client.cache.CacheClient;`	7	`import org.tela_botanica.del.client.cache.CacheClient;`
8	`import org.tela_botanica.del.client.composants.formulaires.AutoCompletionComboBoxPresenteur;`	8	`import org.tela_botanica.del.client.composants.formulaires.autocompletion.AutoCompletionComboBoxPresenteur;`
9	`import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;`	9	`import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur;`
10	`import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur.TypeMoteur;`	10	`import org.tela_botanica.del.client.composants.moteurrecherche.MoteurRecherchePresenteur.TypeMoteur;`
11	`import org.tela_botanica.del.client.config.Config;`	11	`import org.tela_botanica.del.client.config.Config;`
12	`import org.tela_botanica.del.client.modeles.ModeRecherche;`	12	`import org.tela_botanica.del.client.modeles.ModeRecherche;`
13	`import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;`	13	`import org.tela_botanica.del.client.utils.UtilitairesAutoCompletionService;`
14		14
15		15
16	`import com.google.gwt.http.client.Response;`	16	`import com.google.gwt.http.client.Response;`
17	`import com.google.gwt.user.client.ui.HasWidgets;`	17	`import com.google.gwt.user.client.ui.HasWidgets;`
18		18
19	`public class MoteurRecherchePresenteurTest {`	19	`public class MoteurRecherchePresenteurTest {`
20		20
21	`MoteurRecherchePresenteur presenteurRechercheObservation;`	21	`MoteurRecherchePresenteur presenteurRechercheObservation;`
22	`MoteurRecherchePresenteur.Vue vueRechercheObservation;`	22	`MoteurRecherchePresenteur.Vue vueRechercheObservation;`
23	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsObservation;`	23	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsObservation;`
24	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionTaxonsObservation;`	24	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionTaxonsObservation;`
25	`HasWidgets container;`	25	`HasWidgets container;`
26		26
27	`MoteurRecherchePresenteur presenteurRechercheImage;`	27	`MoteurRecherchePresenteur presenteurRechercheImage;`
28	`MoteurRecherchePresenteur.Vue vueRechercheImage;`	28	`MoteurRecherchePresenteur.Vue vueRechercheImage;`
29	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsImage;`	29	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionTaxonsImage;`
30	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;`	30	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionImage;`
31		31
32	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;`	32	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;`
33	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;`	33	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;`
34		34
35	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;`	35	`AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;`
36	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;`	36	`AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;`
37		37
38	`Config config;`	38	`Config config;`
39		39
40	`boolean rechercheObservationEffectuee = false;`	40	`boolean rechercheObservationEffectuee = false;`