public class MockSettingsImpl<T> extends CreationSettings<T> implements MockSettings, MockCreationSettings<T>
defaultAnswer, extraInterfaces, invocationListeners, lenient, mockName, name, serializableMode, spiedInstance, stripAnnotations, stubbingLookupListeners, stubOnly, typeToMock, verificationStartedListeners| Constructor and Description |
|---|
MockSettingsImpl() |
| Modifier and Type | Method and Description |
|---|---|
<T> MockCreationSettings<T> |
build(Class<T> typeToMock)
Creates immutable view of mock settings used later by Mockito.
|
MockSettings |
defaultAnswer(Answer defaultAnswer)
Specifies default answers to interactions.
|
MockSettings |
extraInterfaces(Class<?>... extraInterfaces)
Specifies extra interfaces the mock should implement.
|
Object[] |
getConstructorArgs()
Used when arguments should be passed to the mocked object's constructor, regardless of whether these
arguments are supplied directly, or whether they include the outer instance.
|
Answer<Object> |
getDefaultAnswer()
the default answer for this mock, see
MockSettings.defaultAnswer(org.mockito.stubbing.Answer). |
Set<Class<?>> |
getExtraInterfaces()
the extra interfaces the mock object should implement.
|
List<InvocationListener> |
getInvocationListeners()
InvocationListener instances attached to this mock, see MockSettings.invocationListeners(org.mockito.listeners.InvocationListener...). |
MockName |
getMockName()
the name of this mock, as printed on verification errors; see
MockSettings.name(java.lang.String). |
Object |
getOuterClassInstance()
Used when mocking non-static inner classes in conjunction with
MockCreationSettings.isUsingConstructor() |
Object |
getSpiedInstance()
the spied instance - needed for spies.
|
Class<T> |
getTypeToMock()
Mocked type.
|
boolean |
hasInvocationListeners() |
MockSettings |
invocationListeners(InvocationListener... listeners)
Registers a listener for method invocations on this mock.
|
boolean |
isStubOnly()
Whether the mock is only for stubbing, i.e.
|
boolean |
isUsingConstructor()
Informs whether the mock instance should be created via constructor
|
MockSettings |
lenient()
Lenient mocks bypass "strict stubbing" validation (see
Strictness.STRICT_STUBS). |
MockSettings |
name(String name)
Specifies mock name.
|
MockSettings |
outerInstance(Object outerClassInstance)
Makes it possible to mock non-static inner classes in conjunction with
MockSettings.useConstructor(Object...). |
MockSettings |
serializable()
Configures the mock to be serializable.
|
MockSettings |
serializable(SerializableMode mode)
Configures the mock to be serializable with a specific serializable mode.
|
MockSettings |
spiedInstance(Object spiedInstance)
Specifies the instance to spy on.
|
MockSettingsImpl<T> |
stubOnly()
A stub-only mock does not record method
invocations, thus saving memory but
disallowing verification of invocations.
|
MockSettings |
useConstructor(Object... constructorArgs)
Mockito attempts to use constructor when creating instance of the mock.
|
MockSettings |
verboseLogging()
Enables real-time logging of method invocations on this mock.
|
MockSettings |
verificationStartedListeners(VerificationStartedListener... listeners)
Registers a listener(s) that will be notified when user starts verification.
|
MockSettings |
withoutAnnotations()
By default, Mockito makes an attempt to preserve all annotation meta data on the mocked
type and its methods to mirror the mocked type as closely as possible.
|
getName, getSerializableMode, getStubbingLookupListeners, getVerificationStartedListeners, isLenient, isSerializable, isStripAnnotations, setExtraInterfaces, setMockName, setSerializableMode, setTypeToMockclone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitgetSerializableMode, getVerificationStartedListeners, isLenient, isSerializable, isStripAnnotationspublic MockSettings serializable()
MockSettingsWARNING: This should be rarely used in unit testing.
The behaviour was implemented for a specific use case of a BDD spec that had an unreliable external dependency. This was in a web environment and the objects from the external dependency were being serialized to pass between layers.
Example:
List serializableMock = mock(List.class, withSettings().serializable());
serializable in interface MockSettingspublic MockSettings serializable(SerializableMode mode)
MockSettingsWARNING: This should be rarely used in unit testing.
The behaviour was implemented for a specific use case of a BDD spec that had an unreliable external dependency. This was in a web environment and the objects from the external dependency were being serialized to pass between layers.
List serializableMock = mock(List.class, withSettings().serializable(SerializableMode.ACROSS_CLASSLOADERS));
serializable in interface MockSettingsmode - serialization modepublic MockSettings extraInterfaces(Class<?>... extraInterfaces)
MockSettingsThis mysterious feature should be used very occasionally. The object under test should know exactly its collaborators & dependencies. If you happen to use it often than please make sure you are really producing simple, clean & readable code.
Examples:
Foo foo = mock(Foo.class, withSettings().extraInterfaces(Bar.class, Baz.class));
//now, the mock implements extra interfaces, so following casting is possible:
Bar bar = (Bar) foo;
Baz baz = (Baz) foo;
extraInterfaces in interface MockSettingsextraInterfaces - extra interfaces the should implement.public MockName getMockName()
MockCreationSettingsMockSettings.name(java.lang.String).getMockName in interface MockCreationSettings<T>getMockName in class CreationSettings<T>public Set<Class<?>> getExtraInterfaces()
MockCreationSettingsgetExtraInterfaces in interface MockCreationSettings<T>getExtraInterfaces in class CreationSettings<T>public Object getSpiedInstance()
MockCreationSettingsgetSpiedInstance in interface MockCreationSettings<T>getSpiedInstance in class CreationSettings<T>public MockSettings name(String name)
MockSettingsBeware that naming mocks is not a solution for complex code which uses too many mocks or collaborators. If you have too many mocks then refactor the code so that it's easy to test/debug without necessity of naming mocks.
If you use @Mock annotation then you've got naming mocks for free! @Mock uses field name as mock name. Read more.
Examples:
Foo foo = mock(Foo.class, withSettings().name("foo"));
//Below does exactly the same:
Foo foo = mock(Foo.class, "foo");
name in interface MockSettingsname - the name of the mock, later used in all verification errorspublic MockSettings spiedInstance(Object spiedInstance)
MockSettingsAs usual you are going to read the partial mock warning: Object oriented programming is more or less about tackling complexity by dividing the complexity into separate, specific, SRPy objects. How does partial mock fit into this paradigm? Well, it just doesn't... Partial mock usually means that the complexity has been moved to a different method on the same object. In most cases, this is not the way you want to design your application.
However, there are rare cases when partial mocks come handy: dealing with code you cannot change easily (3rd party interfaces, interim refactoring of legacy code etc.) However, I wouldn't use partial mocks for new, test-driven & well-designed code.
Enough warnings about partial mocks, see an example how spiedInstance() works:
Foo foo = mock(Foo.class, withSettings().spiedInstance(fooInstance));
//Below does exactly the same:
Foo foo = spy(fooInstance);
doReturn|Throw|Answer|CallRealMethod stubbing style. Example:
List list = new LinkedList();
List spy = spy(list);
//Impossible: real method is called so spy.get(0) throws IndexOutOfBoundsException (the list is yet empty)
when(spy.get(0)).thenReturn("foo");
//You have to use doReturn() for stubbing
doReturn("foo").when(spy).get(0);
spiedInstance in interface MockSettingsspiedInstance - to spy onpublic MockSettings defaultAnswer(Answer defaultAnswer)
MockSettingsIt is the default answer so it will be used only when you don't stub the method call.
Foo mock = mock(Foo.class, withSettings().defaultAnswer(RETURNS_SMART_NULLS));
Foo mockTwo = mock(Foo.class, withSettings().defaultAnswer(new YourOwnAnswer()));
//Below does exactly the same:
Foo mockTwo = mock(Foo.class, new YourOwnAnswer());
defaultAnswer in interface MockSettingsdefaultAnswer - default answer to be used by mock when not stubbedpublic Answer<Object> getDefaultAnswer()
MockCreationSettingsMockSettings.defaultAnswer(org.mockito.stubbing.Answer).getDefaultAnswer in interface MockCreationSettings<T>getDefaultAnswer in class CreationSettings<T>public MockSettingsImpl<T> stubOnly()
MockSettingsExample:
List stubOnly = mock(List.class, withSettings().stubOnly());
stubOnly in interface MockSettingspublic MockSettings useConstructor(Object... constructorArgs)
MockSettingsMockito.spy(Class).
Example:
//Robust API, via settings builder:
OtherAbstract spy = mock(OtherAbstract.class, withSettings()
.useConstructor().defaultAnswer(CALLS_REAL_METHODS));
//Mocking an abstract class with constructor arguments
SomeAbstract spy = mock(SomeAbstract.class, withSettings()
.useConstructor("arg1", 123).defaultAnswer(CALLS_REAL_METHODS));
//Mocking a non-static inner abstract class:
InnerAbstract spy = mock(InnerAbstract.class, withSettings()
.useConstructor().outerInstance(outerInstance).defaultAnswer(CALLS_REAL_METHODS));
useConstructor in interface MockSettingsconstructorArgs - The arguments to pass to the constructor. Not passing any arguments means that a parameter-less
constructor will be calledpublic MockSettings outerInstance(Object outerClassInstance)
MockSettingsMockSettings.useConstructor(Object...).
Example:
InnerClass mock = mock(InnerClass.class, withSettings()
.useConstructor().outerInstance(outerInstance).defaultAnswer(CALLS_REAL_METHODS));
outerInstance in interface MockSettingspublic MockSettings withoutAnnotations()
MockSettingswithoutAnnotations in interface MockSettingspublic boolean isUsingConstructor()
MockCreationSettingsisUsingConstructor in interface MockCreationSettings<T>isUsingConstructor in class CreationSettings<T>public Object getOuterClassInstance()
MockCreationSettingsMockCreationSettings.isUsingConstructor()getOuterClassInstance in interface MockCreationSettings<T>getOuterClassInstance in class CreationSettings<T>public Object[] getConstructorArgs()
MockCreationSettingsgetConstructorArgs in interface MockCreationSettings<T>getConstructorArgs in class CreationSettings<T>MockCreationSettings.getOuterClassInstance() is available, it is prepended to the passed arguments.public boolean isStubOnly()
MockCreationSettingsisStubOnly in interface MockCreationSettings<T>isStubOnly in class CreationSettings<T>public MockSettings verboseLogging()
MockSettingsInvocations are logged as they happen to the standard output stream.
Calling this method multiple times makes no difference.
Example:
List mockWithLogger = mock(List.class, withSettings().verboseLogging());
verboseLogging in interface MockSettingspublic MockSettings invocationListeners(InvocationListener... listeners)
MockSettingsMultiple listeners may be added and they will be notified in the order they were supplied. Example:
List mockWithListener = mock(List.class, withSettings().invocationListeners(new YourInvocationListener()));
listener interface for more details.invocationListeners in interface MockSettingslisteners - The invocation listeners to add. May not be null.public MockSettings verificationStartedListeners(VerificationStartedListener... listeners)
MockSettingsVerificationStartedListener on how such listener can be useful.
When multiple listeners are added, they are notified in order they were supplied.
There is no reason to supply multiple listeners but we wanted to keep the API
simple and consistent with MockSettings.invocationListeners(InvocationListener...).
Throws exception when any of the passed listeners is null or when the entire vararg array is null.
verificationStartedListeners in interface MockSettingslisteners - to be notified when user starts verification.public List<InvocationListener> getInvocationListeners()
MockCreationSettingsInvocationListener instances attached to this mock, see MockSettings.invocationListeners(org.mockito.listeners.InvocationListener...).getInvocationListeners in interface MockCreationSettings<T>getInvocationListeners in class CreationSettings<T>public boolean hasInvocationListeners()
public Class<T> getTypeToMock()
MockCreationSettingsgetTypeToMock in interface MockCreationSettings<T>getTypeToMock in class CreationSettings<T>public <T> MockCreationSettings<T> build(Class<T> typeToMock)
MockSettingsInvocationFactory,
or to implement custom MockHandler.
Since MockCreationSettings is NotExtensible, Mockito public API needs a creation method for this type.build in interface MockSettingsT - type to mocktypeToMock - class to mockpublic MockSettings lenient()
MockSettingsStrictness.STRICT_STUBS).
When mock is declared as lenient none of its stubbings will be checked for potential stubbing problems such as
'unnecessary stubbing' (UnnecessaryStubbingException) or for 'stubbing argument mismatch' PotentialStubbingProblem.
Foo mock = mock(Foo.class, withSettings.lenient());
Mockito.lenient().lenient in interface MockSettingsCopyright © 2024. All rights reserved.