Mockito, @InjectMocks strange behaviour with final fields
java, mockito, testng
Solution
You are using the `@InjectMocks` for constructor injection. This will work as long as Mockito finds the field not initalized (null). JUnit is creating a new instance of the test class before each test, so JUnit fans (like me) will never face such problem. TestNg is not creating a new instance of test class. It's keeping the state between test methods, so when `MockitoAnnotations.initMocks(this)` is called for the second time, Mockito will find subject field already initialized and will try to use field injection. This on the other turn will work until the field is not final.
Is this is a bug? I believe not - rather a natural consequence of the API design. Some workaround for you would be to add
this.subject = null;
in some `@AfterMethod` method.
Problem
I am seeing behaviour that I believe is a bug. @InjectMocks does not seem to create a new test subject before every test method. Where as @Mock does. In the following example, if Subject.section is final one @Test fails. If its not final both pass. My current workaround is to use @BeforeClass, but this is not ideal. Subject.java: ``` package inject_mocks_test; public class Subject { private final Section section; public Subject(Section section) { this.section = section; } public Section getSection() { return section; } } ``` Section.java: ``` package inject_mocks_test; public class Section {} ``` SubjectTest.java ``` package inject_mocks_test; import org.mockito.InjectMocks; import org.mockito.Mock; import org.mockito.MockitoAnnotations; import org.testng.annotations.BeforeMethod; import org.testng.annotations.Test; import static org.testng.Assert.assertEquals; public class SubjectTest { @Mock Section section; @InjectMocks Subject subject; @BeforeMethod public void setup() { MockitoAnnotations.initMocks(this); } @Test public void test1() { assertEquals(section, subject.getSection()); } @Test public void test2() { assertEquals(section, subject.getSection()); } } ``` Cheers.