Subversion Repositories eFlore/Applications.del

Compare Revisions

Ignore whitespace Rev 1830 → Rev 2094

/tags/v1.10-sodium/src/org/tela_botanica/del/test/composants/motsclesimage/MotsClesImageTest.java
New file
0,0 → 1,81
package org.tela_botanica.del.test.composants.motsclesimage;
 
import static org.junit.Assert.*;
 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
 
import org.junit.Before;
import org.junit.Test;
import org.tela_botanica.del.client.modeles.MotCle;
import org.tela_botanica.del.client.utils.StringUtils;
 
public class MotsClesImageTest {
List<MotCle> motsCles;
List<String> motClesCelAFiltrer;
 
@Before
public void setUp() {
String chaineMotsClesCelAFiltrer = "fleur,feuille,ecorce,fruit,port,defiphoto";
this.motClesCelAFiltrer = new ArrayList<String>();
String[] tabMotsClesCelAFiltrer = chaineMotsClesCelAFiltrer.split(",");
for (int i = 0; i < tabMotsClesCelAFiltrer.length; i++) {
this.motClesCelAFiltrer.add(StringUtils.normaliser(tabMotsClesCelAFiltrer[i]));
}
motsCles = new ArrayList<MotCle>();
}
 
@Test
public void testFiltreMotClesCelAvecAccents() {
MotCle mc1 = new MotCle("1", "1", "écorce");
MotCle mc2 = new MotCle("2", "1", "pôrt");
MotCle mc3 = new MotCle("3", "1", "ucorce");
MotCle mc4 = new MotCle("4", "1", "Défi Photo");
MotCle mc5 = new MotCle("5", "1", "FeuIlle");
MotCle mc6 = new MotCle("6", "1", "fruIT");
motsCles.add(mc1);
motsCles.add(mc2);
motsCles.add(mc3);
motsCles.add(mc4);
motsCles.add(mc5);
motsCles.add(mc6);
List<String> resultat = afficherMotsClesCel(motsCles, motClesCelAFiltrer);
assertEquals(5, resultat.size());
}
@Test
public void testNormalisation() {
String avecEspaces = "mot cle espaces";
String sansEspaces = "motcleespaces";
 
assertEquals(StringUtils.normaliser(avecEspaces), StringUtils.normaliser(sansEspaces));
String avecAccents = "motcléaccentué";
String sansAccents = "motcleaccentue";
 
assertEquals(StringUtils.normaliser(avecAccents), StringUtils.normaliser(sansAccents));
String avecEspacesAccents = "mot clé èspâces";
String sansEspacesAccents = "motcleespaces";
 
assertEquals(StringUtils.normaliser(avecEspacesAccents), StringUtils.normaliser(sansEspacesAccents));
}
private List<String> afficherMotsClesCel(List<MotCle> motsClesCelImages, List<String> motsClesCelAFiltrer) {
List<String> motsClesCel = new ArrayList<String>();
for (Iterator<MotCle> iterator = motsClesCelImages.iterator(); iterator.hasNext();) {
String mot = iterator.next().getMotCle();
if(!mot.trim().isEmpty() && motsClesCelAFiltrer.contains(StringUtils.normaliser(mot))) {
motsClesCel.add(mot);
}
}
return motsClesCel;
}
}
/tags/v1.10-sodium/src/org/tela_botanica/del/test/composants/votes/MoyenneVotePresenteurTest.java
New file
0,0 → 1,104
package org.tela_botanica.del.test.composants.votes;
 
import static org.junit.Assert.assertEquals;
 
import java.util.ArrayList;
import java.util.List;
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.votes.moyennevotes.MoyenneVotePresenteur;
import org.tela_botanica.del.client.modeles.Image;
import org.tela_botanica.del.client.modeles.Protocole;
import org.tela_botanica.del.client.services.rest.VoteProtocoleService;
 
import com.google.gwt.user.client.ui.HasWidgets;
 
