/
DefaultMockitoSession.java
109 lines (95 loc) · 3.53 KB
/
DefaultMockitoSession.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
/*
* Copyright (c) 2018 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockito.internal.framework;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.MockitoSession;
import org.mockito.exceptions.base.MockitoException;
import org.mockito.exceptions.misusing.RedundantListenerException;
import org.mockito.internal.exceptions.Reporter;
import org.mockito.internal.junit.TestFinishedEvent;
import org.mockito.internal.junit.UniversalTestListener;
import org.mockito.plugins.MockitoLogger;
import org.mockito.quality.Strictness;
import java.util.ArrayList;
import java.util.List;
public class DefaultMockitoSession implements MockitoSession {
private final String name;
private final UniversalTestListener listener;
private final List<AutoCloseable> closeables = new ArrayList<>();
public DefaultMockitoSession(
List<Object> testClassInstances,
String name,
Strictness strictness,
MockitoLogger logger) {
this.name = name;
listener = new UniversalTestListener(strictness, logger);
try {
// So that the listener can capture mock creation events
Mockito.framework().addListener(listener);
} catch (RedundantListenerException e) {
Reporter.unfinishedMockingSession();
}
try {
for (Object testClassInstance : testClassInstances) {
closeables.add(MockitoAnnotations.openMocks(testClassInstance));
}
} catch (RuntimeException e) {
try {
release();
} catch (Throwable t) {
e.addSuppressed(t);
}
// clean up in case 'openMocks' fails
listener.setListenerDirty();
throw e;
}
}
@Override
public void setStrictness(Strictness strictness) {
listener.setStrictness(strictness);
}
@Override
public void finishMocking() {
finishMocking(null);
}
@Override
public void finishMocking(final Throwable failure) {
try {
// Cleaning up the state, we no longer need the listener hooked up
// The listener implements MockCreationListener and at this point
// we no longer need to listen on mock creation events. We are wrapping up the session
Mockito.framework().removeListener(listener);
// Emit test finished event so that validation such as strict stubbing can take place
listener.testFinished(
new TestFinishedEvent() {
@Override
public Throwable getFailure() {
return failure;
}
@Override
public String getTestName() {
return name;
}
});
// Validate only when there is no test failure to avoid reporting multiple problems
if (failure == null) {
// Finally, validate user's misuse of Mockito framework.
Mockito.validateMockitoUsage();
}
} finally {
release();
}
}
private void release() {
for (AutoCloseable closeable : closeables) {
try {
closeable.close();
} catch (Exception e) {
throw new MockitoException("Failed to release " + closeable, e);
}
}
}
}