Subversion Repositories eFlore/Applications.del

Rev

Rev 413 | Rev 446 | Go to most recent revision | Only display areas with differences | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 413 Rev 445
1 
package org.tela_botanica.del.test.composants.pagination;
 1 
package org.tela_botanica.del.test.composants.pagination;
2 
 
 2 
 
3 
import static org.junit.Assert.*;
 3 
import static org.junit.Assert.assertEquals;
4 
import static org.mockito.Mockito.when;
 4 
import static org.mockito.Mockito.when;
5 
 
 5 
 
6 
import org.junit.Before;
 6 
import org.junit.Before;
7 
import org.junit.Test;
 7 
import org.junit.Test;
8 
import org.mockito.Mock;
 - 
 
9 
import org.mockito.Mockito;
 8 
import org.mockito.Mockito;
10 
import org.mockito.invocation.InvocationOnMock;
 9 
import org.mockito.invocation.InvocationOnMock;
11 
import org.mockito.stubbing.Answer;
 10 
import org.mockito.stubbing.Answer;
12 
import org.tela_botanica.del.client.cache.CacheClient;
 11 
import org.tela_botanica.del.client.cache.CacheClient;
13 
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur;
 12 
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur;
14 
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur.Vue;
 13 
import org.tela_botanica.del.client.composants.pagination.PaginationPresenteur.Vue;
15 
 
 14 
 
16 
import com.google.gwt.event.dom.client.HasChangeHandlers;
 15 
import com.google.gwt.event.dom.client.HasChangeHandlers;
17 
import com.google.gwt.event.dom.client.HasClickHandlers;
 16 
import com.google.gwt.event.dom.client.HasClickHandlers;
18 
import com.google.gwt.user.client.ui.HasWidgets;
 17 
import com.google.gwt.user.client.ui.HasWidgets;
19 
 
 18 
 
