Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 1534 → Rev 1535

/tags/v1.1-helium/src/org/tela_botanica/del/test/composants/moteurrecherche/MoteurRecherchePresenteurTest.java
New file
0,0 → 1,494
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());
}
}