Package org.mockito.internal.creation

Class MockSettingsImpl<T>

java.lang.Object
org.mockito.internal.creation.settings.CreationSettings<T>
org.mockito.internal.creation.MockSettingsImpl<T>
All Implemented Interfaces:
Serializable, MockCreationSettings<T>, MockSettings
public class MockSettingsImpl<T> extends CreationSettings<T> implements MockSettings, MockCreationSettings<T>
See Also:

  • Constructor Details

    • MockSettingsImpl

      public MockSettingsImpl()

  • Method Details

    • serializable

      public MockSettings serializable()
      Description copied from interface: MockSettings
      Configures the mock to be serializable. With this feature you can use a mock in a place that requires dependencies to be serializable.

      WARNING: 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());
      Specified by:
      serializable in interface MockSettings
      Returns:
      settings instance so that you can fluently specify other settings

    • serializable

      public MockSettings serializable(SerializableMode mode)
      Description copied from interface: MockSettings
      Configures the mock to be serializable with a specific serializable mode. With this feature you can use a mock in a place that requires dependencies to be serializable.

      WARNING: 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));
      Specified by:
      serializable in interface MockSettings
      Parameters:
      mode - serialization mode
      Returns:
      settings instance so that you can fluently specify other settings

    • extraInterfaces

      public MockSettings extraInterfaces(Class<?>... extraInterfaces)
      Description copied from interface: MockSettings
      Specifies extra interfaces the mock should implement. Might be useful for legacy code or some corner cases.

      This mysterious feature should be used very occasionally. The object under test should know exactly its collaborators and dependencies. If you happen to use it often than please make sure you are really producing simple, clean and 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;
      Specified by:
      extraInterfaces in interface MockSettings
      Parameters:
      extraInterfaces - extra interfaces the mock should implement.
      Returns:
      settings instance so that you can fluently specify other settings

    • getMockName

      public MockName getMockName()
      Description copied from interface: MockCreationSettings
      the name of this mock, as printed on verification errors; see MockSettings.name(java.lang.String).
      Specified by:
      getMockName in interface MockCreationSettings<T>
      Overrides:
      getMockName in class CreationSettings<T>

    • getExtraInterfaces

      public Set<Class<?>> getExtraInterfaces()
      Description copied from interface: MockCreationSettings
      the extra interfaces the mock object should implement.
      Specified by:
      getExtraInterfaces in interface MockCreationSettings<T>
      Overrides:
      getExtraInterfaces in class CreationSettings<T>

    • getSpiedInstance

      public Object getSpiedInstance()
      Description copied from interface: MockCreationSettings
      the spied instance - needed for spies.
      Specified by:
      getSpiedInstance in interface MockCreationSettings<T>
      Overrides:
      getSpiedInstance in class CreationSettings<T>

    • name

      public MockSettings name(String name)
      Description copied from interface: MockSettings
      Specifies mock name. Naming mocks can be helpful for debugging - the name is used in all verification errors.

      Beware 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");
      Specified by:
      name in interface MockSettings
      Parameters:
      name - the name of the mock, later used in all verification errors
      Returns:
      settings instance so that you can fluently specify other settings

    • spiedInstance

      public MockSettings spiedInstance(Object spiedInstance)
      Description copied from interface: MockSettings
      Specifies the instance to spy on. Makes sense only for spies/partial mocks. Sets the instance that will be spied. Actually copies the internal fields of the passed instance to the mock.

      As 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 and 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);
      About stubbing for a partial mock, as it is a spy it will always call the real method, unless you use the 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);
      Specified by:
      spiedInstance in interface MockSettings
      Parameters:
      spiedInstance - to spy on
      Returns:
      settings instance so that you can fluently specify other settings

    • defaultAnswer

      public MockSettings defaultAnswer(Answer defaultAnswer)
      Description copied from interface: MockSettings
      Specifies default answers to interactions. It's quite advanced feature, and typically you don't need it to write decent tests. However, it can be helpful when working with legacy systems.

      It 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());
      Specified by:
      defaultAnswer in interface MockSettings
      Parameters:
      defaultAnswer - default answer to be used by mock when not stubbed
      Returns:
      settings instance so that you can fluently specify other settings

    • getDefaultAnswer

      public Answer<Object> getDefaultAnswer()
      Description copied from interface: MockCreationSettings
      the default answer for this mock, see MockSettings.defaultAnswer(org.mockito.stubbing.Answer).
      Specified by:
      getDefaultAnswer in interface MockCreationSettings<T>
      Overrides:
      getDefaultAnswer in class CreationSettings<T>

    • stubOnly

      public MockSettingsImpl<T> stubOnly()
      Description copied from interface: MockSettings
      A stub-only mock does not record method invocations, thus saving memory but disallowing verification of invocations.

      Example: 

      
 List stubOnly = mock(List.class, withSettings().stubOnly());
      Specified by:
      stubOnly in interface MockSettings
      Returns:
      settings instance so that you can fluently specify other settings

    • useConstructor

      public MockSettings useConstructor(Object... constructorArgs)
      Description copied from interface: MockSettings
      Mockito attempts to use constructor when creating instance of the mock. This is particularly useful for spying on abstract classes. See also Mockito.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));
      Specified by:
      useConstructor in interface MockSettings
      Parameters:
      constructorArgs - The arguments to pass to the constructor. Not passing any arguments means that a parameter-less constructor will be called
      Returns:
      settings instance so that you can fluently specify other settings

    • outerInstance

      public MockSettings outerInstance(Object outerClassInstance)
      Description copied from interface: MockSettings
      Makes it possible to mock non-static inner classes in conjunction with MockSettings.useConstructor(Object...).

      Example: 

      
 InnerClass mock = mock(InnerClass.class, withSettings()
   .useConstructor().outerInstance(outerInstance).defaultAnswer(CALLS_REAL_METHODS));
      Specified by:
      outerInstance in interface MockSettings
      Returns:
      settings instance so that you can fluently specify other settings

    • withoutAnnotations

      public MockSettings withoutAnnotations()
      Description copied from interface: MockSettings
      By default, Mockito makes an attempt to preserve all annotation metadata on the mocked type and its methods to mirror the mocked type as closely as possible. If this is not desired, this option can be used to disable this behavior.
      Specified by:
      withoutAnnotations in interface MockSettings
      Returns:
      settings instance so that you can fluently specify other settings

    • isUsingConstructor

      public boolean isUsingConstructor()
      Description copied from interface: MockCreationSettings
      Informs whether the mock instance should be created via constructor
      Specified by:
      isUsingConstructor in interface MockCreationSettings<T>
      Overrides:
      isUsingConstructor in class CreationSettings<T>

    • getOuterClassInstance

      public Object getOuterClassInstance()
      Description copied from interface: MockCreationSettings
      Used when mocking non-static inner classes in conjunction with MockCreationSettings.isUsingConstructor()
      Specified by:
      getOuterClassInstance in interface MockCreationSettings<T>
      Overrides:
      getOuterClassInstance in class CreationSettings<T>
      Returns:
      the outer class instance used for creation of the mock object via the constructor.

    • getConstructorArgs

      public Object[] getConstructorArgs()
      Description copied from interface: MockCreationSettings
      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.
      Specified by:
      getConstructorArgs in interface MockCreationSettings<T>
      Overrides:
      getConstructorArgs in class CreationSettings<T>
      Returns:
      An array of arguments that are passed to the mocked object's constructor. If MockCreationSettings.getOuterClassInstance() is available, it is prepended to the passed arguments.

    • isStubOnly

      public boolean isStubOnly()
      Description copied from interface: MockCreationSettings
      Whether the mock is only for stubbing, i.e. does not remember parameters on its invocation and therefore cannot be used for verification
      Specified by:
      isStubOnly in interface MockCreationSettings<T>
      Overrides:
      isStubOnly in class CreationSettings<T>

    • verboseLogging

      public MockSettings verboseLogging()
      Description copied from interface: MockSettings
      Enables real-time logging of method invocations on this mock. Can be used during test debugging in order to find wrong interactions with this mock.

      Invocations 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());
      Specified by:
      verboseLogging in interface MockSettings
      Returns:
      settings instance so that you can fluently specify other settings

    • invocationListeners

      public MockSettings invocationListeners(InvocationListener... listeners)
      Description copied from interface: MockSettings
      Registers a listener for method invocations on this mock. The listener is notified every time a method on this mock is called.

      Multiple 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()));
      See the listener interface for more details.
      Specified by:
      invocationListeners in interface MockSettings
      Parameters:
      listeners - The invocation listeners to add. May not be null.
      Returns:
      settings instance so that you can fluently specify other settings

    • stubbingLookupListeners

      public MockSettings stubbingLookupListeners(StubbingLookupListener... listeners)
      Description copied from interface: MockSettings
      Add stubbing lookup listener to the mock object. Multiple listeners may be added, and they will be notified in an orderly fashion. For use cases and more info see StubbingLookupListener. Example: 
      
  List mockWithListener = mock(List.class, withSettings().stubbingLookupListeners(new YourStubbingLookupListener()));
      Specified by:
      stubbingLookupListeners in interface MockSettings
      Parameters:
      listeners - The stubbing lookup listeners to add. May not be null.
      Returns:
      settings instance so that you can fluently specify other settings

    • verificationStartedListeners

      public MockSettings verificationStartedListeners(VerificationStartedListener... listeners)
      Description copied from interface: MockSettings
      Registers a listener(s) that will be notified when user starts verification. See VerificationStartedListener 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.

      Specified by:
      verificationStartedListeners in interface MockSettings
      Parameters:
      listeners - to be notified when user starts verification.
      Returns:
      settings instance so that you can fluently specify other settings

    • hasInvocationListeners

      public boolean hasInvocationListeners()

    • getTypeToMock

      public Class<T> getTypeToMock()
      Description copied from interface: MockCreationSettings
      Mocked type. An interface or class the mock should implement / extend.
      Specified by:
      getTypeToMock in interface MockCreationSettings<T>
      Overrides:
      getTypeToMock in class CreationSettings<T>

    • build

      public <T2> MockCreationSettings<T2> build(Class<T2> typeToMock)
      Description copied from interface: MockSettings
      Creates immutable view of mock settings used later by Mockito. Framework integrators can use this method to create instances of creation settings and use them in advanced use cases, for example to create invocations with InvocationFactory, or to implement custom MockHandler. Since MockCreationSettings is NotExtensible, Mockito public API needs a creation method for this type.
      Specified by:
      build in interface MockSettings
      Type Parameters:
      T2 - type to mock
      Parameters:
      typeToMock - class to mock
      Returns:
      immutable view of mock settings

    • buildStatic

      public <T2> MockCreationSettings<T2> buildStatic(Class<T2> classToMock)
      Description copied from interface: MockSettings
      Creates immutable view of mock settings used later by Mockito, for use within a static mocking. Framework integrators can use this method to create instances of creation settings and use them in advanced use cases, for example to create invocations with InvocationFactory, or to implement custom MockHandler. Since MockCreationSettings is NotExtensible, Mockito public API needs a creation method for this type.
      Specified by:
      buildStatic in interface MockSettings
      Type Parameters:
      T2 - type to mock
      Parameters:
      classToMock - class to mock
      Returns:
      immutable view of mock settings

    • lenient

      public MockSettings lenient()
      Specified by:
      lenient in interface MockSettings

    • strictness

      public MockSettings strictness(Strictness strictness)
      Description copied from interface: MockSettings
      Specifies strictness level for the mock. The default strictness level is determined by the rule/runner used. If you are using no rule/runner, the default strictness level is LENIENT 
      
   Foo defaultStrictMock = mock(Foo.class);
   Foo explicitStrictMock = mock(Foo.class, withSettings().strictness(Strictness.STRICT_STUBS));
   Foo lenientMock = mock(Foo.class, withSettings().strictness(Strictness.LENIENT));
      Specified by:
      strictness in interface MockSettings
      Parameters:
      strictness - the strictness level to set on mock
      Returns:
      settings instance so that you can fluently specify other settings

    • mockMaker

      public MockSettings mockMaker(String mockMaker)
      Description copied from interface: MockSettings
      Specifies the MockMaker for the mock. The default depends on your project as described in the class documentation of MockMaker. You should usually use the default, this option primarily exists to ease migrations. You may specify either one of the constants from MockMakers, 
           Object mock = Mockito.mock(Object.class, Mockito.withSettings()
             .mockMaker(MockMakers.INLINE));
      or the binary name of a class which implements the MockMaker interface. 
           Object mock = Mockito.mock(Object.class, Mockito.withSettings()
             .mockMaker("org.awesome.mockito.AwesomeMockMaker"));
      Specified by:
      mockMaker in interface MockSettings
      Parameters:
      mockMaker - the MockMaker to use for the mock
      Returns:
      settings instance so that you can fluently specify other settings

    • genericTypeToMock

      public MockSettings genericTypeToMock(Type genericType)
      Description copied from interface: MockSettings
      Specifies the generic type of the mock, preserving the information lost to Java type erasure.
      Specified by:
      genericTypeToMock in interface MockSettings
      Parameters:
      genericType -
      Returns: