• 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.mockito.Mockito.atLeast;
9 import static org.mockito.Mockito.calls;
10 import static org.mockito.Mockito.inOrder;
11 import static org.mockito.Mockito.times;
12 import static org.mockito.Mockito.verify;
13 import static org.mockito.Mockito.verifyNoMoreInteractions;
14 
15 import org.junit.Test;
16 import org.mockito.InOrder;
17 import org.mockito.Mock;
18 import org.mockito.exceptions.base.MockitoException;
19 import org.mockito.exceptions.verification.NoInteractionsWanted;
20 import org.mockito.exceptions.verification.VerificationInOrderFailure;
21 import org.mockitousage.IMethods;
22 import org.mockitoutil.TestBase;
23 
24 public class VerificationInOrderWithCallsTest extends TestBase {
25 
26     @Mock private IMethods mockOne;
27     @Mock private IMethods mockTwo;
28 
29     @Test
shouldFailWhenMethodNotCalled()30     public void shouldFailWhenMethodNotCalled() {
31         // Given
32         mockOne.oneArg(1);
33         InOrder verifier = inOrder(mockOne);
34         verifier.verify(mockOne, calls(1)).oneArg(1);
35 
36         // When / Then - expected exception thrown
37         assertThatThrownBy(
38                         () -> {
39                             verifier.verify(mockOne, calls(1)).oneArg(2);
40                         })
41                 .isInstanceOf(VerificationInOrderFailure.class)
42                 .hasMessageContainingAll(
43                         "Verification in order failure",
44                         "Wanted but not invoked",
45                         "mockOne.oneArg(2)");
46     }
47 
48     @Test
shouldFailWhenMethodCalledTooFewTimes()49     public void shouldFailWhenMethodCalledTooFewTimes() {
50         // Given
51         mockOne.oneArg(1);
52         mockOne.oneArg(2);
53 
54         InOrder verifier = inOrder(mockOne);
55         verifier.verify(mockOne, calls(1)).oneArg(1);
56 
57         // When / Then - expected exception thrown
58         assertThatThrownBy(
59                         () -> {
60                             verifier.verify(mockOne, calls(2)).oneArg(2);
61                         })
62                 .isInstanceOf(VerificationInOrderFailure.class)
63                 .hasMessageContainingAll(
64                         "Verification in order failure",
65                         "mockOne.oneArg(2)",
66                         "Wanted 2 times",
67                         "But was 1 time");
68     }
69 
70     @Test
shouldFailWhenSingleMethodCallsAreOutOfSequence()71     public void shouldFailWhenSingleMethodCallsAreOutOfSequence() {
72         // Given
73         mockOne.oneArg(1);
74         mockOne.oneArg(2);
75 
76         InOrder verifier = inOrder(mockOne);
77         verifier.verify(mockOne, calls(1)).oneArg(2);
78 
79         // When / Then - expected exception thrown
80         assertThatThrownBy(
81                         () -> {
82                             verifier.verify(mockOne, calls(1)).oneArg(1);
83                         })
84                 .isInstanceOf(VerificationInOrderFailure.class)
85                 .hasMessageContainingAll(
86                         "Verification in order failure",
87                         "Wanted but not invoked",
88                         "mockOne.oneArg(1)");
89     }
90 
91     @Test
shouldFailWhenDifferentMethodCallsAreOutOfSequence()92     public void shouldFailWhenDifferentMethodCallsAreOutOfSequence() {
93         // Given
94         mockOne.oneArg(1);
95         mockOne.voidMethod();
96 
97         InOrder verifier = inOrder(mockOne);
98         verifier.verify(mockOne, calls(1)).voidMethod();
99 
100         // When / Then - expected exception thrown
101         assertThatThrownBy(
102                         () -> {
103                             verifier.verify(mockOne, calls(1)).oneArg(1);
104                         })
105                 .isInstanceOf(VerificationInOrderFailure.class)
106                 .hasMessageContainingAll(
107                         "Verification in order failure",
108                         "Wanted but not invoked",
109                         "mockOne.oneArg(1)");
110     }
111 
112     @Test
shouldFailWhenMethodCallsOnDifferentMocksAreOutOfSequence()113     public void shouldFailWhenMethodCallsOnDifferentMocksAreOutOfSequence() {
114         // Given
115         mockOne.voidMethod();
116         mockTwo.voidMethod();
117 
118         InOrder verifier = inOrder(mockOne, mockTwo);
119         verifier.verify(mockTwo, calls(1)).voidMethod();
120 
121         // When / Then - expected exception thrown
122         assertThatThrownBy(
123                         () -> {
124                             verifier.verify(mockOne, calls(1)).voidMethod();
125                         })
126                 .isInstanceOf(VerificationInOrderFailure.class)
127                 .hasMessageContainingAll(
128                         "Verification in order failure",
129                         "Wanted but not invoked",
130                         "mockOne.voidMethod()");
131     }
132 
133     @Test
shouldAllowSequentialCallsToCallsForSingleMethod()134     public void shouldAllowSequentialCallsToCallsForSingleMethod() {
135         // Given
136         mockOne.oneArg(1);
137         mockOne.oneArg(2);
138         mockOne.oneArg(2);
139         mockOne.oneArg(1);
140 
141         InOrder verifier = inOrder(mockOne);
142 
143         // When
144         verifier.verify(mockOne, calls(1)).oneArg(1);
145         verifier.verify(mockOne, calls(2)).oneArg(2);
146         verifier.verify(mockOne, calls(1)).oneArg(1);
147         verifyNoMoreInteractions(mockOne);
148         verifier.verifyNoMoreInteractions();
149 
150         // Then - no exception thrown
151     }
152 
153     @Test
shouldAllowSequentialCallsToCallsForDifferentMethods()154     public void shouldAllowSequentialCallsToCallsForDifferentMethods() {
155         // Given
156         mockOne.oneArg(1);
157         mockOne.voidMethod();
158         mockOne.voidMethod();
159         mockOne.oneArg(1);
160 
161         InOrder verifier = inOrder(mockOne);
162 
163         // When
164         verifier.verify(mockOne, calls(1)).oneArg(1);
165         verifier.verify(mockOne, calls(2)).voidMethod();
166         verifier.verify(mockOne, calls(1)).oneArg(1);
167         verifyNoMoreInteractions(mockOne);
168         verifier.verifyNoMoreInteractions();
169 
170         // Then - no exception thrown
171     }
172 
173     @Test
shouldAllowSequentialCallsToCallsForMethodsOnDifferentMocks()174     public void shouldAllowSequentialCallsToCallsForMethodsOnDifferentMocks() {
175         // Given
176         mockOne.voidMethod();
177         mockTwo.voidMethod();
178         mockTwo.voidMethod();
179         mockOne.voidMethod();
180 
181         InOrder verifier = inOrder(mockOne, mockTwo);
182 
183         // When
184         verifier.verify(mockOne, calls(1)).voidMethod();
185         verifier.verify(mockTwo, calls(2)).voidMethod();
186         verifier.verify(mockOne, calls(1)).voidMethod();
187         verifyNoMoreInteractions(mockOne);
188         verifyNoMoreInteractions(mockTwo);
189         verifier.verifyNoMoreInteractions();
190 
191         // Then - no exception thrown
192     }
193 
194     @Test
shouldAllowFewerCallsForSingleMethod()195     public void shouldAllowFewerCallsForSingleMethod() {
196         // Given
197         mockOne.oneArg(1);
198         mockOne.oneArg(2);
199         mockOne.oneArg(2);
200         mockOne.oneArg(1);
201         mockOne.oneArg(2);
202 
203         InOrder verifier = inOrder(mockOne);
204 
205         // When
206         verifier.verify(mockOne, calls(1)).oneArg(1);
207         verifier.verify(mockOne, calls(1)).oneArg(2);
208         verifier.verify(mockOne, calls(1)).oneArg(1);
209         verifier.verify(mockOne, calls(1)).oneArg(2);
210 
211         // Then - no exception thrown
212     }
213 
214     @Test
shouldNotVerifySkippedCallsWhenFewerCallsForSingleMethod()215     public void shouldNotVerifySkippedCallsWhenFewerCallsForSingleMethod() {
216         // Given
217         mockOne.oneArg(1);
218         mockOne.oneArg(2);
219         mockOne.oneArg(2);
220         mockOne.oneArg(1);
221 
222         InOrder verifier = inOrder(mockOne);
223         verifier.verify(mockOne, calls(1)).oneArg(1);
224         verifier.verify(mockOne, calls(1)).oneArg(2);
225         verifier.verify(mockOne, calls(1)).oneArg(1);
226 
227         // When / Then - expected exception thrown
228         assertThatThrownBy(
229                         () -> {
230                             verifyNoMoreInteractions(mockOne);
231                         })
232                 .isInstanceOf(NoInteractionsWanted.class);
233     }
234 
235     @Test
shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForSingleMethod()236     public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForSingleMethod() {
237         // Given
238         mockOne.oneArg(1);
239         mockOne.oneArg(2);
240         mockOne.oneArg(2);
241 
242         InOrder verifier = inOrder(mockOne);
243         verifier.verify(mockOne, calls(1)).oneArg(1);
244         verifier.verify(mockOne, calls(1)).oneArg(2);
245 
246         // When / Then - expected exception thrown
247         assertThatThrownBy(
248                         () -> {
249                             verifier.verifyNoMoreInteractions();
250                         })
251                 .isInstanceOf(VerificationInOrderFailure.class)
252                 .hasMessageContaining("No interactions wanted here");
253     }
254 
255     @Test
shouldAllowFewerCallsForDifferentMethods()256     public void shouldAllowFewerCallsForDifferentMethods() {
257         // Given
258         mockOne.oneArg(1);
259         mockOne.voidMethod();
260         mockOne.voidMethod();
261         mockOne.oneArg(1);
262         mockOne.voidMethod();
263 
264         InOrder verifier = inOrder(mockOne);
265 
266         // When
267         verifier.verify(mockOne, calls(1)).oneArg(1);
268         verifier.verify(mockOne, calls(1)).voidMethod();
269         verifier.verify(mockOne, calls(1)).oneArg(1);
270         verifier.verify(mockOne, calls(1)).voidMethod();
271 
272         // Then - no exception thrown
273     }
274 
275     @Test
shouldNotVerifySkippedCallsWhenFewerCallsForDifferentMethods()276     public void shouldNotVerifySkippedCallsWhenFewerCallsForDifferentMethods() {
277         // Given
278         mockOne.oneArg(1);
279         mockOne.voidMethod();
280         mockOne.voidMethod();
281         mockOne.oneArg(1);
282 
283         InOrder verifier = inOrder(mockOne);
284         verifier.verify(mockOne, calls(1)).oneArg(1);
285         verifier.verify(mockOne, calls(1)).voidMethod();
286         verifier.verify(mockOne, calls(1)).oneArg(1);
287 
288         // When / Then - no exception thrown
289         assertThatThrownBy(
290                         () -> {
291                             verifyNoMoreInteractions(mockOne);
292                         })
293                 .isInstanceOf(NoInteractionsWanted.class);
294     }
295 
296     @Test
shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForDifferentMethods()297     public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForDifferentMethods() {
298         // Given
299         mockOne.oneArg(1);
300         mockOne.voidMethod();
301         mockOne.voidMethod();
302 
303         InOrder verifier = inOrder(mockOne);
304         verifier.verify(mockOne, calls(1)).oneArg(1);
305         verifier.verify(mockOne, calls(1)).voidMethod();
306 
307         // When / Then - expected exception thrown
308         assertThatThrownBy(
309                         () -> {
310                             verifier.verifyNoMoreInteractions();
311                         })
312                 .isInstanceOf(VerificationInOrderFailure.class)
313                 .hasMessageContaining("No interactions wanted here");
314     }
315 
316     @Test
shouldAllowFewerCallsForMethodsOnDifferentMocks()317     public void shouldAllowFewerCallsForMethodsOnDifferentMocks() {
318         // Given
319         mockOne.voidMethod();
320         mockTwo.voidMethod();
321         mockTwo.voidMethod();
322         mockOne.voidMethod();
323         mockTwo.voidMethod();
324 
325         InOrder verifier = inOrder(mockOne, mockTwo);
326 
327         // When
328         verifier.verify(mockOne, calls(1)).voidMethod();
329         verifier.verify(mockTwo, calls(1)).voidMethod();
330         verifier.verify(mockOne, calls(1)).voidMethod();
331         verifier.verify(mockTwo, calls(1)).voidMethod();
332 
333         // Then - no exception thrown
334     }
335 
336     @Test
shouldNotVerifySkippedCallsWhenFewerCallsForMethodsOnDifferentMocks()337     public void shouldNotVerifySkippedCallsWhenFewerCallsForMethodsOnDifferentMocks() {
338         // Given
339         mockOne.voidMethod();
340         mockTwo.voidMethod();
341         mockTwo.voidMethod();
342         mockOne.voidMethod();
343 
344         InOrder verifier = inOrder(mockOne, mockTwo);
345         verifier.verify(mockOne, calls(1)).voidMethod();
346         verifier.verify(mockTwo, calls(1)).voidMethod();
347         verifier.verify(mockOne, calls(1)).voidMethod();
348 
349         // When / Then - expected exception thrown
350         assertThatThrownBy(
351                         () -> {
352                             verifyNoMoreInteractions(mockTwo);
353                         })
354                 .isInstanceOf(NoInteractionsWanted.class);
355     }
356 
357     @Test
shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForMethodsOnDifferentMocks()358     public void shouldNotVerifySkippedCallsInInOrderWhenFewerCallsForMethodsOnDifferentMocks() {
359         // Given
360         mockOne.voidMethod();
361         mockTwo.voidMethod();
362         mockTwo.voidMethod();
363 
364         InOrder verifier = inOrder(mockOne, mockTwo);
365         verifier.verify(mockOne, calls(1)).voidMethod();
366         verifier.verify(mockTwo, calls(1)).voidMethod();
367 
368         // When / Then - expected exception thrown
369         assertThatThrownBy(
370                         () -> {
371                             verifier.verifyNoMoreInteractions();
372                         })
373                 .isInstanceOf(VerificationInOrderFailure.class)
374                 .hasMessageContaining("No interactions wanted here");
375     }
376 
377     @Test
shouldVerifyWithCallsAfterUseOfTimes()378     public void shouldVerifyWithCallsAfterUseOfTimes() {
379         // Given
380         mockOne.oneArg(1);
381         mockOne.oneArg(2);
382         mockOne.oneArg(2);
383         mockOne.oneArg(1);
384 
385         InOrder verifier = inOrder(mockOne);
386 
387         // When
388         verifier.verify(mockOne, times(1)).oneArg(1);
389         verifier.verify(mockOne, calls(2)).oneArg(2);
390         verifier.verify(mockOne, calls(1)).oneArg(1);
391 
392         // Then - no exception thrown
393     }
394 
395     @Test
shouldVerifyWithCallsAfterUseOfAtLeast()396     public void shouldVerifyWithCallsAfterUseOfAtLeast() {
397         // Given
398         mockOne.oneArg(1);
399         mockOne.oneArg(2);
400         mockOne.oneArg(2);
401 
402         InOrder verifier = inOrder(mockOne);
403 
404         // When
405         verifier.verify(mockOne, atLeast(1)).oneArg(1);
406         verifier.verify(mockOne, calls(2)).oneArg(2);
407 
408         // Then - no exception thrown
409     }
410 
411     @Test
shouldVerifyWithTimesAfterUseOfCalls()412     public void shouldVerifyWithTimesAfterUseOfCalls() {
413         // Given
414         mockOne.oneArg(1);
415         mockOne.oneArg(2);
416         mockOne.oneArg(2);
417         mockOne.oneArg(1);
418 
419         InOrder verifier = inOrder(mockOne);
420 
421         // When
422         verifier.verify(mockOne, calls(1)).oneArg(1);
423         verifier.verify(mockOne, times(2)).oneArg(2);
424         verifier.verify(mockOne, times(1)).oneArg(1);
425 
426         // Then - no exception thrown
427     }
428 
429     @Test
shouldVerifyWithAtLeastAfterUseOfCalls()430     public void shouldVerifyWithAtLeastAfterUseOfCalls() {
431         // Given
432         mockOne.oneArg(1);
433         mockOne.oneArg(2);
434         mockOne.oneArg(2);
435         mockOne.oneArg(1);
436 
437         InOrder verifier = inOrder(mockOne);
438 
439         // When
440         verifier.verify(mockOne, calls(1)).oneArg(1);
441         verifier.verify(mockOne, atLeast(1)).oneArg(2);
442         verifier.verify(mockOne, atLeast(1)).oneArg(1);
443 
444         // Then - no exception thrown
445     }
446 
447     @Test
shouldVerifyWithTimesAfterCallsInSameChunk()448     public void shouldVerifyWithTimesAfterCallsInSameChunk() {
449         // Given
450         mockOne.oneArg(1);
451         mockOne.oneArg(1);
452         mockOne.oneArg(1);
453 
454         InOrder verifier = inOrder(mockOne);
455 
456         // When
457         verifier.verify(mockOne, calls(1)).oneArg(1);
458         verifier.verify(mockOne, times(2)).oneArg(1);
459         verifier.verifyNoMoreInteractions();
460 
461         // Then - no exception thrown
462     }
463 
464     @Test
shouldFailToCreateCallsWithZeroArgument()465     public void shouldFailToCreateCallsWithZeroArgument() {
466         // Given
467         InOrder verifier = inOrder(mockOne);
468 
469         // When / Then - expected exception thrown
470         assertThatThrownBy(
471                         () -> {
472                             verifier.verify(mockOne, calls(0)).voidMethod();
473                         })
474                 .isInstanceOf(MockitoException.class)
475                 .hasMessageContaining("Negative and zero values are not allowed here");
476     }
477 
478     @Test
shouldFailToCreateCallsWithNegativeArgument()479     public void shouldFailToCreateCallsWithNegativeArgument() {
480         // Given
481         InOrder verifier = inOrder(mockOne);
482 
483         // When / Then - expected exception thrown
484         assertThatThrownBy(
485                         () -> {
486                             verifier.verify(mockOne, calls(-1)).voidMethod();
487                         })
488                 .isInstanceOf(MockitoException.class)
489                 .hasMessageContaining("Negative and zero values are not allowed here");
490     }
491 
492     @Test
shouldFailToCreateCallsForNonInOrderVerification()493     public void shouldFailToCreateCallsForNonInOrderVerification() {
494         // Given
495         mockOne.voidMethod();
496 
497         // When / Then - expected exception thrown
498         assertThatThrownBy(
499                         () -> {
500                             verify(mockOne, calls(1)).voidMethod();
501                         })
502                 .isInstanceOf(MockitoException.class)
503                 .hasMessageContaining("calls is only intended to work with InOrder");
504     }
505 }
506