Oggetto Java Mock, senza dipendenza injection

Question

Sono interessato alla creazione di oggetti di simulazione in una suite di test JUnit, tuttavia mi sono imbattuto in strutture di simulazione che utilizzano l'iniezione di dipendenza per iniettare oggetti fittizi. Tuttavia, mi piacerebbe essere in grado di simulare classi/funzioni senza dover iniettare quell'oggetto finto, lungo le linee di @patch() in python.

esempio banale:

//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>); 

Answer 1

È possibile utilizzare Powermock allo strumento della classe in prova per restituire un mock quando new si chiama.

Powermock mock constructor tutorial

il codice sarebbe simile a questa:

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); 


} 

} 

Answer 2

In poche parole, si potrebbe prendere in giro Foo come questo

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

Il problema di questo è però che foo.foo() sarà essenzialmente fare nulla, come non si è definito che cosa #foo() dovrebbe tornare quando chiamiamo la versione derisoria. Utilizzando un esempio più completo che si possa fare qualcosa di simile:

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); 
    } 
}