• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2007 Mockito contributors
3  * This program is made available under the terms of the MIT License.
4  */
5 package org.mockitousage.verification;
6 
7 import static org.assertj.core.api.Assertions.assertThatThrownBy;
8 import static org.junit.Assert.fail;
9 import static org.mockito.Mockito.atLeastOnce;
10 import static org.mockito.Mockito.inOrder;
11 import static org.mockito.Mockito.mock;
12 import static org.mockito.Mockito.times;
13 import static org.mockito.Mockito.verify;
14 import static org.mockito.Mockito.verifyNoMoreInteractions;
15 
16 import org.junit.Before;
17 import org.junit.Test;
18 import org.mockito.InOrder;
19 import org.mockito.exceptions.verification.NeverWantedButInvoked;
20 import org.mockito.exceptions.verification.NoInteractionsWanted;
21 import org.mockito.exceptions.verification.VerificationInOrderFailure;
22 import org.mockito.exceptions.verification.WantedButNotInvoked;
23 import org.mockitousage.IMethods;
24 import org.mockitoutil.TestBase;
25 
26 /**
27  * ignored since 'relaxed' in order verification is not implemented (too complex to bother, maybe later).
28  */
29 public class RelaxedVerificationInOrderTest extends TestBase {
30 
31     private IMethods mockOne;
32     private IMethods mockTwo;
33     private IMethods mockThree;
34     private InOrder inOrder;
35 
36     @Before
setUp()37     public void setUp() {
38         mockOne = mock(IMethods.class);
39         mockTwo = mock(IMethods.class);
40         mockThree = mock(IMethods.class);
41 
42         inOrder = inOrder(mockOne, mockTwo, mockThree);
43 
44         mockOne.simpleMethod(1);
45         mockTwo.simpleMethod(2);
46         mockTwo.simpleMethod(2);
47         mockThree.simpleMethod(3);
48         mockTwo.simpleMethod(2);
49         mockOne.simpleMethod(4);
50     }
51 
52     @Test
shouldVerifyInOrderAllInvocations()53     public void shouldVerifyInOrderAllInvocations() {
54         inOrder.verify(mockOne).simpleMethod(1);
55         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
56         inOrder.verify(mockThree).simpleMethod(3);
57         inOrder.verify(mockTwo).simpleMethod(2);
58         inOrder.verify(mockOne).simpleMethod(4);
59         verifyNoMoreInteractions(mockOne, mockTwo, mockThree);
60     }
61 
62     @Test
shouldVerifyInOrderAndBeRelaxed()63     public void shouldVerifyInOrderAndBeRelaxed() {
64         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
65         inOrder.verify(mockThree).simpleMethod(3);
66 
67         verifyNoMoreInteractions(mockThree);
68     }
69 
70     @Test
shouldAllowFirstChunkBeforeLastInvocation()71     public void shouldAllowFirstChunkBeforeLastInvocation() {
72         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
73         inOrder.verify(mockOne).simpleMethod(4);
74 
75         try {
76             verifyNoMoreInteractions(mockTwo);
77             fail();
78         } catch (NoInteractionsWanted e) {
79         }
80     }
81 
82     @Test
shouldAllowAllChunksBeforeLastInvocation()83     public void shouldAllowAllChunksBeforeLastInvocation() {
84         inOrder.verify(mockTwo, times(3)).simpleMethod(2);
85         inOrder.verify(mockOne).simpleMethod(4);
86 
87         verifyNoMoreInteractions(mockTwo);
88     }
89 
90     @Test
shouldVerifyDetectFirstChunkOfInvocationThatExistInManyChunks()91     public void shouldVerifyDetectFirstChunkOfInvocationThatExistInManyChunks() {
92         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
93         inOrder.verify(mockThree).simpleMethod(3);
94         try {
95             verifyNoMoreInteractions(mockTwo);
96             fail();
97         } catch (NoInteractionsWanted e) {
98         }
99     }
100 
101     @Test
shouldVerifyDetectAllChunksOfInvocationThatExistInManyChunks()102     public void shouldVerifyDetectAllChunksOfInvocationThatExistInManyChunks() {
103         inOrder.verify(mockTwo, times(3)).simpleMethod(2);
104         inOrder.verify(mockOne).simpleMethod(4);
105         verifyNoMoreInteractions(mockTwo);
106     }
107 
108     @Test
shouldVerifyInteractionsFromAllChunksWhenAtLeastOnceMode()109     public void shouldVerifyInteractionsFromAllChunksWhenAtLeastOnceMode() {
110         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
111         verifyNoMoreInteractions(mockTwo);
112         try {
113             inOrder.verify(mockThree).simpleMethod(3);
114             fail();
115         } catch (VerificationInOrderFailure e) {
116         }
117     }
118 
119     @Test
shouldVerifyInteractionsFromFirstChunk()120     public void shouldVerifyInteractionsFromFirstChunk() {
121         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
122         try {
123             verifyNoMoreInteractions(mockTwo);
124             fail();
125         } catch (NoInteractionsWanted e) {
126         }
127     }
128 
129     @Test
shouldFailVerificationOfNonFirstChunk()130     public void shouldFailVerificationOfNonFirstChunk() {
131         assertThatThrownBy(
132                         () -> {
133                             inOrder.verify(mockTwo, times(1)).simpleMethod(2);
134                         })
135                 .isInstanceOf(VerificationInOrderFailure.class)
136                 .hasMessageContainingAll(
137                         "Verification in order failure:",
138                         "iMethods.simpleMethod(2);",
139                         "Wanted 1 time:",
140                         "-> at ",
141                         "But was 3 times:",
142                         "-> at ",
143                         "-> at ",
144                         "-> at ");
145     }
146 
147     @Test
shouldPassOnCombinationOfTimesAndAtLeastOnce()148     public void shouldPassOnCombinationOfTimesAndAtLeastOnce() {
149         mockTwo.simpleMethod(2);
150 
151         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
152         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
153         verifyNoMoreInteractions(mockTwo);
154     }
155 
156     @Test
shouldPassOnEdgyCombinationOfTimesAndAtLeastOnce()157     public void shouldPassOnEdgyCombinationOfTimesAndAtLeastOnce() {
158         mockTwo.simpleMethod(2);
159         mockThree.simpleMethod(3);
160 
161         inOrder.verify(mockThree).simpleMethod(3);
162         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
163         inOrder.verify(mockThree).simpleMethod(3);
164 
165         verifyNoMoreInteractions(mockThree);
166     }
167 
168     @Test
shouldVerifyInOrderMockTwoAndThree()169     public void shouldVerifyInOrderMockTwoAndThree() {
170         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
171         inOrder.verify(mockThree).simpleMethod(3);
172         inOrder.verify(mockTwo).simpleMethod(2);
173         verifyNoMoreInteractions(mockTwo, mockThree);
174     }
175 
176     @Test
shouldVerifyInOrderMockOneAndThree()177     public void shouldVerifyInOrderMockOneAndThree() {
178         inOrder.verify(mockOne).simpleMethod(1);
179         inOrder.verify(mockThree).simpleMethod(3);
180         inOrder.verify(mockOne).simpleMethod(4);
181         verifyNoMoreInteractions(mockOne, mockThree);
182     }
183 
184     @Test
shouldVerifyInOrderOnlyTwoInvocations()185     public void shouldVerifyInOrderOnlyTwoInvocations() {
186         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
187         inOrder.verify(mockOne).simpleMethod(4);
188     }
189 
190     @Test
shouldVerifyInOrderOnlyMockTwo()191     public void shouldVerifyInOrderOnlyMockTwo() {
192         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
193         inOrder.verify(mockTwo).simpleMethod(2);
194         verifyNoMoreInteractions(mockTwo);
195     }
196 
197     @Test
shouldVerifyMockTwoCalledTwice()198     public void shouldVerifyMockTwoCalledTwice() {
199         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
200     }
201 
202     @Test
shouldVerifyMockTwoCalledAtLeastOnce()203     public void shouldVerifyMockTwoCalledAtLeastOnce() {
204         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
205     }
206 
207     @Test
shouldFailOnWrongMethodCalledOnMockTwo()208     public void shouldFailOnWrongMethodCalledOnMockTwo() {
209         assertThatThrownBy(
210                         () -> {
211                             inOrder.verify(mockTwo, atLeastOnce()).differentMethod();
212                         })
213                 .isInstanceOf(WantedButNotInvoked.class)
214                 .hasMessageContainingAll(
215                         "Wanted but not invoked:",
216                         "iMethods.differentMethod();",
217                         "-> at ",
218                         "However, there were exactly 6 interactions with this mock:",
219                         "iMethods.simpleMethod(1);",
220                         "-> at ",
221                         "iMethods.simpleMethod(2);",
222                         "-> at ",
223                         "iMethods.simpleMethod(2);",
224                         "-> at ",
225                         "iMethods.simpleMethod(3);",
226                         "-> at ",
227                         "iMethods.simpleMethod(2);",
228                         "-> at ",
229                         "iMethods.simpleMethod(4);",
230                         "-> at ");
231     }
232 
233     @Test
shouldAllowTimesZeroButOnlyInOrder()234     public void shouldAllowTimesZeroButOnlyInOrder() {
235         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
236         inOrder.verify(mockOne, times(0)).simpleMethod(1);
237 
238         try {
239             verify(mockOne, times(0)).simpleMethod(1);
240             fail();
241         } catch (NeverWantedButInvoked e) {
242         }
243     }
244 
245     @Test
shouldFailTimesZeroInOrder()246     public void shouldFailTimesZeroInOrder() {
247         inOrder.verify(mockTwo, times(2)).simpleMethod(2);
248         try {
249             inOrder.verify(mockThree, times(0)).simpleMethod(3);
250             fail();
251         } catch (VerificationInOrderFailure e) {
252         }
253     }
254 
255     @Test
shouldFailWhenMockTwoWantedZeroTimes()256     public void shouldFailWhenMockTwoWantedZeroTimes() {
257         assertThatThrownBy(
258                         () -> {
259                             inOrder.verify(mockTwo, times(0)).simpleMethod(2);
260                         })
261                 .isInstanceOf(VerificationInOrderFailure.class)
262                 .hasMessageContainingAll(
263                         "Verification in order failure:",
264                         "iMethods.simpleMethod(2);",
265                         "Wanted 0 times:",
266                         "-> at ",
267                         "But was 3 times:",
268                         "-> at ",
269                         "-> at ",
270                         "-> at ");
271     }
272 
273     @Test
shouldVerifyLastInvocation()274     public void shouldVerifyLastInvocation() {
275         inOrder.verify(mockOne).simpleMethod(4);
276     }
277 
278     @Test
shouldVerifySecondAndLastInvocation()279     public void shouldVerifySecondAndLastInvocation() {
280         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
281         inOrder.verify(mockOne).simpleMethod(4);
282     }
283 
284     @Test
shouldVerifySecondAndLastInvocationWhenAtLeastOnceUsed()285     public void shouldVerifySecondAndLastInvocationWhenAtLeastOnceUsed() {
286         inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
287         inOrder.verify(mockOne).simpleMethod(4);
288     }
289 
290     @Test
shouldFailOnLastTwoInvocationsInWrongOrder()291     public void shouldFailOnLastTwoInvocationsInWrongOrder() {
292         inOrder.verify(mockOne).simpleMethod(4);
293         try {
294             inOrder.verify(mockTwo, atLeastOnce()).simpleMethod(2);
295             fail();
296         } catch (VerificationInOrderFailure e) {
297         }
298     }
299 
300     @Test
shouldFailOnLastAndFirstInWrongOrder()301     public void shouldFailOnLastAndFirstInWrongOrder() {
302         inOrder.verify(mockOne).simpleMethod(4);
303         try {
304             inOrder.verify(mockOne).simpleMethod(1);
305             fail();
306         } catch (VerificationInOrderFailure e) {
307         }
308     }
309 
310     @Test
shouldFailOnWrongMethodAfterLastInvocation()311     public void shouldFailOnWrongMethodAfterLastInvocation() {
312         inOrder.verify(mockOne).simpleMethod(4);
313         try {
314             inOrder.verify(mockOne).simpleMethod(999);
315             fail();
316         } catch (VerificationInOrderFailure e) {
317         }
318     }
319 }
320