public abstract class BaseStubbing<T> extends java.lang.Object implements OngoingStubbing<T>
Modifier and Type | Field and Description |
---|---|
private java.lang.Object |
strongMockRef |
Constructor and Description |
---|
BaseStubbing(java.lang.Object mock) |
Modifier and Type | Method and Description |
---|---|
<M> M |
getMock()
Returns the mock that was used for this stub.
|
OngoingStubbing<T> |
then(Answer<?> answer)
Sets a generic Answer for the method.
|
OngoingStubbing<T> |
thenCallRealMethod()
Sets the real implementation to be called when the method is called on a mock object.
|
OngoingStubbing<T> |
thenReturn(T value)
Sets a return value to be returned when the method is called.
|
OngoingStubbing<T> |
thenReturn(T value,
T... values)
Sets consecutive return values to be returned when the method is called.
|
OngoingStubbing<T> |
thenThrow(java.lang.Class<? extends java.lang.Throwable> throwableType)
Sets a Throwable type to be thrown when the method is called.
|
OngoingStubbing<T> |
thenThrow(java.lang.Class<? extends java.lang.Throwable> toBeThrown,
java.lang.Class<? extends java.lang.Throwable>... nextToBeThrown)
Sets Throwable classes to be thrown when the method is called.
|
OngoingStubbing<T> |
thenThrow(java.lang.Throwable... throwables)
Sets Throwable objects to be thrown when the method is called.
|
private OngoingStubbing<T> |
thenThrow(java.lang.Throwable throwable) |
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
thenAnswer
public OngoingStubbing<T> then(Answer<?> answer)
OngoingStubbing
OngoingStubbing.thenAnswer(Answer)
. This alias allows
more readable tests on occasion, for example:
//using 'then' alias:
when(mock.foo()).then(returnCoolValue());
//versus good old 'thenAnswer:
when(mock.foo()).thenAnswer(byReturningCoolValue());
then
in interface OngoingStubbing<T>
answer
- the custom answer to execute.OngoingStubbing.thenAnswer(Answer)
public OngoingStubbing<T> thenReturn(T value)
OngoingStubbing
when(mock.someMethod()).thenReturn(10);
See examples in javadoc for Mockito.when(T)
thenReturn
in interface OngoingStubbing<T>
value
- return valuepublic OngoingStubbing<T> thenReturn(T value, T... values)
OngoingStubbing
when(mock.someMethod()).thenReturn(1, 2, 3);
Last return value in the sequence (in example: 3) determines the behavior of further consecutive calls.
See examples in javadoc for Mockito.when(T)
thenReturn
in interface OngoingStubbing<T>
value
- first return valuevalues
- next return valuesprivate OngoingStubbing<T> thenThrow(java.lang.Throwable throwable)
public OngoingStubbing<T> thenThrow(java.lang.Throwable... throwables)
OngoingStubbing
when(mock.someMethod()).thenThrow(new RuntimeException());
If throwables contain a checked exception then it has to
match one of the checked exceptions of method signature.
You can specify throwables to be thrown for consecutive calls. In that case the last throwable determines the behavior of further consecutive calls.
If throwable is null then exception will be thrown.
See examples in javadoc for Mockito.when(T)
thenThrow
in interface OngoingStubbing<T>
throwables
- to be thrown on method invocationpublic OngoingStubbing<T> thenThrow(java.lang.Class<? extends java.lang.Throwable> throwableType)
OngoingStubbing
when(mock.someMethod()).thenThrow(RuntimeException.class);
If the throwable class is a checked exception then it has to match one of the checked exceptions of the stubbed method signature.
If throwable is null then exception will be thrown.
See examples in javadoc for Mockito.when(T)
Note depending on the JVM, stack trace information may not be available in
the generated throwable instance. If you require stack trace information,
use OngoingStubbing.thenThrow(Throwable...)
instead.
thenThrow
in interface OngoingStubbing<T>
throwableType
- to be thrown on method invocationpublic OngoingStubbing<T> thenThrow(java.lang.Class<? extends java.lang.Throwable> toBeThrown, java.lang.Class<? extends java.lang.Throwable>... nextToBeThrown)
OngoingStubbing
when(mock.someMethod()).thenThrow(RuntimeException.class);
Each throwable class will be instantiated for each method invocation.
If throwableTypes
contain a checked exception then it has to
match one of the checked exceptions of method signature.
You can specify throwableTypes
to be thrown for consecutive calls.
In that case the last throwable determines the behavior of further consecutive calls.
If throwable is null then exception will be thrown.
See examples in javadoc for Mockito.when(T)
Note since JDK 7, invoking this method will raise a compiler warning "possible heap pollution",
this API is safe to use. If you don't want to see this warning it is possible to chain OngoingStubbing.thenThrow(Class)
Note depending on the JVM, stack trace information may not be available in
the generated throwable instance. If you require stack trace information,
use OngoingStubbing.thenThrow(Throwable...)
instead.
thenThrow
in interface OngoingStubbing<T>
toBeThrown
- to be thrown on method invocationnextToBeThrown
- next to be thrown on method invocationpublic OngoingStubbing<T> thenCallRealMethod()
OngoingStubbing
As usual you are going to read the partial mock warning: Object oriented programming is more less 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.
// someMethod() must be safe (e.g. doesn't throw, doesn't have dependencies to the object state, etc.)
// if it isn't safe then you will have trouble stubbing it using this api. Use Mockito.doCallRealMethod() instead.
when(mock.someMethod()).thenCallRealMethod();
// calls real method:
mock.someMethod();
See also javadoc Mockito.spy(Object)
to find out more about partial mocks.
Mockito.spy() is a recommended way of creating partial mocks.
The reason is it guarantees real methods are called against correctly constructed object because you're responsible for constructing the object passed to spy() method.
See examples in javadoc for Mockito.when(T)
thenCallRealMethod
in interface OngoingStubbing<T>
public <M> M getMock()
OngoingStubbing
It allows to create a stub in one line of code. This can be helpful to keep test code clean. For example, some boring stub can be created & stubbed at field initialization in a test:
public class CarTest {
Car boringStubbedCar = when(mock(Car.class).shiftGear()).thenThrow(EngineNotStarted.class).getMock();
@Test public void should... {}
getMock
in interface OngoingStubbing<T>
M
- The mock type given by the variable type.