1 /*
2  * Copyright (c) 2007 Mockito contributors
3  * This program is made available under the terms of the MIT License.
4  */
5 
6 package org.mockitousage.stacktrace;
7 
8 import org.assertj.core.api.Assertions;
9 import org.junit.After;
10 import org.junit.Before;
11 import org.junit.Test;
12 import org.mockito.InOrder;
13 import org.mockito.Mock;
14 import org.mockito.exceptions.base.MockitoException;
15 import org.mockito.exceptions.verification.NoInteractionsWanted;
16 import org.mockito.exceptions.verification.VerificationInOrderFailure;
17 import org.mockito.exceptions.verification.WantedButNotInvoked;
18 import org.mockitousage.IMethods;
19 import org.mockitoutil.TestBase;
20 
21 import static org.junit.Assert.fail;
22 import static org.mockito.Mockito.inOrder;
23 import static org.mockito.Mockito.verify;
24 import static org.mockito.Mockito.verifyNoMoreInteractions;
25 import static org.mockito.Mockito.verifyZeroInteractions;
26 import static org.mockito.Mockito.when;
27 import static org.mockitoutil.Conditions.firstMethodInStackTrace;
28 
29 public class StackTraceFilteringTest extends TestBase {
30 
31     @Mock private IMethods mock;
32 
33     @After
resetState()34     public void resetState() {
35         super.resetState();
36     }
37 
38     @Before
setup()39     public void setup() {
40         makeStackTracesClean();
41     }
42 
43     @Test
shouldFilterStackTraceOnVerify()44     public void shouldFilterStackTraceOnVerify() {
45         try {
46             verify(mock).simpleMethod();
47             fail();
48         } catch (WantedButNotInvoked e) {
49             Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerify"));
50         }
51     }
52 
53     @Test
shouldFilterStackTraceOnVerifyNoMoreInteractions()54     public void shouldFilterStackTraceOnVerifyNoMoreInteractions() {
55         mock.oneArg(true);
56         try {
57             verifyNoMoreInteractions(mock);
58             fail();
59         } catch (NoInteractionsWanted e) {
60             Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyNoMoreInteractions"));
61         }
62     }
63 
64     @Test
shouldFilterStackTraceOnVerifyZeroInteractions()65     public void shouldFilterStackTraceOnVerifyZeroInteractions() {
66         mock.oneArg(true);
67         try {
68             verifyZeroInteractions(mock);
69             fail();
70         } catch (NoInteractionsWanted e) {
71             Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStackTraceOnVerifyZeroInteractions"));
72         }
73     }
74 
75     @SuppressWarnings({"MockitoUsage", "CheckReturnValue"})
76     @Test
shouldFilterStacktraceOnMockitoException()77     public void shouldFilterStacktraceOnMockitoException() {
78         verify(mock);
79         try {
80             verify(mock).oneArg(true);
81             fail();
82         } catch (MockitoException expected) {
83             Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceOnMockitoException"));
84         }
85     }
86 
87     @Test
shouldFilterStacktraceWhenVerifyingInOrder()88     public void shouldFilterStacktraceWhenVerifyingInOrder() {
89         InOrder inOrder = inOrder(mock);
90         mock.oneArg(true);
91         mock.oneArg(false);
92 
93         inOrder.verify(mock).oneArg(false);
94         try {
95             inOrder.verify(mock).oneArg(true);
96             fail();
97         } catch (VerificationInOrderFailure e) {
98             Assertions.assertThat(e).has(firstMethodInStackTrace("shouldFilterStacktraceWhenVerifyingInOrder"));
99         }
100     }
101 
102     @Test
shouldFilterStacktraceWhenInOrderThrowsMockitoException()103     public void shouldFilterStacktraceWhenInOrderThrowsMockitoException() {
104         try {
105             inOrder();
106             fail();
107         } catch (MockitoException expected) {
108             Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderThrowsMockitoException"));
109         }
110     }
111 
112     @Test
shouldFilterStacktraceWhenInOrderVerifies()113     public void shouldFilterStacktraceWhenInOrderVerifies() {
114         try {
115             InOrder inOrder = inOrder(mock);
116             inOrder.verify(null);
117             fail();
118         } catch (MockitoException expected) {
119             Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStacktraceWhenInOrderVerifies"));
120         }
121     }
122 
123     @Test
shouldFilterStackTraceWhenThrowingExceptionFromMockHandler()124     public void shouldFilterStackTraceWhenThrowingExceptionFromMockHandler() {
125         try {
126             when(mock.oneArg(true)).thenThrow(new Exception());
127             fail();
128         } catch (MockitoException expected) {
129             Assertions.assertThat(expected).has(firstMethodInStackTrace("shouldFilterStackTraceWhenThrowingExceptionFromMockHandler"));
130         }
131     }
132 
133     @Test
shouldShowProperExceptionStackTrace()134     public void shouldShowProperExceptionStackTrace() throws Exception {
135         when(mock.simpleMethod()).thenThrow(new RuntimeException());
136 
137         try {
138             mock.simpleMethod();
139             fail();
140         } catch (RuntimeException e) {
141             Assertions.assertThat(e).has(firstMethodInStackTrace("shouldShowProperExceptionStackTrace"));
142         }
143     }
144 }
145