Subversion Repositories eFlore/Applications.del

Rev

Rev 470 | Rev 553 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | RSS feed 

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.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.Vue vueAutoCompletionImage;
        
        AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesImage;
        AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesImage;
        
        AutoCompletionComboBoxPresenteur presenteurAutoCompletionCommunesObservation;
        AutoCompletionComboBoxPresenteur.Vue vueAutoCompletionCommunesObservation;
        
        boolean rechercheObservationEffectuee = false;
        boolean rechercheImageEffectuee = false;
        
        @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, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
                        
                        @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, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
                        
                        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);
                        }
                };
                
                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, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
                        
                        @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, UtilitairesAutoCompletionService.urlServiceCompletionNomLocale) {
                        
                        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(presenteurAutoCompletionImage, presenteurAutoCompletionCommunesImage, vueRechercheImage, ModeRecherche.MODE_IMAGE) {
                        public void lancerRecherche() {
                                chercher();
                        }
                };
        }
        
        
        private void chercher() {
                rechercheObservationEffectuee = true;
                rechercheImageEffectuee = true;
        }
        
        @Test
        public void testModeRecherche() {
                assertEquals(ModeRecherche.MODE_IMAGE, presenteurRechercheImage.getMode());
                assertEquals(ModeRecherche.MODE_OBSERVATION, presenteurRechercheObservation.getMode());
        }
        
        @Test
        public void testLancerRechercheLibreObs() {     
                presenteurRechercheObservation.go(container);
                Mockito.when(vueRechercheObservation.getRecherchePrincipale()).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.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.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.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.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.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.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.collecterInfosRecherche();
                presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheObservationEffectuee);
                assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheObservation().getFamille());
        }
        
        @Test
        public void testLancerRechercheTagObs() {       
                presenteurRechercheObservation.go(container);
                Mockito.when(vueRechercheObservation.getTag()).thenReturn("fleur, tige, épine");
                presenteurRechercheObservation.collecterInfosRecherche();
                presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheObservationEffectuee);
                assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheObservation().getTag());
        }
        
        @Test
        public void testLancerRechercheAuteurObs() {    
                presenteurRechercheObservation.go(container);
                Mockito.when(vueRechercheObservation.getAuteur()).thenReturn("Hubert de Linné");
                presenteurRechercheObservation.collecterInfosRecherche();
                presenteurRechercheObservation.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheObservationEffectuee);
                assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheObservation().getAuteur());
        }
        
        @Test
        public void testLancerRechercheLibreImage() {   
                presenteurRechercheImage.go(container);
                Mockito.when(vueRechercheImage.getRecherchePrincipale()).thenReturn("Essai");
                presenteurRechercheImage.collecterInfosRecherche();
                presenteurRechercheImage.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheImageEffectuee);
                assertEquals("Essai", CacheClient.getInstance().getInformationsRechercheImage().getRechercheLibre());
        }
        
        @Test
        public void testLancerRechercheDepartementImage() {     
                presenteurRechercheImage.go(container);
                Mockito.when(vueRechercheImage.getDepartement()).thenReturn("34");
                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.");
                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.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.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.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.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.collecterInfosRecherche();
                presenteurRechercheImage.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheImageEffectuee);
                assertEquals("Asteracae", CacheClient.getInstance().getInformationsRechercheImage().getFamille());
        }
        
        @Test
        public void testLancerRechercheTagImage() {     
                presenteurRechercheImage.go(container);
                Mockito.when(vueRechercheImage.getTag()).thenReturn("fleur, tige, épine");
                presenteurRechercheImage.collecterInfosRecherche();
                presenteurRechercheImage.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheImageEffectuee);
                assertEquals("fleur, tige, épine", CacheClient.getInstance().getInformationsRechercheImage().getTag());
        }
        
        @Test
        public void testLancerRechercheAuteurImage() {  
                presenteurRechercheImage.go(container);
                Mockito.when(vueRechercheImage.getAuteur()).thenReturn("Hubert de Linné");
                presenteurRechercheImage.collecterInfosRecherche();
                presenteurRechercheImage.afficherRequeteEtLancerRecherche();
                
                assertTrue(rechercheImageEffectuee);
                assertEquals("Hubert de Linné", CacheClient.getInstance().getInformationsRechercheImage().getAuteur());
        }
}