org.mockito.internal.creation
Class MockSettingsImpl

java.lang.Object
  extended by org.mockito.internal.creation.MockSettingsImpl
All Implemented Interfaces:
MockSettings

public class MockSettingsImpl
extends java.lang.Object
implements MockSettings


Constructor Summary
MockSettingsImpl()
           
 
Method Summary
 MockSettings defaultAnswer(Answer defaultAnswer)
          Specifies default answers to interactions.
 MockSettings extraInterfaces(java.lang.Class<?>... extraInterfaces)
          Specifies extra interfaces the mock should implement.
 Answer<java.lang.Object> getDefaultAnswer()
           
 java.lang.Class<?>[] getExtraInterfaces()
           
 java.lang.String getMockName()
           
 java.lang.Object getSpiedInstance()
           
 MockSettings name(java.lang.String name)
          Specifies mock name.
 MockSettings spiedInstance(java.lang.Object spiedInstance)
          Specifies the instance to spy on.
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

MockSettingsImpl

public MockSettingsImpl()
Method Detail

extraInterfaces

public MockSettings extraInterfaces(java.lang.Class<?>... extraInterfaces)
Description copied from interface: MockSettings
Specifies extra interfaces the mock should implement. Might be useful for legacy code or some corner cases. For background, see issue 51 here

This 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;
 

Specified by:
extraInterfaces in interface MockSettings
Parameters:
extraInterfaces - extra interfaces the should implement.
Returns:
settings instance so that you can fluently specify other settings

getMockName

public java.lang.String getMockName()

getExtraInterfaces

public java.lang.Class<?>[] getExtraInterfaces()

getSpiedInstance

public java.lang.Object getSpiedInstance()

name

public MockSettings name(java.lang.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(java.lang.Object spiedInstance)
Description copied from interface: MockSettings
Specifies the instance to spy on. Makes sense only for spies/partial mocks. Sets the real implementation to be called when the method is called on a mock object.

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.

Enough warnings about partial mocks, see an example how spiedInstance() works:

   Foo foo = mock(Foo.class, spiedInstance(fooInstance));
   
   //Below does exactly the same:
   Foo foo = spy(fooInstance);
 

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<java.lang.Object> getDefaultAnswer()