What is the difference between Mockito.mock(SomeCl

问题:

What is the difference between Mockito.mock(Class<T> classToMock) method and the @Mock annotation? Are they the same?

For Example, is this:

private TestClass test = Mockito.mock(TestClass.class);

the same as:

@Mock
private TestClass test;

回答1:

They both achieve the same result. Using an annotation (@Mock) is usually considered "cleaner", as you don't fill up your code with boilerplate assignments that all look the same.

Note that in order to use the @Mock annotation, your test class should be annotated with @RunWith(MockitoJUnitRunner.class) or contain a call to MockitoAnnotations.initMocks(this) in its @Before method.

回答2:

The difference is in the lines of code you need to write :) :) :)

Seriously though, using the annotations has the exact same effect as using the Mockito.mock.

To quote the documentation of MockitoAnnotations the use of annotations has the following benefits:

• Allows shorthand creation of objects required for testing.

• Minimizes repetitive mock creation code.

• Makes the test class more readable.

• Makes the verification error easier to read because field name is
  used to identify the mock.

The javadoc for MockitoAnnotations is here

回答3:

They both are considered same and achieve the same thing but I'd prefer the second one:

@Mock is an annotation which:

• Minimizes repetitive mock creation code.
• Makes the test class more readable.
• Allows shorthand creation of objects required for testing.

回答4:

There are two significant advantages to using the annotation.

• A mock created with @Mock can be injected into the class you're testing, using the @InjectMocks annotation. This is a powerful technique that can make testing significantly easier. It just won't work with mocks created by the mock method.
• If you have any errors involving your mock, the name of the mock will appear in the message. If you've used @Mock, then this name will just be the name of the field. This makes it really easy to find the problem mock.

Of course, in addition to these two important advantages, most people find the @Mock notation much more readable, and it does cut down on the amount of code. I see no reason not to use it.

回答5:

The answer of the question is one big mistake. We just solved some problems caused by Mockito.mock(Your.class) as a field. We had few @Test methods. The 4th method was throwing an exception with 'thenThrow(ex)'. All of the @Test methods after it was failing and the reason was the exception thrown. They were sharing the mocked instance and the 'when' condition. After we changed from

TestClass testInstance = Mockito.mock(TestClass.class);

to

@Mock
TestClass testInstance;

everything started to work as expected. So Mockito.mock is creating a shared mock between the test methods, and @Mock does not.