public class MoyenneVotePresenteurTest {
 
MoyenneVotePresenteur mvp;
HasWidgets container;
List<Protocole> tousLesProtocoles = new ArrayList<Protocole>();
MoyenneVotePresenteur.Vue vue;
Image imageCourante;
@Before
public void setUp() {
CacheClient.getInstance().getUtilisateur().setId(0+"");
Protocole protocol1 = new Protocole();
protocol1.setNom("esthétique");
protocol1.setId(0);
 
Protocole protocol2 = new Protocole();
protocol2.setNom("capitalisation de scan de feuilles");
protocol2.setId(1);
 
tousLesProtocoles.add(protocol1);
tousLesProtocoles.add(protocol2);
imageCourante = new Image();
Protocole protocole = tousLesProtocoles.get(0);
vue = Mockito.mock(MoyenneVotePresenteur.Vue.class,Mockito.RETURNS_DEEP_STUBS);
VoteProtocoleService voteProtocoleService=Mockito.mock(VoteProtocoleService.class);
mvp = new MoyenneVotePresenteur(imageCourante, protocole, vue, voteProtocoleService);
container = Mockito.mock(HasWidgets.class, Mockito.RETURNS_DEEP_STUBS);
mvp.go(container);
}
@Test
public void testerVoteMemeUtilisateur() {
// Un même utilisateur vote deux fois sur la même image, même protocole, en faisant des votes différents
assertEquals(1, imageCourante.getListeVotesProtocoles().size());
mvp.setValeurVoteUtilisateur(3);
mvp.enregistrerVote();
// la valeur du vote change mais le nombre de vote ne change pas, son vote est remplacé
mvp.setValeurVoteUtilisateur(1);
mvp.enregistrerVote();
assertEquals(1, imageCourante.getVotesProtocoles(0).size());
assertEquals(1, mvp.getValeurVoteTotal());
}
@Test
public void testerTroisVotesUtilisateursDifferents() {
// Trois utilisateur différents votent pour la même image et le même protocole
CacheClient.getInstance().getUtilisateur().setId(0+"");
assertEquals(1, imageCourante.getListeVotesProtocoles().size());
mvp.setValeurVoteUtilisateur(3);
mvp.enregistrerVote();
CacheClient.getInstance().getUtilisateur().setId(1+"");
mvp.setValeurVoteUtilisateur(1);
mvp.enregistrerVote();
assertEquals(2, imageCourante.getVotesProtocoles(0).size());
assertEquals(2, mvp.getValeurVoteTotal());
CacheClient.getInstance().getUtilisateur().setId(2+"");
mvp.setValeurVoteUtilisateur(5);
mvp.enregistrerVote();
assertEquals(3, imageCourante.getVotesProtocoles(0).size());
assertEquals(3, mvp.getValeurVoteTotal());
// Le premier utilisateur change d'avis et modifie son vote
CacheClient.getInstance().getUtilisateur().setId(0+"");
assertEquals(1, imageCourante.getListeVotesProtocoles().size());
mvp.setValeurVoteUtilisateur(5);
mvp.enregistrerVote();
// La moyenne des vote change mais le nombre de vote ne doit pas changer
assertEquals(3, imageCourante.getVotesProtocoles(0).size());
assertEquals(4, mvp.getValeurVoteTotal());
}
@Test
public void testerDeuxVotesMemeUtilisateursProtocolesDifferents() {
// Trois utilisateur différents votent pour la même image et le même protocole
CacheClient.getInstance().getUtilisateur().setId(0+"");
assertEquals(1, imageCourante.getListeVotesProtocoles().size());
mvp.setValeurVoteUtilisateur(3);
mvp.enregistrerVote();
}
}
/tags/v1.10-sodium/src/org/tela_botanica/del/test/composants/votes/BarreRepartitionVotePresenteurTest.java
New file
0,0 → 1,59
package org.tela_botanica.del.test.composants.votes;
 
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.mock;
 
import java.util.Date;
 
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.tela_botanica.del.client.composants.votes.barrerepartition.BarreRepartitionVotePresenteur;
import org.tela_botanica.del.client.composants.votes.barrerepartition.BarreRepartitionVotePresenteur.Vue;
import org.tela_botanica.del.client.modeles.Contributeur;
import org.tela_botanica.del.client.modeles.MoyenneVote;
import org.tela_botanica.del.client.modeles.Observation;
import org.tela_botanica.del.client.modeles.PropositionDetermination;
import org.tela_botanica.del.client.modeles.VoteDetermination;
import org.tela_botanica.del.client.services.CalculVoteDeterminationService;
import org.tela_botanica.del.client.services.rest.VoteDeterminationService;
 
public class BarreRepartitionVotePresenteurTest {
 
private BarreRepartitionVotePresenteur barreRepartitionVotePresenteur;
private BarreRepartitionVotePresenteur.Vue vue;
 
@Before
public void setUp() {
 
vue = mock(Vue.class, Mockito.RETURNS_DEEP_STUBS);
VoteDeterminationService voteDeterminationService = Mockito.mock(VoteDeterminationService.class);
barreRepartitionVotePresenteur = new BarreRepartitionVotePresenteur(vue, voteDeterminationService);
 
VoteDetermination voteDetermination = new VoteDetermination();
voteDetermination.setVote(1);
voteDetermination.setDate(new Date());
voteDetermination.setContributeur("benjamin");
 
Observation obs = new Observation();
PropositionDetermination propositionDetermination = new PropositionDetermination(obs);
propositionDetermination.setEspece("Iris lutescens subsp. lutescens");
propositionDetermination.setContributeur(new Contributeur("1", "contrib", "test", "contrib@test.com"));
propositionDetermination.setId("1");
propositionDetermination.ajouterVoteDetermination(voteDetermination);
propositionDetermination.setObservation(obs);
obs.ajouterPropositionDetermination(propositionDetermination);
 
MoyenneVote moyenneVote = CalculVoteDeterminationService.calculerVoteDetermination(propositionDetermination);
barreRepartitionVotePresenteur.afficherVotes(moyenneVote);
}
 
@Test
public void testVoter() {
assertEquals("Iris lutescens subsp. lutescens", barreRepartitionVotePresenteur.getMoyenneVote().getIntituleAssocie());
assertEquals(100, barreRepartitionVotePresenteur.getMoyenneVote().getScore());
barreRepartitionVotePresenteur.voter(false);
assertEquals(100, barreRepartitionVotePresenteur.getMoyenneVote().getScore());
}
 
}
/tags/v1.10-sodium/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());
}
}
/tags/v1.10-sodium/src/org/tela_botanica/del/test/composants/formulaires/FormulaireCommentaireTest.java
New file
0,0 → 1,69
package org.tela_botanica.del.test.composants.formulaires;
 
import static org.junit.Assert.*;
 
import java.util.Date;
 
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.tela_botanica.del.client.composants.formulaires.formulairecommentaire.FormulaireCommentairePresenteur;
import org.tela_botanica.del.client.composants.formulaires.formulairecommentaire.FormulaireCommentairePresenteur.Vue;
import org.tela_botanica.del.client.modeles.Commentaire;
import org.tela_botanica.del.client.modeles.Contributeur;
import org.tela_botanica.del.client.modeles.Observation;
import org.tela_botanica.del.client.services.rest.CommentaireService;
 
