Unit testing a class with autowired notation using Junit and EasyMock?

Question

I am trying to write a Unit test for a class that has several of its fields marked @Autowired. Given the fact that Spring is automatically resolving the concrete implementations for these fields, I am having a hard time figuring out how to plug my Mock objects(created via EasyMock) as the dependencies during the test-run. Using @Autowired in the class means lack of setters in that class. Is there a way for me to plug my mock objects in without creating additional setters in class?

Here's an example of what I am trying to accomplish:

public class SomeClassUnderTest implements SomeOtherClass {
    
    @Autowired
    private SomeType someType;
    
    @Autowired
    private SomeOtherType someOtherType;
    
    @Override
    public SomeReturnType someMethodIWouldLikeToTest(){
    //Uses someType and someOtherType and returns SomeReturnType
    }
    
}

Here's how I am crafting my Test class before I hit the wall:

public class MyTestClassForSomeClassUnderTest{
  private SomeType someType;
  private SomeOtherType someOtherType;
  
  @Before
  public void testSetUp(){
    SomeClassUnderTest someClassToTest = new SomeClassUnderTest();
    someType = EasyMock.createMock(SomeType.class);
    someOtherType = EasyMock.createMock(SomeOtherType.class);
    //How to set dependencies????
  }

  @Test
  public void TestSomeMethodIWouldLikeToTest(){
    //??????
  } 

}

It will be great to get a push in the right direction.

Thanks

score 34 · Accepted Answer · edited Aug 23 '13 at 10:26

34

You can reflectively inject dependencies directly into the field using ReflectionTestUtils, e.g.

ReflectionTestUtils.setField( testInstance, "fieldName", fieldValue );

Some would argue that it's preferable to add a package-visible setter method to the class anyway, used solely by the tests. Alternatively, use autowired constructors, rather than autowired fields, and inject the test dependencies into that.

edited Aug 23 '13 at 10:26

Alex

855
7
21

answered Mar 21 '12 at 15:42

skaffman

398,947
96
818
769

1

http://stackoverflow.com/questions/16426323/injecting-into-autowired-variable-during-testing – Dan Feb 13 '15 at 00:17
1

EasyMock supports since the version 3.2 similar annotations to Mockito for mock injection. See my answer. – krm Dec 08 '15 at 17:13
1

Downvoting this answer which shouldn't be the accepted one nowadays (or it should be updated). As @krm said, ``@TestSubject`` and ``@Mock`` annotations should be used. – fbastien Dec 03 '20 at 22:59

score 6 · Answer 2 · answered Mar 21 '12 at 16:42

Although it is possible to set these fields via reflection, doing so will prevent your development tools from finding usages of these fields, and make it harder for you to refactor SomeClassToTest in the future.

It would be better to add public setters for these fields, and place the @Autowired annotations on these instead. Not only does this avoid reflection, but it also clarifies the external interface of the class and ensures that your unit test uses just this interface. I see that SomeClassToTest already implements the SomeOtherClass interface, and I assume that clients of SomeClassToTest only use this interface, so there is little danger in making the setters on SomeClassToTest public.

Better still, use constructor injection and make the fields final. You can still use @Autowired on the constructor arguments.

krm · Answer 3 · 2016-05-27T13:19:39.293

I do not recommend the answer which had been accepted, i.e. using reflection on your own (without a mocking framework).

Since the version 3.2 of EasyMock you can use annotations in order to define the mocks and inject them into the class under test. A full description how to do it can be found in the official documentation of EasyMock: http://easymock.org/user-guide.html#mocking-annotations

Here's an example from the above-mentioned site:

import static org.easymock.EasyMock.*;
import org.easymock.EasyMockRunner;
import org.easymock.TestSubject;
import org.easymock.Mock;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(EasyMockRunner.class)
public class ExampleTest {

  @TestSubject
  private ClassUnderTest classUnderTest = new ClassUnderTest(); // 2

  @Mock
  private Collaborator mock; // 1

  @Test
  public void testRemoveNonExistingDocument() {
    replay(mock);
    classUnderTest.removeDocument("Does not exist");
  }
}

Unit testing a class with autowired notation using Junit and EasyMock?

3 Answers3

Linked