Wie verspotte ich eine Methode, die von einer anderen Methode mit EasyMock aufgerufen wird?

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

Zuerst die getestete Klasse. Sie müssen ein Teilmodell davon erstellen. getSizesollte verspottet werden, myMethodsollte aber da es die getestete Methode ist.

Außerdem möchten Sie häufig einen Konstruktor aufrufen, um die Klasse korrekt zu initialisieren (ein klassischer Mock ruft keinen Konstruktor auf).

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 sein

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 erledigt. Beachten Sie, dass dies nicht unbedingt ein Zeichen für schlechtes Design ist. Ich benutze es häufig beim Testen des Template-Methodenmusters .