Subversion Repositories eFlore/Applications.del

Rev

Rev 580 | 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.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());
        }
}