CODEWITHSUNDEEP
javaunit-testingjunitmockingmockito
Gábor Csikós
Gábor Csikós

Reputation: 2927

What is the difference between Mockito.mock(SomeClass) and the @Mock annotation?

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;

Upvotes: 79

Views: 32139

Answers (6)

A. S. Ranjan
A. S. Ranjan

Reputation: 418

In Junit5, use

@ExtendWith(MockitoExtension.class)

Upvotes: -3

saferJo
saferJo

Reputation: 547

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.

Upvotes: 1

Mureinik
Mureinik

Reputation: 311843

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.

Upvotes: 96

Dawood ibn Kareem
Dawood ibn Kareem

Reputation: 79857

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.

Upvotes: 9

Shweta
Shweta

Reputation: 141

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.

Upvotes: 8

geoand
geoand

Reputation: 64039

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

Upvotes: 15

Related Questions