¿Hay alguna forma de burlarse parcialmente de un objeto usando EasyMock?

Question

P. ej. vamos a decir que tengo esta clase:

public class Foo Implements Fooable { 
    public void a() { 
    // does some stuff 
    bar = b(); 
    // moar coadz 
    } 
    public Bar b() { 
    // blah 
    } 
    // ... 
} 

y quiero probar Foo.a. Quiero simular Foo.b, porque estoy probando ese método por separado. Lo que estoy imaginando es algo como esto:

public class FooTest extends TestCase { 
    public void testA() { 
    Fooable foo = createPartialMock(
     Fooable.class, // like with createMock 
     Foo // class where non-mocked method implementations live 
    ); 

    // Foo's implementation of b is not used. 
    // Rather, it is replaced with a dummy implementation 
    // that records calls that are supposed to be made; 
    // and returns a hard coded value (i.e. new Bar()). 
    expect(foo.b()).andReturn(new Bar()); 

    // The rest is the same as with createMock: 
    // 1. Stop recording expected calls. 
    // 2. Run code under test. 
    // 3. Verify that recorded calls were made. 
    replay(foo); 
    foo.a(); 
    verify(foo); 
    } 
} 

sé que puedo escribir mi propio Foo subclase de hacer este tipo de cosas para mí. Pero no quiero hacer eso si no es necesario, porque es tedioso, es decir, debería ser automático.

Answer 1

Supongo que puede hacerlo utilizando la biblioteca de extensiones EasyMock. Puede encontrar un ejemplo simple aquí en este Partial Mocking

Answer 2

Encontraría una forma de actualizar a JUnit 4, y usar classextensions. (En realidad, me gustaría utilizar Mockito en lugar de EasyMock, pero no vamos a reescribir su conjunto de pruebas de conjunto.) Si no puede, entonces siempre se puede crear su propio espía así: aparece

public class FooTest extends TestCase { 
    public static class FooSpy extends Foo { 
     private final Fooable mockFoo; 

     FooSpy(Fooable mockFoo) { 
      this.mockFoo = mockFoo; 
     } 

     public Bar b() { 
      return mockFoo.b(); 
     } 
    } 

    public void testA() { 
     Fooable mockFoo = createMock(Foo.class); 
     Fooable fooSpy = new FooSpy(mockFoo); 

     // Foo's implementation of b is not used. 
     // Rather, it is replaced with a dummy implementation 
     // that records calls that are supposed to be made; 
     // and returns a hard coded value (i.e. new Bar()). 
     expect(mockFoo.b()).andReturn(new Bar()); 

     // The rest is the same as with createMock: 
     // 1. Stop recording expected calls. 
     // 2. Run code under test. 
     // 3. Verify that recorded calls were made. 
     replay(mockFoo); 
     foo.a(); 
     verify(foo); 
    } 

} 

Answer 3

La OP (?) sugerir que la subclasificación es de alguna manera más difícil o tediosa que la burla parcial. Sugiero que vale la pena repensar eso.

Por ejemplo, en la clase de prueba:

Foo dummyFoo = new Foo() { 
     @Override public Bar b() { return new Bar(); } 
    }; 

hace lo que los estados OP, parece más sencillo, y menos propenso a otros problemas (olvidando a reproducir/verificar/etc.), Que el uso de EasyMock.

Answer 4

En EasyMock 3.0+, puede crear simulacro parcial mediante el mockbuilder

EasyMock.createMockBuilder(class).addMockedMethod("MethodName").createMock();