org.mockito.internal.MockitoCore Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of mockito-core Show documentation
Show all versions of mockito-core Show documentation
Mockito mock objects library core API and implementation
/*
* Copyright (c) 2007 Mockito contributors
* This program is made available under the terms of the MIT License.
*/
package org.mockito.internal;
import static org.mockito.internal.exceptions.Reporter.missingMethodInvocation;
import static org.mockito.internal.exceptions.Reporter.mocksHaveToBePassedToVerifyNoMoreInteractions;
import static org.mockito.internal.exceptions.Reporter.mocksHaveToBePassedWhenCreatingInOrder;
import static org.mockito.internal.exceptions.Reporter.notAMockPassedToVerify;
import static org.mockito.internal.exceptions.Reporter.notAMockPassedToVerifyNoMoreInteractions;
import static org.mockito.internal.exceptions.Reporter.notAMockPassedWhenCreatingInOrder;
import static org.mockito.internal.exceptions.Reporter.nullPassedToVerify;
import static org.mockito.internal.exceptions.Reporter.nullPassedToVerifyNoMoreInteractions;
import static org.mockito.internal.exceptions.Reporter.nullPassedWhenCreatingInOrder;
import static org.mockito.internal.exceptions.Reporter.stubPassedToVerify;
import static org.mockito.internal.progress.ThreadSafeMockingProgress.mockingProgress;
import static org.mockito.internal.util.MockUtil.createConstructionMock;
import static org.mockito.internal.util.MockUtil.createMock;
import static org.mockito.internal.util.MockUtil.createStaticMock;
import static org.mockito.internal.util.MockUtil.getInvocationContainer;
import static org.mockito.internal.util.MockUtil.getMockHandler;
import static org.mockito.internal.util.MockUtil.isMock;
import static org.mockito.internal.util.MockUtil.resetMock;
import static org.mockito.internal.verification.VerificationModeFactory.noInteractions;
import static org.mockito.internal.verification.VerificationModeFactory.noMoreInteractions;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.Function;
import org.mockito.InOrder;
import org.mockito.MockSettings;
import org.mockito.MockedConstruction;
import org.mockito.MockedStatic;
import org.mockito.MockingDetails;
import org.mockito.exceptions.misusing.DoNotMockException;
import org.mockito.exceptions.misusing.NotAMockException;
import org.mockito.internal.configuration.plugins.Plugins;
import org.mockito.internal.creation.MockSettingsImpl;
import org.mockito.internal.invocation.finder.VerifiableInvocationsFinder;
import org.mockito.internal.listeners.VerificationStartedNotifier;
import org.mockito.internal.progress.MockingProgress;
import org.mockito.internal.stubbing.DefaultLenientStubber;
import org.mockito.internal.stubbing.InvocationContainerImpl;
import org.mockito.internal.stubbing.OngoingStubbingImpl;
import org.mockito.internal.stubbing.StubberImpl;
import org.mockito.internal.util.DefaultMockingDetails;
import org.mockito.internal.util.MockUtil;
import org.mockito.internal.verification.MockAwareVerificationMode;
import org.mockito.internal.verification.VerificationDataImpl;
import org.mockito.internal.verification.VerificationModeFactory;
import org.mockito.internal.verification.api.InOrderContext;
import org.mockito.internal.verification.api.VerificationDataInOrder;
import org.mockito.internal.verification.api.VerificationDataInOrderImpl;
import org.mockito.invocation.Invocation;
import org.mockito.invocation.MockHandler;
import org.mockito.mock.MockCreationSettings;
import org.mockito.plugins.DoNotMockEnforcer;
import org.mockito.plugins.MockMaker;
import org.mockito.quality.Strictness;
import org.mockito.stubbing.LenientStubber;
import org.mockito.stubbing.OngoingStubbing;
import org.mockito.stubbing.Stubber;
import org.mockito.verification.VerificationMode;
@SuppressWarnings("unchecked")
public class MockitoCore {
private static final DoNotMockEnforcer DO_NOT_MOCK_ENFORCER = Plugins.getDoNotMockEnforcer();
private static final Set> MOCKABLE_CLASSES =
Collections.synchronizedSet(new HashSet<>());
public T mock(Class typeToMock, MockSettings settings) {
if (!(settings instanceof MockSettingsImpl)) {
throw new IllegalArgumentException(
"Unexpected implementation of '"
+ settings.getClass().getCanonicalName()
+ "'\n"
+ "At the moment, you cannot provide your own implementations of that class.");
}
MockSettingsImpl impl = (MockSettingsImpl) settings;
MockCreationSettings creationSettings = impl.build(typeToMock);
checkDoNotMockAnnotation(creationSettings.getTypeToMock(), creationSettings);
T mock = createMock(creationSettings);
mockingProgress().mockingStarted(mock, creationSettings);
return mock;
}
private void checkDoNotMockAnnotation(
Class typeToMock, MockCreationSettings creationSettings) {
checkDoNotMockAnnotationForType(typeToMock);
for (Class aClass : creationSettings.getExtraInterfaces()) {
checkDoNotMockAnnotationForType(aClass);
}
}
private static void checkDoNotMockAnnotationForType(Class type) {
// Object and interfaces do not have a super class
if (type == null) {
return;
}
if (MOCKABLE_CLASSES.contains(type)) {
return;
}
String warning = DO_NOT_MOCK_ENFORCER.checkTypeForDoNotMockViolation(type);
if (warning != null) {
throw new DoNotMockException(warning);
}
checkDoNotMockAnnotationForType(type.getSuperclass());
for (Class aClass : type.getInterfaces()) {
checkDoNotMockAnnotationForType(aClass);
}
MOCKABLE_CLASSES.add(type);
}
public MockedStatic mockStatic(Class classToMock, MockSettings settings) {
if (!MockSettingsImpl.class.isInstance(settings)) {
throw new IllegalArgumentException(
"Unexpected implementation of '"
+ settings.getClass().getCanonicalName()
+ "'\n"
+ "At the moment, you cannot provide your own implementations of that class.");
}
MockSettingsImpl impl = MockSettingsImpl.class.cast(settings);
MockCreationSettings creationSettings = impl.buildStatic(classToMock);
MockMaker.StaticMockControl control = createStaticMock(classToMock, creationSettings);
control.enable();
mockingProgress().mockingStarted(classToMock, creationSettings);
return new MockedStaticImpl<>(control);
}
public MockedConstruction mockConstruction(
Class typeToMock,
Function settingsFactory,
MockedConstruction.MockInitializer mockInitializer) {
Function> creationSettings =
context -> {
MockSettings value = settingsFactory.apply(context);
if (!MockSettingsImpl.class.isInstance(value)) {
throw new IllegalArgumentException(
"Unexpected implementation of '"
+ value.getClass().getCanonicalName()
+ "'\n"
+ "At the moment, you cannot provide your own implementations of that class.");
}
MockSettingsImpl impl = MockSettingsImpl.class.cast(value);
String mockMaker = impl.getMockMaker();
if (mockMaker != null) {
throw new IllegalArgumentException(
"Unexpected MockMaker '"
+ mockMaker
+ "'\n"
+ "At the moment, you cannot override the MockMaker for construction mocks.");
}
return impl.build(typeToMock);
};
MockMaker.ConstructionMockControl control =
createConstructionMock(typeToMock, creationSettings, mockInitializer);
control.enable();
return new MockedConstructionImpl<>(control);
}
public OngoingStubbing when(T methodCall) {
MockingProgress mockingProgress = mockingProgress();
mockingProgress.stubbingStarted();
@SuppressWarnings("unchecked")
OngoingStubbing stubbing = (OngoingStubbing) mockingProgress.pullOngoingStubbing();
if (stubbing == null) {
mockingProgress.reset();
throw missingMethodInvocation();
}
return stubbing;
}
public T verify(T mock, VerificationMode mode) {
if (mock == null) {
throw nullPassedToVerify();
}
MockingDetails mockingDetails = mockingDetails(mock);
if (!mockingDetails.isMock()) {
throw notAMockPassedToVerify(mock.getClass());
}
assertNotStubOnlyMock(mock);
MockHandler handler = mockingDetails.getMockHandler();
mock =
(T)
VerificationStartedNotifier.notifyVerificationStarted(
handler.getMockSettings().getVerificationStartedListeners(),
mockingDetails);
MockingProgress mockingProgress = mockingProgress();
VerificationMode actualMode = mockingProgress.maybeVerifyLazily(mode);
mockingProgress.verificationStarted(
new MockAwareVerificationMode(
mock, actualMode, mockingProgress.verificationListeners()));
return mock;
}
public void reset(T... mocks) {
MockingProgress mockingProgress = mockingProgress();
mockingProgress.validateState();
mockingProgress.reset();
mockingProgress.resetOngoingStubbing();
for (T m : mocks) {
resetMock(m);
}
}
public void clearInvocations(T... mocks) {
MockingProgress mockingProgress = mockingProgress();
mockingProgress.validateState();
mockingProgress.reset();
mockingProgress.resetOngoingStubbing();
for (T m : mocks) {
getInvocationContainer(m).clearInvocations();
}
}
public void verifyNoMoreInteractions(Object... mocks) {
assertMocksNotEmpty(mocks);
mockingProgress().validateState();
for (Object mock : mocks) {
try {
if (mock == null) {
throw nullPassedToVerifyNoMoreInteractions();
}
InvocationContainerImpl invocations = getInvocationContainer(mock);
assertNotStubOnlyMock(mock);
VerificationDataImpl data = new VerificationDataImpl(invocations, null);
noMoreInteractions().verify(data);
} catch (NotAMockException e) {
throw notAMockPassedToVerifyNoMoreInteractions();
}
}
}
public void verifyNoInteractions(Object... mocks) {
assertMocksNotEmpty(mocks);
mockingProgress().validateState();
for (Object mock : mocks) {
try {
if (mock == null) {
throw nullPassedToVerifyNoMoreInteractions();
}
InvocationContainerImpl invocations = getInvocationContainer(mock);
assertNotStubOnlyMock(mock);
VerificationDataImpl data = new VerificationDataImpl(invocations, null);
noInteractions().verify(data);
} catch (NotAMockException e) {
throw notAMockPassedToVerifyNoMoreInteractions();
}
}
}
public void verifyNoMoreInteractionsInOrder(List