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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
/*
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockito.internal.stubbing.defaultanswers;
import org.mockito.MockSettings;
import org.mockito.Mockito;
import org.mockito.internal.MockitoCore;
import org.mockito.internal.creation.settings.CreationSettings;
import org.mockito.internal.stubbing.InvocationContainerImpl;
import org.mockito.internal.stubbing.StubbedInvocationMatcher;
import org.mockito.internal.util.MockUtil;
import org.mockito.internal.util.reflection.GenericMetadataSupport;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.mock.MockCreationSettings;
import org.mockito.stubbing.Answer;
import org.mockito.stubbing.Stubbing;
import java.io.IOException;
import java.io.Serializable;
import static org.mockito.Mockito.withSettings;
/**
* Returning deep stub implementation.
*
* Will return previously created mock if the invocation matches.
*
* <p>Supports nested generic information, with this answer you can write code like this :
*
* <pre class="code"><code class="java">
* interface GenericsNest<K extends Comparable<K> & Cloneable> extends Map<K, Set<Number>> {}
*
* GenericsNest<?> mock = mock(GenericsNest.class, new ReturnsGenericDeepStubs());
* Number number = mock.entrySet().iterator().next().getValue().iterator().next();
* </code></pre>
* </p>
*
* @see org.mockito.Mockito#RETURNS_DEEP_STUBS
* @see org.mockito.Answers#RETURNS_DEEP_STUBS
*/
public class ReturnsDeepStubs implements Answer<Object>, Serializable {
private static final long serialVersionUID = -7105341425736035847L;
public Object answer(InvocationOnMock invocation) throws Throwable {
GenericMetadataSupport returnTypeGenericMetadata =
actualParameterizedType(invocation.getMock()).resolveGenericReturnType(invocation.getMethod());
Class<?> rawType = returnTypeGenericMetadata.rawType();
if (!mockitoCore().isTypeMockable(rawType)) {
return delegate().returnValueFor(rawType);
}
return deepStub(invocation, returnTypeGenericMetadata);
}
private Object deepStub(InvocationOnMock invocation, GenericMetadataSupport returnTypeGenericMetadata) throws Throwable {
InvocationContainerImpl container = MockUtil.getInvocationContainer(invocation.getMock());
// matches invocation for verification
// TODO why don't we do container.findAnswer here?
for (Stubbing stubbing : container.getStubbingsDescending()) {
if (container.getInvocationForStubbing().matches(stubbing.getInvocation())) {
return stubbing.answer(invocation);
}
}
// record deep stub answer
StubbedInvocationMatcher stubbing = recordDeepStubAnswer(
newDeepStubMock(returnTypeGenericMetadata, invocation.getMock()),
container
);
// deep stubbing creates a stubbing and immediately uses it
// so the stubbing is actually used by the same invocation
stubbing.markStubUsed(stubbing.getInvocation());
return stubbing.answer(invocation);
}
/**
* Creates a mock using the Generics Metadata.
*
* <li>Finally as we want to mock the actual type, but we want to pass along the contextual generics meta-data
* that was resolved for the current return type, for this to happen we associate to the mock an new instance of
* {@link ReturnsDeepStubs} answer in which we will store the returned type generic metadata.
*
* @param returnTypeGenericMetadata The metadata to use to create the new mock.
* @param parentMock The parent of the current deep stub mock.
* @return The mock
*/
private Object newDeepStubMock(GenericMetadataSupport returnTypeGenericMetadata, Object parentMock) {
MockCreationSettings parentMockSettings = MockUtil.getMockSettings(parentMock);
return mockitoCore().mock(
returnTypeGenericMetadata.rawType(),
withSettingsUsing(returnTypeGenericMetadata, parentMockSettings)
);
}
private MockSettings withSettingsUsing(GenericMetadataSupport returnTypeGenericMetadata, MockCreationSettings parentMockSettings) {
MockSettings mockSettings = returnTypeGenericMetadata.hasRawExtraInterfaces() ?
withSettings().extraInterfaces(returnTypeGenericMetadata.rawExtraInterfaces())
: withSettings();
return propagateSerializationSettings(mockSettings, parentMockSettings)
.defaultAnswer(returnsDeepStubsAnswerUsing(returnTypeGenericMetadata));
}
private MockSettings propagateSerializationSettings(MockSettings mockSettings, MockCreationSettings parentMockSettings) {
return mockSettings.serializable(parentMockSettings.getSerializableMode());
}
private ReturnsDeepStubs returnsDeepStubsAnswerUsing(final GenericMetadataSupport returnTypeGenericMetadata) {
return new ReturnsDeepStubsSerializationFallback(returnTypeGenericMetadata);
}
private StubbedInvocationMatcher recordDeepStubAnswer(final Object mock, InvocationContainerImpl container) {
DeeplyStubbedAnswer answer = new DeeplyStubbedAnswer(mock);
return container.addAnswer(answer, false, null);
}
protected GenericMetadataSupport actualParameterizedType(Object mock) {
CreationSettings mockSettings = (CreationSettings) MockUtil.getMockHandler(mock).getMockSettings();
return GenericMetadataSupport.inferFrom(mockSettings.getTypeToMock());
}
private static class ReturnsDeepStubsSerializationFallback extends ReturnsDeepStubs implements Serializable {
@SuppressWarnings("serial") // not gonna be serialized
private final GenericMetadataSupport returnTypeGenericMetadata;
public ReturnsDeepStubsSerializationFallback(GenericMetadataSupport returnTypeGenericMetadata) {
this.returnTypeGenericMetadata = returnTypeGenericMetadata;
}
@Override
protected GenericMetadataSupport actualParameterizedType(Object mock) {
return returnTypeGenericMetadata;
}
private Object writeReplace() throws IOException {
return Mockito.RETURNS_DEEP_STUBS;
}
}
private static class DeeplyStubbedAnswer implements Answer<Object>, Serializable {
@SuppressWarnings("serial") // serialization will fail with a nice message if mock not serializable
private final Object mock;
DeeplyStubbedAnswer(Object mock) {
this.mock = mock;
}
public Object answer(InvocationOnMock invocation) throws Throwable {
return mock;
}
}
private static MockitoCore mockitoCore() {
return LazyHolder.MOCKITO_CORE;
}
private static ReturnsEmptyValues delegate() {
return LazyHolder.DELEGATE;
}
private static class LazyHolder {
private static final MockitoCore MOCKITO_CORE = new MockitoCore();
private static final ReturnsEmptyValues DELEGATE = new ReturnsEmptyValues();
}
}
|
