/branches/v1.5-carbone/src/org/tela_botanica/del/test/services/CalculVoteDeterminationServiceTest.java |
---|
New file |
0,0 → 1,108 |
package org.tela_botanica.del.test.services; |
import static org.junit.Assert.assertTrue; |
import java.util.ArrayList; |
import java.util.Date; |
import java.util.Iterator; |
import java.util.List; |
import org.junit.Test; |
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; |
public class CalculVoteDeterminationServiceTest { |
@Test |
public void testCalculerVoteDetermination() { |
Observation obs = new Observation(); |
VoteDetermination voteDetermination = new VoteDetermination(); |
voteDetermination.setVote(1); |
voteDetermination.setDate(new Date()); |
voteDetermination.setContributeur("benjamin"); |
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); |
obs.ajouterPropositionDetermination(propositionDetermination); |
MoyenneVote moyenneVote = CalculVoteDeterminationService |
.calculerVoteDetermination(propositionDetermination); |
assertTrue(moyenneVote.getScore() == 100); |
} |
@Test |
public void testCalculerVoteDeterminationPlusPopulaire() { |
Observation obs = new Observation(); |
Contributeur cIdent1 = new Contributeur("1", "Peronnet", "Aurélien", "aurelien@tela-botanica.org"); |
Contributeur cIdent2 = new Contributeur("2", "Liens", "Benjamin", "benjamin@tela-botanica.org"); |
Contributeur cAnon1 = new Contributeur("a1a5f7b8s8c4v2b3g4g5t7t8t94", "", "", ""); |
VoteDetermination voteDetermination1 = new VoteDetermination(); |
voteDetermination1.setVote(1); |
voteDetermination1.setDate(new Date()); |
voteDetermination1.setContributeur(cIdent1.getId()); |
voteDetermination1.setAuteur(cIdent1); |
VoteDetermination voteDetermination2 = new VoteDetermination(); |
voteDetermination2.setVote(1); |
voteDetermination2.setDate(new Date()); |
voteDetermination2.setContributeur(cIdent2.getId()); |
voteDetermination2.setAuteur(cIdent2); |
VoteDetermination voteDetermination3 = new VoteDetermination(); |
voteDetermination3.setVote(0); |
voteDetermination3.setDate(new Date()); |
voteDetermination3.setContributeur(cAnon1.getId()); |
voteDetermination3.setAuteur(cAnon1); |
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(voteDetermination2); |
propositionDetermination.ajouterVoteDetermination(voteDetermination3); |
obs.ajouterPropositionDetermination(propositionDetermination); |
PropositionDetermination propositionDetermination2 = new PropositionDetermination(obs); |
propositionDetermination2.setEspece("Iris urticans"); |
propositionDetermination2.setContributeur(new Contributeur("1", "contrib", "test", "contrib@test.com")); |
propositionDetermination2.setId("2"); |
propositionDetermination2.ajouterVoteDetermination(voteDetermination1); |
propositionDetermination2.ajouterVoteDetermination(voteDetermination2); |
propositionDetermination2.ajouterVoteDetermination(voteDetermination3); |
obs.ajouterPropositionDetermination(propositionDetermination2); |
List<PropositionDetermination> listePropositions = new ArrayList<PropositionDetermination>(); |
listePropositions.add(propositionDetermination2); |
listePropositions.add(propositionDetermination); |
List<MoyenneVote> listeMoyenneVote = CalculVoteDeterminationService |
.calculerVoteDeterminationPlusPopulaire(listePropositions); |
for (Iterator iterator = listeMoyenneVote.iterator(); iterator |
.hasNext();) { |
MoyenneVote moyenneVote = (MoyenneVote) iterator.next(); |
System.out.println(moyenneVote.getScore()); |
} |
// le premier vote est sensé être celui qui possède le plus gros score |
assertTrue(listeMoyenneVote.get(0).getIntituleAssocie().equals("Iris urticans")); |
} |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/MockDatasource.java |
---|
New file |
0,0 → 1,438 |
package org.tela_botanica.del.test; |
import java.util.ArrayList; |
import java.util.Date; |
import java.util.HashMap; |
import java.util.Iterator; |
import java.util.LinkedHashMap; |
import java.util.List; |
import org.tela_botanica.del.client.modeles.Commentaire; |
import org.tela_botanica.del.client.modeles.Contributeur; |
import org.tela_botanica.del.client.modeles.Image; |
import org.tela_botanica.del.client.modeles.InformationsRecherche; |
import org.tela_botanica.del.client.modeles.InterventionForum; |
import org.tela_botanica.del.client.modeles.Observation; |
import org.tela_botanica.del.client.modeles.PropositionDetermination; |
import org.tela_botanica.del.client.modeles.Protocole; |
import org.tela_botanica.del.client.modeles.VoteDetermination; |
import org.tela_botanica.del.client.modeles.VoteProtocole; |
import org.tela_botanica.del.client.services.rest.ImageService; |
import org.tela_botanica.del.client.services.rest.ObservationService; |
import org.tela_botanica.del.client.services.rest.PropositionDeterminationService; |
import org.tela_botanica.del.client.services.rest.ProtocoleService; |
import org.tela_botanica.del.client.services.rest.VoteProtocoleService; |
import org.tela_botanica.del.client.services.rest.async.AjoutVoteProtocoleCallback; |
import org.tela_botanica.del.client.services.rest.async.DepublicationObservationCallBack; |
import org.tela_botanica.del.client.services.rest.async.ImagesParTaxonCallback; |
import org.tela_botanica.del.client.services.rest.async.ObservationsCallback; |
import org.tela_botanica.del.client.services.rest.async.PropositionDeterminationCallBack; |
import org.tela_botanica.del.client.services.rest.async.ProtocolesCallback; |
import org.tela_botanica.del.client.services.rest.async.SuppressionImageCallback; |
import org.tela_botanica.del.client.services.rest.async.SuppressionPropositionDeterminationCallback; |
import org.tela_botanica.del.client.services.rest.async.ValidationPropositionCallback; |
import org.tela_botanica.del.client.services.rest.async.VoteProtocoleCallback; |
public class MockDatasource implements ObservationService, ImageService, ProtocoleService, VoteProtocoleService, PropositionDeterminationService { |
static MockDatasource instance; |
List<Observation> observations = new ArrayList<Observation>(); |
List<InterventionForum> observationValidationDatas = new ArrayList<InterventionForum>(); |
List<String> propositionsTaxonDatas = new ArrayList<String>(); |
List<Protocole> protocoles = new ArrayList<Protocole>(); |
List<Image> images = new ArrayList<Image>(); |
private MockDatasource() { |
HashMap<String, String> auteurObs = new LinkedHashMap<String, String>(); |
auteurObs.put("01Juliette 1MOUREAU", "Tragopogon porrifolius subsp. australis (Jord.) Nyman"); |
auteurObs.put("02Robert 2LERAS", "Iris lutescens subsp. lutescens"); |
auteurObs.put("03Geneviève 3BOTTI", "Euphorbia dendroides L."); |
auteurObs.put("04Robert 4LERAS", "Lonicera japonica Thunb. ex Murray"); |
auteurObs.put("05Juliette 5MOUREAU", "Lavatera arborea L."); |
auteurObs.put("06Robert 6LERAS", "Lavatera arborea L."); |
auteurObs.put("07Juliette 7MOUREAU", "Serapias vomeracea (Burm.f.) Briq. "); |
auteurObs.put("08Benjamin 8LIENS", "Lonicera etrusca Santi"); |
auteurObs.put("09Aurélient 9PERONNET", "Ophrys scolopax Cav. "); |
auteurObs.put("10Grégoire 10DUCHÉ", "Staehelina dubia L. "); |
auteurObs.put("11Juliette 11MOUREAU", "Tragopogon porrifolius subsp. australis (Jord.) Nyman"); |
auteurObs.put("12Robert 12LERAS", "Iris lutescens subsp. lutescens"); |
auteurObs.put("13Geneviève 13BOTTI", "Euphorbia dendroides L."); |
auteurObs.put("14Robert 14LERAS", "Lonicera japonica Thunb. ex Murray"); |
auteurObs.put("15Juliette 15MOUREAU", "Lavatera arborea L."); |
auteurObs.put("16Robert 16LERAS", "Lavatera arborea L."); |
auteurObs.put("17Juliette 17MOUREAU", "Serapias vomeracea (Burm.f.) Briq. "); |
auteurObs.put("18Benjamin 18LIENS", "Lonicera etrusca Santi"); |
auteurObs.put("19Aurélient 19PERONNET", "Ophrys scolopax Cav. "); |
auteurObs.put("20Grégoire 20DUCHÉ", "Staehelina dubia L. "); |
auteurObs.put("21Juliette 1MOUREAU", "Tragopogon porrifolius subsp. australis (Jord.) Nyman"); |
auteurObs.put("22R2obert 2LERAS", "Iris lutescens subsp. lutescens"); |
auteurObs.put("23Ge3neviève 3BOTTI", "Euphorbia dendroides L."); |
auteurObs.put("24Rob4ert 4LERAS", "Lonicera japonica Thunb. ex Murray"); |
auteurObs.put("25Jul5iette 5MOUREAU", "Lavatera arborea L."); |
auteurObs.put("26Rob6ert 6LERAS", "Lavatera arborea L."); |
auteurObs.put("27J6ul7iette 7MOUREAU", "Serapias vomeracea (Burm.f.) Briq. "); |
auteurObs.put("28Ben8jamin 8LIENS", "Lonicera etrusca Santi"); |
auteurObs.put("29Auré9lient 9PERONNET", "Ophrys scolopax Cav. "); |
auteurObs.put("30Gég10oire 10DUCHÉ", "Staehelina dubia L. "); |
auteurObs.put("31Julie11tte 11MOUREAU", "Tragopogon porrifolius subsp. australis (Jord.) Nyman"); |
auteurObs.put("32Rober12t 12LERAS", "Iris lutescens subsp. lutescens"); |
auteurObs.put("33Genev13iève 13BOTTI", "Euphorbia dendroides L."); |
auteurObs.put("34Robe14rt 14LERAS", "Lonicera japonica Thunb. ex Murray"); |
auteurObs.put("35Julie15tte 15MOUREAU", "Lavatera arborea L."); |
auteurObs.put("36Robe16rt 16LERAS", "Lavatera arborea L."); |
auteurObs.put("37Julie17tte 17MOUREAU", "Serapias vomeracea (Burm.f.) Briq. "); |
auteurObs.put("38Benja1m11in 18LIENS", "Lonicera etrusca Santi"); |
auteurObs.put("39Auré1111lient 19PERONNET", "Ophrys scolopax Cav. "); |
auteurObs.put("40Gr545égoire 20DUCHÉ", "Staehelina dubia L. "); |
ArrayList<String> motsClefs = new ArrayList<String>(); |
motsClefs.add("plantnet"); |
motsClefs.add("fleur"); |
motsClefs.add("fruit"); |
Iterator<String> auteurs = auteurObs.keySet().iterator(); |
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); |
protocoles.add(protocol1); |
protocoles.add(protocol2); |
VoteDetermination voteDetermination = new VoteDetermination(); |
voteDetermination.setVote(1); |
voteDetermination.setDate(new Date()); |
voteDetermination.setContributeur("benjamin"); |
PropositionDetermination observationValidationData = new PropositionDetermination(new Observation()); |
observationValidationData.setEspece("Iris lutescens subsp. lutescens"); |
Contributeur contributeur = new Contributeur("1", "contributeur", "test", "contrib@test.com"); |
observationValidationData.setContributeur(contributeur); |
observationValidationData.setId("1"); |
observationValidationData.ajouterVoteDetermination(voteDetermination); |
observationValidationData.setDate(new Date()); |
observationValidationDatas.add(observationValidationData); |
PropositionDetermination observationValidationData2 = new PropositionDetermination(new Observation()); |
Contributeur contributeur2 = new Contributeur("2", "contributeur2", "test2", "contrib2@test.com"); |
observationValidationData2.setContributeur(contributeur2); |
observationValidationData2.setEspece("Lavatera arborea L."); |
observationValidationData2.setId("2"); |
observationValidationData2.ajouterVoteDetermination(voteDetermination); |
observationValidationData2.setDate(new Date()); |
observationValidationDatas.add(observationValidationData2); |
PropositionDetermination observationValidationData3 = new PropositionDetermination(new Observation()); |
observationValidationData3.setEspece("Acer monsp. L."); |
Contributeur contributeur3 = new Contributeur("2", "contributeur3", "test3", "contrib3test.com"); |
observationValidationData3.setContributeur(contributeur3); |
Commentaire commentaire = new Commentaire(new Contributeur("3", "Benjamin", "Liens", "benjamin@liens.com"), new Date(), "Avec le temps..."); |
Commentaire commentaireBis = new Commentaire(new Contributeur("4", "Greg", "Duche", "greg@duche.com"), new Date(), "Pas d'accord avec Greg!"); |
commentaire.getListeCommentaires().add(commentaireBis); |
observationValidationData3.ajouterCommentaire(commentaire); |
observationValidationData3.setId("3"); |
observationValidationData2.ajouterVoteDetermination(voteDetermination); |
observationValidationData3.setDate(new Date()); |
observationValidationDatas.add(observationValidationData3); |
PropositionDetermination observationValidationData4 = new PropositionDetermination(new Observation()); |
observationValidationData4.setEspece("Acer aceras aus."); |
Contributeur contributeur4 = new Contributeur("5", "Pierre", "Desproges", "contrib4test.com"); |
observationValidationData4.setContributeur(contributeur4); |
Commentaire commentaire2 = new Commentaire(new Contributeur("6", "Greg","Duche", "gregoire@tela-botanica.org"), new Date(), "Public chéri mon amour..."); |
observationValidationData4.ajouterCommentaire(commentaire2); |
observationValidationData4.setId("4"); |
observationValidationData4.ajouterVoteDetermination(voteDetermination); |
observationValidationData4.setDate(new Date()); |
observationValidationDatas.add(observationValidationData4); |
PropositionDetermination observationValidationData5 = new PropositionDetermination(new Observation()); |
observationValidationData5.setEspece("Acer monsp subsp. monsp."); |
Contributeur contributeur5 = new Contributeur("7", "contributeur5", "nom", "contrib@nom.com"); |
observationValidationData5.setContributeur(contributeur5); |
Commentaire commentaire3 = new Commentaire(new Contributeur("8", "tsdt", "emkj", "lkjlkje@teas"), new Date(), "Tout est affaire de décor..."); |
observationValidationData5.ajouterCommentaire(commentaire3); |
observationValidationData5.setId("5"); |
observationValidationData5.ajouterVoteDetermination(voteDetermination); |
observationValidationData5.setDate(new Date()); |
observationValidationDatas.add(observationValidationData5); |
int numobs = 44120; |
for (int i = 0; i < 40; i++) { |
Observation observation = new Observation(); |
String auteur = auteurs.next(); |
observation.setAuteur(auteur); |
observation.setNomRetenu(auteurObs.get(auteur)); |
numobs += i; |
observation.setNumNomenclatural("num nomenclatural " + i); |
observation.setDateReleve("28/09/2011"); |
observation.setFamille("famille " + i); |
observation.setLocalite("localite " + i); |
observation.setNomRetenu(auteurObs.get(auteur)); |
observation.setMotsClefs(motsClefs); |
observation.setInterventionsForum(observationValidationDatas); |
Image image = new Image(); |
image.setIdImage("id image " + i); |
image.setUrlFormat("http://www.tela-botanica.org/appli:cel-img:0000" + String.valueOf(numobs) + "%s%.jpg"); |
image.setUrl("http://www.tela-botanica.org/appli:cel-img:0000" + String.valueOf(numobs) + "CRS.jpg"); |
image.setMiniature("http://www.tela-botanica.org/appli:cel-img:0000" + String.valueOf(numobs) + "XS.jpg"); |
observation.getImages().add(image); |
image.setObservation(observation); |
images.add(image); |
// nombre d'images aléatoires |
int nbImagesAssociees = (int) Math.round(Math.random() * 10); |
for (int j = 0; j < nbImagesAssociees; j++) { |
numobs++; |
image = new Image(); |
image.setIdImage("id image " + i + j); |
image.setUrlFormat("http://www.tela-botanica.org/appli:cel-img:0000" + String.valueOf(numobs) + "%s%.jpg"); |
image.setUrl("http://www.tela-botanica.org/appli:cel-img:0000" + String.valueOf(numobs) + "CRS.jpg"); |
image.setMiniature("http://www.tela-botanica.org/appli:cel-img:0000" + String.valueOf(numobs) + "XS.jpg"); |
observation.getImages().add(image); |
image.setObservation(observation); |
images.add(image); |
} |
VoteProtocole voteProtocole = new VoteProtocole(); |
voteProtocole.setProtocole(protocol1); |
voteProtocole.setVote(3); |
voteProtocole.setContributeur("aurelien"); |
voteProtocole.setDate(new Date()); |
// image.getVoteProtocoles().add(voteProtocole); |
VoteProtocole voteProtocole2 = new VoteProtocole(); |
voteProtocole2.setProtocole(protocol2); |
voteProtocole2.setVote(2); |
voteProtocole2.setContributeur("jpm"); |
voteProtocole2.setDate(new Date()); |
// image.getVoteProtocoles().add(voteProtocole2); |
observations.add(observation); |
} |
ajouterVotesAleatoires(); |
} |
private void ajouterVotesAleatoires() { |
for (InterventionForum validation : observationValidationDatas) { |
if (validation instanceof PropositionDetermination) { |
int nbVotesAjoutes = (int) Math.round(Math.random() * 20); |
for (int i = 0; i < nbVotesAjoutes; i++) { |
VoteDetermination vd = new VoteDetermination(); |
vd.setVote((int) Math.round(Math.random())); |
vd.setDate(new Date()); |
vd.setContributeur("test"); |
((PropositionDetermination) validation).ajouterVoteDetermination(vd); |
} |
} |
} |
} |
/* |
* (non-Javadoc) |
* |
* @see org.tela_botanica.del.client.utils.ObservationService#getImages() |
*/ |
public List<Image> getImages(int debut, int fin) { |
List<Image> sousListe = new ArrayList<Image>(); |
for (int i = debut; i < fin; i++) { |
if (images.get(i) != null) { |
sousListe.add(images.get(i)); |
} else { |
break; |
} |
} |
return sousListe; |
} |
public List<Observation> getObservations(int debut, int fin) { |
List<Observation> sousListe = new ArrayList<Observation>(); |
for (int i = debut; i < fin; i++) { |
if (observations.get(i) != null) { |
sousListe.add(observations.get(i)); |
} else { |
break; |
} |
} |
return sousListe; |
} |
/* |
* (non-Javadoc) |
* |
* @see |
* org.tela_botanica.del.client.utils.ObservationService#getVote(java.lang |
* .String) |
*/ |
@Override |
public List<VoteProtocole> getVote(String idImage) { |
for (Image image : images) { |
if (image.getIdImage().equals(idImage)) { |
return null; |
// return image.getVoteProtocoles(); |
} |
} |
return new ArrayList<VoteProtocole>(0); |
} |
/* |
* (non-Javadoc) |
* |
* @see org.tela_botanica.del.client.utils.ObservationService# |
* getVoteByImageAndProtocol(java.lang.String, java.lang.String) |
*/ |
@Override |
public List<VoteProtocole> getVotePourImageEtProtocole(String idImage, String protocolName) { |
List<VoteProtocole> voteProtocolesLocal = new ArrayList<VoteProtocole>(); |
int rand = (int) (Math.random() * 5); |
for (int i = 0; i < rand; i++) { |
VoteProtocole voteProtocole = new VoteProtocole(); |
voteProtocole.setProtocole(protocoles.get(0)); |
voteProtocole.setVote((int) (Math.random() * 5)); |
voteProtocole.setContributeur("aurelien"); |
voteProtocole.setDate(new Date()); |
VoteProtocole voteProtocole2 = new VoteProtocole(); |
voteProtocole2.setProtocole(protocoles.get(0)); |
voteProtocole2.setVote((int) (Math.random() * 5)); |
voteProtocole2.setContributeur("jpm"); |
voteProtocole2.setDate(new Date()); |
voteProtocolesLocal.add(voteProtocole); |
voteProtocolesLocal.add(voteProtocole2); |
} |
return voteProtocolesLocal; |
} |
public static MockDatasource getInstance() { |
if (instance == null) { |
instance = new MockDatasource(); |
} |
return instance; |
} |
@Override |
public void getImagesEfloreParTaxon(String nomTaxon, ImagesParTaxonCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void getImagesParTaxon(InformationsRecherche informationsRecherche, int debut, int fin, ImagesParTaxonCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void getImagesParObservation(String observationId, ImagesParTaxonCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void getProtocoles(ProtocolesCallback pc) { |
// TODO Auto-generated method stub |
} |
@Override |
public void getProtocole(String nomProtocole) { |
// TODO Auto-generated method stub |
} |
@Override |
public void modifierVote(String idImage, VoteProtocole voteProtocole, |
VoteProtocoleCallback vpc) { |
// TODO Auto-generated method stub |
} |
@Override |
public void getObservation(String idObservation, |
ObservationsCallback observationsCallback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void ajouterProposition(PropositionDetermination proposition, |
PropositionDeterminationCallBack callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void supprimerProposition(PropositionDetermination proposition, |
SuppressionPropositionDeterminationCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void getObservations(InformationsRecherche informationsRecherche, |
int debut, int fin, String statut, ObservationsCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void validerProposition(PropositionDetermination proposition, |
ValidationPropositionCallback validationPropositionCallback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void ajouterVote(String idImage, VoteProtocole voteProtocole, |
AjoutVoteProtocoleCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void supprimerVote(String idImage, VoteProtocole voteProtocole, |
VoteProtocoleCallback vpc) { |
// TODO Auto-generated method stub |
} |
@Override |
public void supprimer(Image image, SuppressionImageCallback callback) { |
// TODO Auto-generated method stub |
} |
@Override |
public void depublier(Observation observation, |
DepublicationObservationCallBack callback) { |
// TODO Auto-generated method stub |
} |
} |
/branches/v1.5-carbone/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()); |
} |
} |
/branches/v1.5-carbone/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(); |
} |
} |
/branches/v1.5-carbone/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()); |
} |
} |
/branches/v1.5-carbone/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); |
} |
} |
/branches/v1.5-carbone/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()); |
} |
} |
/branches/v1.5-carbone/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; |
} |
} |
/branches/v1.5-carbone/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; |
} |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/modeles/ImageTest.java |
---|
New file |
0,0 → 1,40 |
package org.tela_botanica.del.test.modeles; |
import static org.junit.Assert.*; |
import org.junit.Before; |
import org.junit.Test; |
import org.tela_botanica.del.client.modeles.Image; |
import org.tela_botanica.del.client.modeles.Observation; |
public class ImageTest { |
Image testImage; |
Observation testObservation; |
@Before |
public void setUp() { |
testImage = new Image(); |
testObservation = new Observation(); |
testImage.setObservation(testObservation); |
} |
@Test |
public void testEstADeterminerCarNomRetenuVide() { |
testObservation.setNomRetenu(""); |
assertEquals(testImage.estADeterminer(), true); |
} |
@Test |
public void testEstADeterminerCarTagImageADeterminer() { |
testImage.ajouterMotsClef("aDeterminer"); |
assertEquals(testImage.estADeterminer(), true); |
} |
@Test |
public void testEstADeterminerTagObservationADeterminer() { |
testObservation.ajouterMotsClef("aDeterminer"); |
assertEquals(testImage.estADeterminer(), true); |
} |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/modeles/MoyenneVoteTest.java |
---|
New file |
0,0 → 1,41 |
package org.tela_botanica.del.test.modeles; |
import static org.junit.Assert.*; |
import java.util.ArrayList; |
import java.util.Date; |
import java.util.HashMap; |
import org.junit.Test; |
import org.tela_botanica.del.client.modeles.MoyenneVote; |
import org.tela_botanica.del.client.modeles.Observation; |
import org.tela_botanica.del.client.modeles.PropositionDetermination; |
public class MoyenneVoteTest { |
@Test |
public void testCompareTo() { |
PropositionDetermination propositionDetermination = new PropositionDetermination(new Observation()); |
MoyenneVote mv1 = new MoyenneVote(100, propositionDetermination); |
PropositionDetermination propositionDetermination2 = new PropositionDetermination(new Observation()); |
MoyenneVote mv2 = new MoyenneVote(75, propositionDetermination2); |
PropositionDetermination propositionDetermination3 = new PropositionDetermination(new Observation()); |
MoyenneVote mv3 = new MoyenneVote(50, propositionDetermination3); |
PropositionDetermination propositionDetermination4 = new PropositionDetermination(new Observation()); |
MoyenneVote mv4 = new MoyenneVote(50, propositionDetermination4); |
int mv1SuperieurMv2 = mv1.compareTo(mv2); |
assertEquals(-1, mv1SuperieurMv2); |
int mv3InferieurMv2 = mv3.compareTo(mv2); |
assertEquals(1, mv3InferieurMv2); |
int mv4EgalMv3 = mv4.compareTo(mv3); |
assertEquals(0, mv4EgalMv3); |
} |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/modeles/PropositionDeterminationTest.java |
---|
New file |
0,0 → 1,156 |
package org.tela_botanica.del.test.modeles; |
import static org.junit.Assert.*; |
import java.util.ArrayList; |
import java.util.Date; |
import java.util.HashMap; |
import java.util.Map; |
import org.junit.Before; |
import org.junit.Test; |
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.modeles.PropositionDetermination; |
import org.tela_botanica.del.client.modeles.VoteDetermination; |
public class PropositionDeterminationTest { |
PropositionDetermination propositionDetermination; |
VoteDetermination voteDetermination1; |
Commentaire commentaireInitial; |
Date dateInitiale; |
ArrayList<Commentaire> commentairesInitiaux = new ArrayList<Commentaire>(); |
Map<String, VoteDetermination> votesDeterminationsInitiaux = new HashMap<String, VoteDetermination>(); |
@Before |
public void setUp() { |
propositionDetermination = new PropositionDetermination(new Observation()); |
Contributeur contributeur = new Contributeur("1", "peronnet", "Aurélien", "aurelien@tela-botanica.org"); |
propositionDetermination.setContributeur(contributeur); |
propositionDetermination.setId("5"); |
dateInitiale = new Date(); |
propositionDetermination.setDate(dateInitiale); |
commentaireInitial = new Commentaire(contributeur, new Date(), "Oui c'est interessant"); |
commentairesInitiaux.add(commentaireInitial); |
propositionDetermination.setListeCommentaires(commentairesInitiaux); |
propositionDetermination.setEspece("Acer monsp. L."); |
voteDetermination1 = new VoteDetermination(); |
voteDetermination1.setVote(1); |
voteDetermination1.setDate(new Date()); |
voteDetermination1.setContributeur("benjamin"); |
votesDeterminationsInitiaux.put("benjamin", voteDetermination1); |
propositionDetermination.setVotesDeterminations(votesDeterminationsInitiaux); |
} |
@Test |
public void testAjouterVoteDetermination() { |
assertEquals(1, propositionDetermination.getVotesDeterminations().size()); |
VoteDetermination voteDeterminationTest = new VoteDetermination(); |
voteDeterminationTest.setVote(1); |
voteDeterminationTest.setDate(new Date()); |
voteDeterminationTest.setContributeur("gregoire"); |
propositionDetermination.ajouterVoteDetermination(voteDeterminationTest); |
assertEquals(2, propositionDetermination.getVotesDeterminations().size()); |
VoteDetermination voteDeterminationTest2 = new VoteDetermination(); |
voteDeterminationTest2.setVote(0); |
voteDeterminationTest2.setDate(new Date()); |
voteDeterminationTest2.setContributeur("gregoire"); |
propositionDetermination.ajouterVoteDetermination(voteDeterminationTest2); |
// la taille ne doit pas avoir changé après l'ajout du vote de Grégoire car le contributeur |
// est la clé la map (i.e. 1 vote par personne pour une determination) |
assertEquals(2, propositionDetermination.getVotesDeterminations().size()); |
assertEquals(0, propositionDetermination.getVotesDeterminations().get("gregoire").getVote()); |
} |
@Test |
public void testGetContributeur() { |
assertEquals("Aurélien", propositionDetermination.getContributeur().getPrenom()); |
} |
@Test |
public void testSetContributeur() { |
Contributeur contributeurTest = new Contributeur("1", "duche", "gregoire", "gregoire@tela-botanica.org"); |
propositionDetermination.setContributeur(contributeurTest); |
assertEquals("gregoire", propositionDetermination.getContributeur().getPrenom()); |
} |
@Test |
public void testGetId() { |
assertEquals("5", propositionDetermination.getId()); |
} |
@Test |
public void testSetId() { |
propositionDetermination.setId("325"); |
assertEquals("325", propositionDetermination.getId()); |
} |
@Test |
public void testGetDate() { |
assertEquals(dateInitiale, propositionDetermination.getDate()); |
} |
@Test |
public void testSetDate() { |
Date dateTest = new Date(); |
propositionDetermination.setDate(dateTest); |
assertEquals(dateTest, propositionDetermination.getDate()); |
} |
@Test |
public void testGetCommentaires() { |
assertEquals(1, propositionDetermination.getListeCommentaires().size()); |
assertEquals("Aurélien", propositionDetermination.getListeCommentaires().get(0).getContributeur().getPrenom()); |
} |
@Test |
public void testSetCommentaires() { |
ArrayList<Commentaire> listeVide = new ArrayList<Commentaire>(); |
propositionDetermination.setListeCommentaires(listeVide); |
assertEquals(0, propositionDetermination.getListeCommentaires().size()); |
} |
@Test |
public void testAjouterCommentaire() { |
propositionDetermination.setListeCommentaires(commentairesInitiaux); |
assertEquals(1, propositionDetermination.getListeCommentaires().size()); |
Contributeur contributeur = new Contributeur("1", "Peronnet", "Aurélien", "aurelien@tela-botanica.org"); |
Commentaire nouveauCommentaire = new Commentaire(contributeur, new Date(), "Tout est beau, tout est joyeux, je suis une fleur"); |
propositionDetermination.ajouterCommentaire(nouveauCommentaire); |
assertEquals(2, propositionDetermination.getListeCommentaires().size()); |
assertEquals("Aurélien", propositionDetermination.getListeCommentaires().get(1).getContributeur().getPrenom()); |
} |
@Test |
public void testGetEspece() { |
assertEquals("Acer monsp. L.", propositionDetermination.getEspece()); |
} |
@Test |
public void testSetEspece() { |
propositionDetermination.setEspece("Acer monsp. subsp. monsp."); |
assertEquals("Acer monsp. subsp. monsp.", propositionDetermination.getEspece()); |
} |
@Test |
public void testGetVotesDeterminations() { |
assertEquals(1, propositionDetermination.getVotesDeterminations().size()); |
assertEquals(voteDetermination1, propositionDetermination.getVotesDeterminations().get("benjamin")); |
} |
@Test |
public void testSetVotesDeterminations() { |
HashMap<String, VoteDetermination> votesDeterminationVides = new HashMap<String, VoteDetermination>(); |
propositionDetermination.setVotesDeterminations(votesDeterminationVides); |
assertEquals(0,propositionDetermination.getVotesDeterminations().size()); |
} |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/DelTestSuite.java |
---|
New file |
0,0 → 1,26 |
package org.tela_botanica.del.test; |
import org.junit.runner.RunWith; |
import org.junit.runners.Suite; |
import org.junit.runners.Suite.SuiteClasses; |
import org.tela_botanica.del.test.composants.pagination.PaginationPresenteurTest; |
import org.tela_botanica.del.test.composants.votes.BarreRepartitionVotePresenteurTest; |
import org.tela_botanica.del.test.modeles.MoyenneVoteTest; |
import org.tela_botanica.del.test.modeles.PropositionDeterminationTest; |
import org.tela_botanica.del.test.services.CalculVoteDeterminationServiceTest; |
import org.tela_botanica.del.test.vues.identiplante.MoteurIdentiplantePresenteurTest; |
import org.tela_botanica.del.test.vues.identiplante.ResultatIdentiplanteTest; |
@RunWith(Suite.class) |
@SuiteClasses({ |
MoteurIdentiplantePresenteurTest.class, |
PaginationPresenteurTest.class, |
MoyenneVoteTest.class, |
PropositionDeterminationTest.class, |
CalculVoteDeterminationServiceTest.class, |
BarreRepartitionVotePresenteurTest.class, |
ResultatIdentiplanteTest.class |
}) |
public class DelTestSuite { |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/vues/identiplante/ResultatIdentiplanteTest.java |
---|
New file |
0,0 → 1,35 |
package org.tela_botanica.del.test.vues.identiplante; |
import static org.mockito.Mockito.mock; |
import org.junit.Before; |
import org.junit.Test; |
import static org.junit.Assert.*; |
import org.mockito.Mockito; |
import org.tela_botanica.del.client.cache.CacheClient; |
import org.tela_botanica.del.client.services.rest.ImageService; |
import org.tela_botanica.del.client.services.rest.ObservationService; |
import org.tela_botanica.del.client.vues.identiplante.resultats.ResultatsIdentiplantePresenteur; |
public class ResultatIdentiplanteTest { |
private ResultatsIdentiplantePresenteur resultatPresenteur; |
private ResultatsIdentiplantePresenteur.Vue vueResultat; |
private ImageService serviceImage; |
@Before |
public void setUp() throws Exception { |
vueResultat = mock( ResultatsIdentiplantePresenteur.Vue.class, Mockito.RETURNS_MOCKS); |
serviceImage = mock(ImageService.class); |
ObservationService obsService = Mockito.mock(ObservationService.class); |
resultatPresenteur = new ResultatsIdentiplantePresenteur(obsService, vueResultat); |
} |
@Test |
public void testAfficherImages() { |
resultatPresenteur.chercherEtAfficherObservationsPageEnCours(); |
assertEquals(CacheClient.getInstance().getPageCouranteRechercheImage(), 1); |
} |
} |
/branches/v1.5-carbone/src/org/tela_botanica/del/test/vues/identiplante/MoteurIdentiplantePresenteurTest.java |
---|
New file |
0,0 → 1,31 |
package org.tela_botanica.del.test.vues.identiplante; |
import org.junit.Before; |
import org.junit.Test; |
import org.mockito.Mockito; |
import org.tela_botanica.del.client.services.rest.ObservationService; |
import org.tela_botanica.del.client.vues.identiplante.moteur.MoteurIdentiplantePresenteur; |
import com.google.gwt.user.client.ui.HasWidgets; |
public class MoteurIdentiplantePresenteurTest { |
MoteurIdentiplantePresenteur moteurRecherchePresenteur; |
MoteurIdentiplantePresenteur.Vue moteurRechercheVue; |
HasWidgets container; |
@Before |
public void setUp() { |
moteurRechercheVue = Mockito.mock(MoteurIdentiplantePresenteur.Vue.class, Mockito.RETURNS_MOCKS); |
ObservationService obsService = Mockito.mock(ObservationService.class); |
moteurRecherchePresenteur = new MoteurIdentiplantePresenteur(obsService, moteurRechercheVue); |
container = Mockito.mock(HasWidgets.class); |
} |
@Test |
public void testerMoteurRechercheImage() { |
// TODO faire un test GWTTestCase |
} |
} |