क्या EasyMock का उपयोग करके किसी ऑब्जेक्ट को आंशिक रूप से नकल करने का कोई तरीका है?

Question

उदा। के मैं इस वर्ग है मान लीजिए:

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

और मैं Foo.a परीक्षण करना चाहते हैं। मैं Foo.b का नकल करना चाहता हूं, क्योंकि मैं उस विधि को अलग से जांच रहा हूं।

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

मैं जानता हूँ कि मैं अपने ही Foo मेरे लिए बात की इस तरह करने के लिए उपवर्ग लिख सकते हैं: क्या मैं कल्पना कर रहा हूँ कुछ इस तरह है। लेकिन अगर ऐसा नहीं करना है, तो मैं ऐसा नहीं करना चाहता, क्योंकि यह कठिन है यानी स्वचालित होना चाहिए।

Answer 1

मुझे लगता है कि आप EasyMock एक्सटेंशन लाइब्रेरी का उपयोग करके ऐसा कर सकते हैं। आप इस Partial Mocking

Answer 2

में यहां एक साधारण उदाहरण पा सकते हैं मुझे जुनीट 4 में अपग्रेड करने और क्लैसक्स्टेंशन का उपयोग करने का एक तरीका मिलेगा। (वास्तव में, मैं EasyMock के बजाय Mockito का प्रयोग करेंगे, लेकिन अपने पूरे टेस्ट स्वीट पुनर्लेखन नहीं करते हैं।) आप नहीं है, तो आप हमेशा अपनी खुद की जासूसी thusly बना सकते हैं कर सकते हैं:

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

ओपी दिखाई देता है (?) यह सुझाव देने के लिए कि आंशिक मॉकिंग से उप-वर्गीकरण किसी भी तरह से कठिन या कठिन है। मेरा सुझाव है कि यह पुनर्विचार करने लायक है।

उदाहरण के लिए, परीक्षण कक्षा में:

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

क्या करता है ओ पी राज्यों, सरल लगता है, और कम अन्य समस्याओं से ग्रस्त (पुनः चलाने के लिए/सत्यापित/आदि भूल जाना।), EasyMock का उपयोग करने से।

Answer 4

EasyMock 3.0+ में, आप का उपयोग कर mockbuilder

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