20 
public class PaginationPresenteurTest {
 19 
public class PaginationPresenteurTest {
21
20 
 
22 
	PaginationPresenteur paginationHautPresenteur;
 21 
	PaginationPresenteur paginationHautPresenteur;
23 
	PaginationPresenteur paginationBasPresenteur;
 22 
	PaginationPresenteur paginationBasPresenteur;
24
23 
 
25 
	PaginationPresenteur paginationPresenteurSeul;
 24 
	PaginationPresenteur paginationPresenteurSeul;
26
25 
 
27 
	boolean boutonPremierePageEstAffiche;
 26 
	boolean boutonPremierePageEstAffiche;
28 
	boolean boutonDernierePageEstAffiche;
 27 
	boolean boutonDernierePageEstAffiche;
29
28 
 
30 
    @Before
 29 
	@Before
31 
	public void setUp() {
 30 
	public void setUp() {
32 
    	PaginationPresenteur.Vue vueBas = creerMockVuePaginationPresenteurBasique();
 31 
		PaginationPresenteur.Vue vueBas = creerMockVuePaginationPresenteurBasique();
33 
		this.paginationBasPresenteur = new PaginationPresenteur(vueBas, 100, 10) {
 32 
		this.paginationBasPresenteur = new PaginationPresenteur(vueBas, 100, 10, 1) {
34 
			@Override
 33 
			@Override
35 
			public void changerPage(int debut, int fin) {
 34 
			public void chargerElements(int debut, int fin) {
36 
				//TODO: tester avec des données factices, est-ce utile ici ?
 35 
				// TODO: tester avec des données factices, est-ce utile ici ?
37 
			}
 36 
			}
38 
 
 37 
 
39 
			@Override
 38 
			@Override
40 
			public void actualiserPasCache(int pas) {
 39 
			public void actualiserPasCache(int pas) {
41 
				CacheClient.getInstance().setPasPagination(pas);
 40 
				CacheClient.getInstance().setPasPagination(pas);
42 
			}
 41 
			}
43
42 
 
44 
			@Override
 - 
 
45 
			public void synchroniser() {
 - 
 
46 
				paginationHautPresenteur.setPas(getPas());
 - 
 
47 
				paginationHautPresenteur.setPageCourante(getPageCourante());
 - 
 
48 
				paginationHautPresenteur.setNbPages(getNbPages());
 - 
 
49 
				paginationHautPresenteur.actualiserLiens();
 - 
 
50 
			}
 - 
 
51 
		};
 43 
		};
52
44 
 
53 
		PaginationPresenteur.Vue vueHaut = creerMockVuePaginationPresenteurBasique();
 45 
		PaginationPresenteur.Vue vueHaut = creerMockVuePaginationPresenteurBasique();
54 
		this.paginationHautPresenteur = new PaginationPresenteur(vueHaut,100, 10) {
 46 
		this.paginationHautPresenteur = new PaginationPresenteur(vueHaut, 100, 10, 1) {
55 
 
 47 
 
56 
			@Override
 48 
			@Override
57 
			public void changerPage(int debut, int fin) {
 49 
			public void chargerElements(int debut, int fin) {
58 
 
 50 
 
59 
			}
 51 
			}
60 
 
 52 
 
61 
			@Override
 53 
			@Override
62 
			public void actualiserPasCache(int pas) {
 54 
			public void actualiserPasCache(int pas) {
63
- 
 
64 
			}
 - 
 
65 
 
 - 
 
66 
			@Override
 - 
 
67 
			public void synchroniser() {
 - 
 
68 
				paginationBasPresenteur.setPas(getPas());
 - 
 
69 
				paginationBasPresenteur.setPageCourante(getPageCourante());
 - 
 
70 
				paginationBasPresenteur.setNbPages(getNbPages());
 - 
 
71 
				paginationBasPresenteur.actualiserLiens();
 55 
 
- 
 
 56 
			}
72 
			}
 57 
 
73 
		};
 58 
		};
74
59 
 
75 
		PaginationPresenteur.Vue vueSeule = creerMockVuePaginationPresenteurBasique();
 60 
		PaginationPresenteur.Vue vueSeule = creerMockVuePaginationPresenteurBasique();
76 
		this.paginationPresenteurSeul = new PaginationPresenteur(vueSeule, 100, 10) {
 61 
		this.paginationPresenteurSeul = new PaginationPresenteur(vueSeule, 100, 10, 1) {
77 
			@Override
 62 
			@Override
- 
 
 63 
			public void chargerElements(int debut, int fin) {
78 
			public void changerPage(int debut, int fin) {}
 64 
			}
79 
 
 65 
 
- 
 
 66 
			@Override
80 
			@Override
 67 
			public void actualiserPasCache(int pas) {
81 
			public void actualiserPasCache(int pas) {}
 - 
 
82
- 
 
83 
			@Override
 68 
			}
84 
			public void synchroniser() {}
 69 
 
85 
		};
 70 
		};
86 
	}
 - 
 
87
- 
 
88 
	@Test
 - 
 
89 
	public void testSynchroWidgetPagination() {
 - 
 
90
- 
 
91 
		HasWidgets conteneur = Mockito.mock(HasWidgets.class);
 - 
 
92
- 
 
93 
		paginationBasPresenteur.go(conteneur);
 - 
 
94 
		paginationHautPresenteur.go(conteneur);
 - 
 
95 
 
 - 
 
96 
		assertEquals(1, paginationHautPresenteur.getPageCourante());
 - 
 
97 
		assertEquals(1, paginationBasPresenteur.getPageCourante());
 - 
 
98
- 
 
99 
		paginationHautPresenteur.changerPas(20);
 - 
 
100 
		paginationHautPresenteur.synchroniser();
 - 
 
101 
		assertEquals(20, paginationBasPresenteur.getPas());
 - 
 
102 
		assertEquals(20, paginationHautPresenteur.getPas());
 - 
 
103
- 
 
104 
		paginationBasPresenteur.setPageCourante(4);
 - 
 
105 
		paginationBasPresenteur.changerPage(4*20,5*20);
 - 
 
106 
		paginationBasPresenteur.synchroniser();
 - 
 
107
- 
 
108 
		assertEquals(4, paginationHautPresenteur.getPageCourante());
 - 
 
109
- 
 
110 
		paginationBasPresenteur.changerPas(10);
 - 
 
111 
		paginationBasPresenteur.synchroniser();
 - 
 
112 
		assertEquals(8, paginationHautPresenteur.getPageCourante());
 - 
 
113 
		assertEquals(8, paginationBasPresenteur.getPageCourante());
 - 
 
114
- 
 
115 
	}
 71 
	}
116
72 
 
117 
	@Test
 73 
	@Test
118 
	public void testAffichageBoutonPremiereDernierePage() {
 74 
	public void testAffichageBoutonPremiereDernierePage() {
119
75 
 
120 
		mockerMethodeAffichageBoutons(paginationPresenteurSeul.getVue());
 76 
		mockerMethodeAffichageBoutons(paginationPresenteurSeul.getVue());
- 
 
 77 
 
121
78 
		// TODO: voir comment mocker ces méthodes avec Benjamin car le test ne
122 
		//TODO: voir comment mocker ces méthodes avec Benjamin car le test ne passe alors que
 79 
		// passe alors que
123 
		// ça fonctionne en pratique
 80 
		// ça fonctionne en pratique
- 
 
 81 
		paginationPresenteurSeul.afficherLaPremierePage();
- 
 
 82 
		assertEquals(1, paginationPresenteurSeul.getPageCourante());
124 
		paginationPresenteurSeul.premierePage();
 83 
		/*
- 
 
 84 
		 * assertEquals(false,
125 
		assertEquals(1, paginationPresenteurSeul.getPageCourante());
 85 
		 * paginationPresenteurSeul.getVue().boutonPrecedentEstAffiche());
- 
 
 86 
		 * assertEquals(true,
126 
		/*assertEquals(false, paginationPresenteurSeul.getVue().boutonPrecedentEstAffiche());
 87 
		 * paginationPresenteurSeul.getVue().boutonSuivantEstAffiche());
127 
		assertEquals(true, paginationPresenteurSeul.getVue().boutonSuivantEstAffiche());*/
 88 
		 */
128
89 
 
- 
 
 90 
		paginationPresenteurSeul.afficherlaDernierePage();
- 
 
 91 
		assertEquals(9, paginationPresenteurSeul.getPageCourante());
129 
  	  	paginationPresenteurSeul.dernierePage();
 92 
		/*
- 
 
 93 
		 * assertEquals(false,
130 
		assertEquals(9, paginationPresenteurSeul.getPageCourante());
 94 
		 * paginationPresenteurSeul.getVue().boutonPrecedentEstAffiche());
- 
 
 95 
		 * assertEquals(false,
131 
		/*assertEquals(false, paginationPresenteurSeul.getVue().boutonPrecedentEstAffiche());
 96 
		 * paginationPresenteurSeul.getVue().boutonSuivantEstAffiche());
132 
		assertEquals(false, paginationPresenteurSeul.getVue().boutonSuivantEstAffiche());*/
 97 
		 */
133
98 
 
134 
	}
 99 
	}
135
100 
 
136 
	private PaginationPresenteur.Vue creerMockVuePaginationPresenteurBasique() {
 101 
	private PaginationPresenteur.Vue creerMockVuePaginationPresenteurBasique() {
137
102 
 
138 
		PaginationPresenteur.Vue vueMock =  Mockito.mock(PaginationPresenteur.Vue.class);
 103 
		PaginationPresenteur.Vue vueMock = Mockito.mock(PaginationPresenteur.Vue.class);
139 
		HasWidgets zoneLiens = Mockito.mock(HasWidgets.class);
 104 
		HasWidgets zoneLiens = Mockito.mock(HasWidgets.class);
140 
		HasChangeHandlers selecteurPas = Mockito.mock(HasChangeHandlers.class);
 105 
		HasChangeHandlers selecteurPas = Mockito.mock(HasChangeHandlers.class);
141 
		HasClickHandlers boutonPrecedent = Mockito.mock(HasClickHandlers.class);
 106 
		HasClickHandlers boutonPrecedent = Mockito.mock(HasClickHandlers.class);
142 
		HasClickHandlers boutonSuivant = Mockito.mock(HasClickHandlers.class);
 107 
		HasClickHandlers boutonSuivant = Mockito.mock(HasClickHandlers.class);
143 
		HasClickHandlers boutonPremierePage = Mockito.mock(HasClickHandlers.class);
 108 
		HasClickHandlers boutonPremierePage = Mockito.mock(HasClickHandlers.class);
144 
		HasClickHandlers boutonDernierePage = Mockito.mock(HasClickHandlers.class);
 109 
		HasClickHandlers boutonDernierePage = Mockito.mock(HasClickHandlers.class);
145
110 
 
146 
		when(vueMock.getZoneLiens()).thenReturn(zoneLiens);
 111 
		when(vueMock.getZoneLiens()).thenReturn(zoneLiens);
147 
		when(vueMock.getSelecteurPas()).thenReturn(selecteurPas);
 112 
		when(vueMock.getSelecteurPas()).thenReturn(selecteurPas);
148 
		when(vueMock.getBoutonPrecedent()).thenReturn(boutonPrecedent);
 113 
		when(vueMock.getBoutonPrecedent()).thenReturn(boutonPrecedent);
149 
		when(vueMock.getBoutonSuivant()).thenReturn(boutonSuivant);
 114 
		when(vueMock.getBoutonSuivant()).thenReturn(boutonSuivant);
150 
		when(vueMock.getBoutonPremierePage()).thenReturn(boutonPremierePage);
 115 
		when(vueMock.getBoutonPremierePage()).thenReturn(boutonPremierePage);
151 
		when(vueMock.getBoutonDernierePage()).thenReturn(boutonDernierePage);
 116 
		when(vueMock.getBoutonDernierePage()).thenReturn(boutonDernierePage);
152
117 
 
153 
		return vueMock;
 118 
		return vueMock;
154 
	}
 119 
	}
155
120 
 
156 
	private void mockerMethodeAffichageBoutons(Vue vueMock) {
 121 
	private void mockerMethodeAffichageBoutons(Vue vueMock) {
157
122 
 
158 
		when(vueMock.boutonPrecedentEstAffiche()).thenReturn(boutonPremierePageEstAffiche);
 123 
		when(vueMock.boutonPrecedentEstAffiche()).thenReturn(boutonPremierePageEstAffiche);
159 
		when(vueMock.boutonSuivantEstAffiche()).thenReturn(boutonDernierePageEstAffiche);
 124 
		when(vueMock.boutonSuivantEstAffiche()).thenReturn(boutonDernierePageEstAffiche);
160
125 
 
161 
		Mockito.doAnswer(new Answer<Object>() {
 126 
		Mockito.doAnswer(new Answer<Object>() {
162 
		      public Object answer(InvocationOnMock invocation) {
 127 
			public Object answer(InvocationOnMock invocation) {
163 
		    	  boutonPremierePageEstAffiche = true;
 128 
				boutonPremierePageEstAffiche = true;
164 
		          return boutonPremierePageEstAffiche;
 129 
				return boutonPremierePageEstAffiche;
165 
		      }})
 130 
			}
166 
		  .when(vueMock).afficherBoutonPrecedent();
 131 
		}).when(vueMock).afficherBoutonPrecedent();
167
132 
 
168 
		Mockito.doAnswer(new Answer<Object>() {
 133 
		Mockito.doAnswer(new Answer<Object>() {
169 
		      public Object answer(InvocationOnMock invocation) {
 134 
			public Object answer(InvocationOnMock invocation) {
170 
		    	  boutonDernierePageEstAffiche = true;
 135 
				boutonDernierePageEstAffiche = true;
171 
		          return boutonDernierePageEstAffiche;
 136 
				return boutonDernierePageEstAffiche;
172 
		      }})
 137 
			}
173 
		  .when(vueMock).afficherBoutonSuivant();
 138 
		}).when(vueMock).afficherBoutonSuivant();
174
139 
 
175 
		Mockito.doAnswer(new Answer<Object>() {
 140 
		Mockito.doAnswer(new Answer<Object>() {
176 
		      public Object answer(InvocationOnMock invocation) {
 141 
			public Object answer(InvocationOnMock invocation) {
177 
		    	  boutonPremierePageEstAffiche = false;
 142 
				boutonPremierePageEstAffiche = false;
178 
		          return boutonPremierePageEstAffiche;
 143 
				return boutonPremierePageEstAffiche;
179 
		      }})
 144 
			}
180 
		  .when(vueMock).masquerBoutonPrecedent();
 145 
		}).when(vueMock).masquerBoutonPrecedent();
181
146 
 
182 
		Mockito.doAnswer(new Answer<Object>() {
 147 
		Mockito.doAnswer(new Answer<Object>() {
183 
		      public Object answer(InvocationOnMock invocation) {
 148 
			public Object answer(InvocationOnMock invocation) {
184 
		    	  boutonDernierePageEstAffiche = false;
 149 
				boutonDernierePageEstAffiche = false;
185 
		          return boutonDernierePageEstAffiche;
 150 
				return boutonDernierePageEstAffiche;
186 
		      }})
 151 
			}
187 
		  .when(vueMock).masquerBoutonSuivant();
 152 
		}).when(vueMock).masquerBoutonSuivant();
188 
	}
 153 
	}
189 
}
 154 
}