public class FormulaireCommentaireTest {
 
FormulaireCommentairePresenteur presenteurFormulaireCommentairePourObservation;
FormulaireCommentairePresenteur presenteurFormulaireCommentairePourPossesseurCommentaire;
 
Commentaire comm;
 
Observation obs;
 
@Before
public void setUp() {
 
obs = new Observation();
comm = new Commentaire(new Contributeur("1", "Peronnet", "Aurélien", "aurelien@tela-botanica.org"), new Date(), "Ceci est une chaine de charactères");
obs.getInterventionsForum().add(comm);
 
Vue vue1 = Mockito.mock(FormulaireCommentairePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
Mockito.when(vue1.getCommentaire().getText()).thenReturn("Ceci est un commentaire");
Mockito.when(vue1.getPrenom()).thenReturn("Georges");
Mockito.when(vue1.getNom()).thenReturn("Abitbol");
 
CommentaireService commentaireService = Mockito.mock(CommentaireService.class);
presenteurFormulaireCommentairePourObservation = new FormulaireCommentairePresenteur(obs, commentaireService, vue1);
 
Vue vue2 = Mockito.mock(FormulaireCommentairePresenteur.Vue.class, Mockito.RETURNS_MOCKS);
Mockito.when(vue2.getCommentaire().getText()).thenReturn("Ceci est un commentaire");
Mockito.when(vue2.getPrenom()).thenReturn("Georges");
Mockito.when(vue2.getNom()).thenReturn("Abitbol");
 
presenteurFormulaireCommentairePourPossesseurCommentaire = new FormulaireCommentairePresenteur(comm, commentaireService, vue2);
}
 
@Test
public void testAjoutCommentaireSurObservation() {
assertEquals(1, obs.getInterventionsForum().size());
 
presenteurFormulaireCommentairePourObservation.surValidationCommentaire();
assertEquals(1, obs.getInterventionsForum().size());
}
 
@Test
public void testAjoutCommentaireSurPossesseurCOmmentaire() {
// Les deux ligne suivantes désignent normalement le même objet, qui ne
// possède pas de commentaire
// au début
assertEquals(comm.getListeCommentaires().size(), 0);
assertEquals(obs.getInterventionsForum().get(0).getListeCommentaires().size(), 0);
 
presenteurFormulaireCommentairePourPossesseurCommentaire.surValidationCommentaire();
assertEquals(obs.getInterventionsForum().size(), 1);
assertEquals(obs.getInterventionsForum().get(0).getListeCommentaires().size(), 1);
}
}
/tags/v1.10-sodium/src/org/tela_botanica/del/test/composants/identification/FormulaireIdentificationPresenteurTest.java
New file
0,0 → 1,66
package org.tela_botanica.del.test.composants.identification;
 
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.identification.FormulaireIdentificationPresenteur;
import org.tela_botanica.del.client.modeles.Utilisateur;
import org.tela_botanica.del.client.services.rest.UtilisateurService;
import org.tela_botanica.del.client.services.rest.async.UtilisateurCallback;
 
public class FormulaireIdentificationPresenteurTest {
FormulaireIdentificationPresenteur.Vue vue;
FormulaireIdentificationPresenteur presenteur;
Utilisateur utilisateurDepart;
@Before
public void setUp() throws Exception {
utilisateurDepart = new Utilisateur("0", "gregoire@tela-botanica.org");
utilisateurDepart.setIdentifie(true);
utilisateurDepart.setCourriel("gregoire@tela-botanica.org");
utilisateurDepart.setNom("Duché");
utilisateurDepart.setPrenom("Grégoire");
vue = Mockito.mock(FormulaireIdentificationPresenteur.Vue.class, Mockito.RETURNS_MOCKS);
presenteur = new FormulaireIdentificationPresenteur(vue, new UtilisateurService() {
@Override
public void obtenirUtilisateur(UtilisateurCallback callback) {
}
@Override
public void connecterUtilisateur(String login, String motDePasse, UtilisateurCallback callback) {
Utilisateur utilisateur = new Utilisateur("0", login);
utilisateur.setCourriel(login);
utilisateur.setIdentifie(true);
CacheClient.getInstance().setUtilisateur(utilisateur);
}
 
@Override
public void deconnecterUtilisateur(UtilisateurCallback callback) {
// TODO Auto-generated method stub
}
});
}
 
@Test
public void loginOk() {
presenteur.connecterUtilisateur(utilisateurDepart.getId(), "test");
Utilisateur utilisateurCache = CacheClient.getInstance().getUtilisateur();
assertEquals(utilisateurDepart.getCourriel(), utilisateurCache.getCourriel());
assertEquals(true, utilisateurCache.estIdentifie());
}
@Test
public void deconnecter() {
presenteur.deconnecterUtilisateur();
Utilisateur utilisateurCache = CacheClient.getInstance().getUtilisateur();
assertEquals(null, utilisateurCache.getId());
assertEquals(false, utilisateurCache.estIdentifie());
}
}
/tags/v1.10-sodium/src/org/tela_botanica/del/test/composants/pagination/PaginationPresenteurTest.java
New file
0,0 → 1,137
package org.tela_botanica.del.test.composants.pagination;
 
import static org.junit.Assert.assertEquals;
import static org.mockito.Mockito.when;
 
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mockito;
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur;
 
import com.google.gwt.event.dom.client.HasChangeHandlers;
import com.google.gwt.event.dom.client.HasClickHandlers;
import com.google.gwt.user.client.ui.HasWidgets;
 
public class PaginationPresenteurTest {
 
/**
* Presenteur utilisé pour le test de synchro pagination
*/
PaginationPresenteur paginationHautPresenteur;
/**
* Presenteur utilisé pour le test de synchro pagination
*/
PaginationPresenteur paginationBasPresenteur;
 
/**
* Presenteur utilisé seul qui ne doit pas réagir au évènements lancés par
* les deux autres
*/
PaginationPresenteur paginationPresenteurSeul;
 
@Before
public void setUp() {
PaginationPresenteur.Vue vueBas = creerMockVuePaginationPresenteurBasique();
this.paginationBasPresenteur = new PaginationPresenteur(vueBas, 100, 10, 1) {
 
@Override
public void chargerElements(int debut, int fin) {
// TODO Auto-generated method stub
 
}
 
@Override
public void actualiserPasCache(int pas) {
// TODO Auto-generated method stub
 
}
};
 
PaginationPresenteur.Vue vueHaut = creerMockVuePaginationPresenteurBasique();
this.paginationHautPresenteur = new PaginationPresenteur(vueHaut, 100, 10, 1) {
 
@Override
public void actualiserPasCache(int pas) {
}
 
@Override
public void chargerElements(int debut, int fin) {
// TODO Auto-generated method stub
 
}
};
 
PaginationPresenteur.Vue vueSeule = creerMockVuePaginationPresenteurBasique();
this.paginationPresenteurSeul = new PaginationPresenteur(vueSeule, 100, 10, 1) {
 
@Override
public void actualiserPasCache(int pas) {
}
 
@Override
public void chargerElements(int debut, int fin) {
// TODO Auto-generated method stub
 
}
};
 
HasWidgets containerMock = Mockito.mock(HasWidgets.class);
 
paginationHautPresenteur.setGroupePagination("pagination_synchro");
paginationBasPresenteur.setGroupePagination("pagination_synchro");
 
paginationHautPresenteur.go(containerMock);
paginationBasPresenteur.go(containerMock);
 
paginationPresenteurSeul.go(containerMock);
}
 
@Test
public void testSynchronisationChangementPageCourante() {
 
assertEquals(1, paginationHautPresenteur.getPageCourante());
assertEquals(1, paginationBasPresenteur.getPageCourante());
 
paginationBasPresenteur.allerALapageSuivante();
assertEquals(2, paginationHautPresenteur.getPageCourante());
}
 
@Test
public void testSynchronisationChangementPas() {
paginationBasPresenteur.changerPas(20);
assertEquals(1, paginationBasPresenteur.getPageCourante());
assertEquals(20, paginationHautPresenteur.getPas());
}
 
@Test
public void testGroupePaginationDifferents() {
paginationPresenteurSeul.allerALapageSuivante();
assertEquals(2, paginationPresenteurSeul.getPageCourante());
 
paginationBasPresenteur.allerAlaDernierePage();
assertEquals(10, paginationHautPresenteur.getPageCourante());
assertEquals(10, paginationBasPresenteur.getPageCourante());
 
assertEquals(2, paginationPresenteurSeul.getPageCourante());
}
 
private PaginationPresenteur.Vue creerMockVuePaginationPresenteurBasique() {
 
PaginationPresenteur.Vue vueMock = Mockito.mock(PaginationPresenteur.Vue.class);
HasChangeHandlers saisiePageCourante = Mockito.mock(HasChangeHandlers.class);
HasChangeHandlers selecteurPas = Mockito.mock(HasChangeHandlers.class);
HasClickHandlers boutonPrecedent = Mockito.mock(HasClickHandlers.class);
HasClickHandlers boutonSuivant = Mockito.mock(HasClickHandlers.class);
HasClickHandlers boutonPremierePage = Mockito.mock(HasClickHandlers.class);
HasClickHandlers boutonDernierePage = Mockito.mock(HasClickHandlers.class);
 
when(vueMock.getSaisiePageCourante()).thenReturn(saisiePageCourante);
when(vueMock.getSelecteurPas()).thenReturn(selecteurPas);
when(vueMock.getBoutonPrecedent()).thenReturn(boutonPrecedent);
when(vueMock.getBoutonSuivant()).thenReturn(boutonSuivant);
when(vueMock.getBoutonPremierePage()).thenReturn(boutonPremierePage);
when(vueMock.getBoutonDernierePage()).thenReturn(boutonDernierePage);
 
return vueMock;
}
}