Java：当该字段未公开时，如何模拟字段的方法？

Question

I'm using Java 6, JUnit 4.8.1, and writing a console application. My application has a member field that isn't exposed …

public class MyApp { 
    ...
    private OpportunitiesService m_oppsSvc;

    private void initServices() { 
        …
        m_oppsSvc = new OpportunitiesServiceImpl(…);
    }
    ...
}

I want to mock a behavior such that whenever one method from my service is called, (eg m_oppsSvc.getResults() ), the same result is always returned. How do I do that? There's no setter method for the field. I'm currently working with Mockito 1.8.4. Is it possible to do this with Mockito or some other mock framework?

Answer 1

This is what you want:

@RunWith(MockitoJUnitRunner.class)
public class MyAppTest { 

    @Mock private OpportunitiesService mocked_m_oppsSvc;
    @InjectMocks MyApp myApp;

    @Test public void when_MyApp_uses_OpportunititesService_then_verify_something() { 
        // given
        given( mocked_m_oppsSvc.whatever()).willReturn(...);

        // when
        myApp.isUsingTheOpportunitiesService(...);

        // then
        verify...
        assertThat...
    }
}

Using: Mockito 1.9.0 , BDD style , FEST-Assert AssertJ .

Hope that helps :)

Answer 2

Given that you're already using mockito, why not just use reflection:

@RunWith(MockitoJUnitRunner.class)
public class MyApp { 

    @Mock
    private OpportunitiesService m_oppsSvc;

    private MyApp myApp;


    @Before
    public void before() throws Exception {
       myApp = new MyApp();
       Field f = MyApp.class.getDeclaredField("m_oppsSvc");
       f.setAccessible(true);
       f.set(myApp, m_oppsSvc);
    }
}

It's a bit ugly, but it will do the trick. Note that this may not be the most efficient way to do it with Mockito, but it will work.

There's also Powermock which should allow you to do this as well using the Whitebox class. I won't get into the whole details of Powermock but here's the call to inject the private field value, which should be a mock object:

Whitebox.setInternalState(myApp, "m_oppsSvc", m_oppsSvc);

Answer 3

You should consider attempts to mock a private field a smell . That is, a sign that either what you're trying to do is either incorrect or that your code is currently structured incorrectly. You should only need to mock public methods or injected dependencies

In the code you've given you should consider injecting OpportunitiesService as follows:

public class MyApp { 
    ...
    private OpportunitiesService m_oppsSvc;

    public MyApp(OpportunitiesService oppsSvc) {
        this.m_oppsSvc = oppsSvc;
    }
    ...
}

In your test you can then inject a mock as follows:

OpportunitiesService mockOpportunitiesService =
    Mockito.mock(OpportunitiesService.class);
Mockit.when(mockOpportunitiesService.someMethod()).thenReturn(someValue);
MyApp app = new MyApp(mockOpportunitiesService);

Answer 4

You can easily do it with JMockit:

public class MyAppTest
{
    @Tested MyApp myApp;

    @Test
    public testSomething(final @Capturing OpportunitiesService mockService)
    {
        new NonStrictExpectations() {{
            mockService.getResults(); result = asList("a", "b", "C");
            // record other expectations, if needed
        }};

        myApp.whateverMethodIWantToTest();

        new Verifications() {{
            mockService.doSomething(anyInt);
            // verify other expectations, if needed
        }};
    }
}

Even though the implementation class OpportunitiesServiceImpl isn't mentioned in test code, its instances (any number of them) will still get properly mocked.

Answer 5

Generally you should use dependency injection and pass the mock object (of type OppportunitiesServiceImpl) in via the constructor, a separate setter or directly to the method (getResults). You might need to extract an interface for OpportunitiesServiceImpl first.

Answer 6

Usually, this is solved through the use of dependency injection. In regular (production) mode, your dependency injection container (eg Spring or Guice) will inject an instance of OpportunitiesService into MyApp through your constructor or through a setter.

Then, when you're testing you can "inject" a mock instance manually using the same setter or constructor argument.

Instead of doing

m_oppsSvc = new OpportunitiesServiceImpl(…);

Try Passing OpportunitesService in through MyApp 's constructor