EasyMock kullanarak bir nesneyi kısmen taşımak için bir yol var mı?

Question

E.g. Diyelim ki bu sınıfı var diyelim:

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

Ve Foo.a test etmek istiyorum. Ben Foo.b alay etmek istiyorum çünkü bu yöntemi ayrı ayrı test ediyorum.

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

Bana göre bu tür bir şey yapmak için kendi Foo alt sınıfını yazabilirsiniz biliyorum: Ne hayal ediyorum böyle bir şeydir. Ama bunu yapmak istemiyorsam yapmak istemiyorum, çünkü sıkıcı çünkü otomatik olmalı.

Answer 1

Bunu EasyMock uzantı kitaplığını kullanarak yapabilirsin. Burada, bu Partial Mocking

Answer 2

'da basit bir örnek bulabilirsiniz JUnit 4'e yükseltmenin ve classextensions kullanmanın bir yolunu bulabilirim. (Aslında, yerine EasyMock ait Mockito kullanabilirsiniz, ancak senin bütün test takımı yeniden yazmak değil izin vermedi.) Eğer, o zaman her zaman thusly kendi casus yaratabilir yapamıyorsanız:

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

OP görünür (?) Alt sınıflamanın bir şekilde kısmi alaydan daha zor ya da sıkıcı olduğunu öne sürmek. Bunu yeniden düşünmeye değer. Test sınıfında Örneğin

:

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

OP devletler, daha basit görünüyor ve diğer en az problemi (./etc/yeniden doğrulamak için unutmak), EasyMock kullanmaktan daha yapar. EasyMock 3.0+ yılında

Answer 4

, sen mockbuilder

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