How to mock creation new object inside some service?

Question

I have to test a method inside some class like this:

public class aClassToTest{
  private SomeService someService = new SomeService();

  public String methodToTest(){
  String data = someService.getData();
  //....
 }
}

So, I have mocked SomeService class for returning my mock-object instead of original SomeService-object. I have done it via PowerMockito in every of my @Test method

SomeService someServiceMock = mock(SomeService.class); 
when(someServiceMock.getData().thenReturn(Data myMockedData)
PowerMockito.whenNew(SomeService.class).withAnyArguments().thenReturn(someServiceMock);

And I have this annotation above my Test class:

@PrepareForTest({aClassToTest.class, SomeService.class})

It works fine if there is only one test, but if there is a few tests someServiceMock.getData() returns data from the very first test each time dispite the fact, that i mock it in every test with new data. I've tried to add annotation @PrepareForTest({aClassToTest.class, SomeService.class}) above every @Test method, but now I have an OutOfMemoryError after a few tests, and now it works only if I run whole Test class with all test methods, but if I run test methods separately I have No tests found for given includes error.

I have test class like this:

@RunWith(PowerMock.class)
@PrepareForTest({aClassToTest.class, SomeService.class})
public class TestClass{

private void doMockSomeService(String testData){
  SomeService someServiceMock = mock(SomeService.class); 
  when(someServiceMock.getData().thenReturn(testData);
  PowerMockito.whenNew(SomeService.class).withAnyArguments().thenReturn(someServiceMock);
 }

  @Test
  public void testCase1(){
  String expectedResult = "expectedResult1";
  doMockSomeService("123");
  ClassToTest classToTest = new ClassToTest();
  String result = classToTest.methodToTest();
  assertEquals(result, expectedResult);
  }

 @Test
  public void testCase2(){
  String expectedResult = "expectedResult2";
  doMockSomeService("456");
  ClassToTest classToTest = new ClassToTest();
  String result = classToTest.methodToTest();
  assertEquals(result, expectedResult);
  }
}

In this case, the return value of someService.getData() is always "123".

Answer 1

I don't know why this shouldn't work:

@RunWith(MockitoJUnitRunner.class)
class MyTest {
    @Mock private SomeService service;
    @InjectMocks private aClassToTest;

    @Before
    public void initData() {
        when(service.getData()).thenReturn(data);
    }

    @Test
    public void test() {
        mockData("expected");

        String result = aClassToTest.methodToTest();
        verify(service).getData(); // method was called

        assertEquals("expected", result);
    }

    private void mockData(String str) {
        when(service.getData()).thenReturn(str);
    }
}

Answer 2

Use withNoArguments instead when configuring initialization. Also remove SomeService.class from @PrepareForTest

@RunWith(PowerMockRunner.class)
@PrepareForTest(aClassToTest.class)
public class TestClass {

    private void doMockSomeService(String testData){
        SomeService someServiceMock = PowerMockito.mock(SomeService.class); 
        PowerMockito.when(someServiceMock.getData().thenReturn(testData);
        PowerMockito.whenNew(SomeService.class).withNoArguments()
            .thenReturn(someServiceMock);
    }

    @Test
    public void testCase1() {
        //Arrange
        String expectedResult = "expectedResult1";
        doMockSomeService("123");
        ClassToTest classToTest = new ClassToTest();
        //Act
        String result = classToTest.methodToTest();
        //Assert
        assertEquals(result, expectedResult);
    }

    @Test
    public void testCase2() {
        //Arrange
        String expectedResult = "expectedResult2";
        doMockSomeService("456");
        ClassToTest classToTest = new ClassToTest();
        //Act
        String result = classToTest.methodToTest();
        //Assert
        assertEquals(result, expectedResult);
    }
}

Note that you must prepare the class creating the new instance of SomeService for test, not the SomeService itself.

Reference How to mock construction of new objects

---

Separate to the issues being experienced with powermock, This demonstrates the problem with tightly coupling your code to dependencies that make it difficult to test in isolation.

A more SOLID approach would be to follow the explicit dependency principle using dependency inversion

public class aClassToTest{
    private SomeService someService;

    @Inject    
    public aClassToTest(SomeService someService) {
        this.someService = someService;
    }

    public String methodToTest(){
        String data = someService.getData();
        //....
    }
}

This inverts the creation of the dependency to external of the target class and also states very clearly what is required by the class in order to perform its particular function.

This also allows for easier isolated unit tests on the target subject under test

@RunWith(MockitoJUnitRunner.class)
public class TestClass {

    private someServiceMock doMockSomeService(String testData){
        someServiceMock = mock(SomeService.class); 
        when(someServiceMock.getData().thenReturn(testData);
        return someServiceMock;
    }

    @Test
    public void testCase1() {
        //Arrange
        String expected = "expectedResult1";
        ClassToTest classToTest = new ClassToTest(doMockSomeService("123"));
        //Act
        String actual = classToTest.methodToTest();
        //Assert
        assertEquals(expected, actual);
    }

    @Test
    public void testCase2() {
        //Arrange
        String expected = "expectedResult2";
        ClassToTest classToTest = new ClassToTest(doMockSomeService("456"));
        //Act
        String actual = classToTest.methodToTest();
        //Assert
        assertEquals(expected, actual);
    }
}

In my opinion, just because PowerMock allows us the ability to mock the creation of object within other objects, does not mean that we should be encouraged to design tightly coupled classes that are difficult to maintain and test in isolation.

This answer is also meant to be an alternative to the current approach if a viable solution is not found.

Answer 3

Thank you all. Problem solved by changing the design of a class, that should be tested.