Java Mock object, without dependency injection

Question

I am interested in Mocking objects in a JUnit test-suite, however I have only come across mocking frameworks that use dependency injection to inject mock objects. However, I would like to be able to mock classes/functions without having to inject that mock object, along the lines of @patch() in python.

Trivial example:

//dependency injection
public String bar(Foo foo) {
    return foo.foo(); //just pass in mock Foo object
}
//.... onto test code
Foo mockedFoo = <Mocked Foo object>;
String response = bar(mockedFoo);
assertEqual(response, <mockedFoo return value>);


//case I am looking for
public String bar() {
    Foo foo = new Foo(); //how to create mock object here?
    return foo.foo(); //or simply how to mock a single function?
}
//... onto test code
<force the Foo class or foo method to be mocked from here without touching bar() source code>
String response = bar();
assertEqual(response, <mocked response>);

http://stackoverflow.com/questions/10895605/how-to-mock-a-single-method-in-java — kamoor, Dec 19 '14 at 01:08
Use a library, e.g. Mockito. Or in simpler cases, extend `Foo` or even better, implement the same interface as `Foo` to get a simple mock. — mike, Dec 19 '14 at 01:11
Mike, from looking through Mockito, it still appears that dependencies have to be injected. Please see above for edit to increase clarity. — Brent Hronik, Dec 19 '14 at 01:40
@Kamoor1982, the author of that post appears to be asking the opposite of what I am asking. — Brent Hronik, Dec 19 '14 at 01:42

dkatzel · Accepted Answer · 2014-12-20T04:31:54.190

You can use Powermock to instrument the class under test to return a mock when new is called.

Powermock mock constructor tutorial

your code would look like this:

RunWith(PowerMockRunner.class)
@PrepareForTest( Bar.class )
public class BarTest {


@Test
public void test(){
   Foo mockedFoo = createMock(Foo.class);
   //set up mockedFoo here
   ...

   //This will make a call  to new Foo() inside Bar.class
   //return your mock instead of a real new one
   expectNew(Foo.class).andReturn(mockedFoo);

   ...
   replay(mockedFoo, File.class);

   Bar bar = new Bar();
   String response = bar.bar();

   assertEqual(response, <mocked response>);

   verify(mockedFoo, File.class);


}

}

if I am not wrong, expectNew is only implemented for use with EasyMock, not with Mockito. For Mockito, use whenNew instead. — luca.vercelli, Oct 05 '20 at 11:40

score 2 · Answer 2 · answered Dec 19 '14 at 01:24

Simply put, you could mock Foo like this

public String bar() {
    Foo foo = Mockito.mock(Foo.class);
    return foo.foo();
}

The problem with this though is that foo.foo() will essentially do nothing as you haven't defined what #foo() should return when we call the mocked version. Using a more complete example you could do something like this:

class MyTest {

    Foo mockedFoo = Mockito.mock(Foo.class);

    @Before
    public void setUp() throws Exception {
        Mockito.when(mockedFoo.foo()).thenReturn("This is mocked!");
    }

    @Test
    public void testMock() {
        String returnedFoo = mockedFoo.foo();
        Assert.assertEquals("This is mocked!", returnedFoo);
    }
}

Thanks for the suggestion, modified my post to aid in clarity. It appears that this response answers a question a tad different from what I was asking, sorry about. — Brent Hronik, Dec 19 '14 at 01:45

Java Mock object, without dependency injection

2 Answers2

Linked