Wie spottet man eine Methode, die mit einer anderen Methode mit EasyMock aufgerufen wird?

Question

Ich muss eine Methode innerhalb einer void-Methode verspotten.

Hier ist mein Beispielcode:

class MyClass { 

    public MyClass(Session s, Boolean b1, Boolean b2) 

    void myMethod(some paramaters...) { 

     // some code 
     int count= setSize(); 
    } 

    int setSize() { 

     // some calculation.... 
     return size; 
    } 

Jetzt in meinem Test-Klasse Ich möchte setSize() verspotten meinen eigenen Wert sagen 300 zurückzukehren.

Ich habe wie:

MyClass mockclass = createNiceMock(MyClass.class); 
EasyMock.expect(mockimplyZero.setBatchSize()).andReturn(Integer.valueOf(300)); 

mockclass.myMethod(parameters....) 

wenn Anruf myMethod, es ist nicht richtig in das Verfahren geht. Ich denke, es könnte sein EasyMock setzt Standardwerte auf den MyClass Konstruktor. Wie mache ich den Mock richtig?

Es gibt keine Methoden in MyClass außer Konstruktor, myMethod und setSize

Answer 1

Sie können es mit partiellen Spott tun. Hier ist ein Beispiel in der Nähe Ihres Codes.

Zuerst die getestete Klasse. Sie müssen einen Teil davon erstellen. getSize sollte verspottet werden, aber myMethod sollte da die getestete Methode ist.

Außerdem sollten Sie häufig einen Konstruktor aufrufen, um die Klasse korrekt zu initialisieren (ein klassischer Schein wird keinen Konstruktor aufrufen).

class MyClass { 

    private boolean b1; 
    private boolean b2; 

    public MyClass(boolean b1, boolean b2) { 
    this.b1 = b1; 
    this.b2 = b2; 
    } 

    int myMethod() { 
    return getSize(); 
    } 

    int getSize() { 
    return 42; 
    } 

    public boolean getB1() { 
    return b1; 
    } 

    public boolean getB2() { 
    return b2; 
    } 
} 

Der Test wird dann der folgende

import org.junit.Test; 

import static org.easymock.EasyMock.*; 
import static org.junit.Assert.*; 

public class MyClassTest { 

    @Test 
    public void test() { 
    // Create a partial mock by calling its constructor 
    // and only mocking getSize 
    MyClass mock = createMockBuilder(MyClass.class) 
     .withConstructor(true, true) 
     .addMockedMethod("getSize") 
     .createMock(); 

    // Record that getSize should return 8 (instead of 42) 
    expect(mock.getSize()).andReturn(8); 

    // All recording done. So put the mock in replay mode 
    replay(mock); 

    // Then, these assertions are to prove that the partial mock is 
    // actually doing what we expect. This is just to prove my point. Your 
    // actual code will verify that myMethod is doing was is expected 

    // 1. Verify that the constructor was correctly called 
    assertEquals(true, mock.getB1()); 
    assertEquals(true, mock.getB2()); 
    // 2. Verify that getSize was indeed mocked 
    assertEquals(8, mock.myMethod()); 

    // Check everything expected was indeed called 
    verify(mock); 
    } 
} 

Job gemacht. Beachten Sie, dass dies nicht unbedingt ein Zeichen für schlechtes Design ist. Ich benutze es häufig beim Testen der Template method pattern.

Answer 2

Sie sollten nicht ein Methode spotten, während eine andere Methode auf der gleichen Klasse zu testen. Sie könnten das theoretisch tun (zum Beispiel mit einem Mokito spy ).

In diesem Sinne nähern Sie sich dies auf einer falschen Ebene: Sie sollten sich eigentlich nicht darum kümmern, welche anderen Methoden Ihre zu testende Methode innerhalb Ihrer zu testenden Klasse aufruft. Aber wenn Sie Dinge für das Testen anpassen müssen, dann wäre der Weg zu gehen (zum Beispiel) eine Methode, die Ihren Test-Code ermöglicht, Größe Feld vor Aufruf mymethod() einzurichten.

Oder: Sie trennen Bedenken, und verschieben Sie diese "Größe" Teil in seine eigene Klasse X. Und dann könnte Ihre Klasse unter Test eine Instanz von X halten; und diese Instanz könnte dann verspottet werden.

Lange Rede, kurzer Sinn: Sie möchten zurücktreten und einige Tutorials lesen, wie Sie EasyMock verwenden können. Das ist nicht etwas, was Sie durch Versuch und Irrtum lernen können.