Verspotten von Mitgliedsvariablen einer Klasse mit Mockito

Ich bin ein Neuling in der Entwicklung und insbesondere bei Unit-Tests. Ich denke, meine Anforderung ist ziemlich einfach, aber ich bin gespannt darauf, andere Gedanken dazu zu kennen.

Angenommen, ich habe zwei Klassen wie diese -

public class First {

    Second second ;

    public First(){
        second = new Second();
    }

    public String doSecond(){
        return second.doSecond();
    }
}

class Second {

    public String doSecond(){
        return "Do Something";
    }
}

Angenommen, ich schreibe Unit-Test-to-Test- First.doSecond()Methode. Angenommen, ich möchte die Second.doSecond()Klasse so verspotten . Ich benutze Mockito, um dies zu tun.

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");

    First first = new First();
    assertEquals("Stubbed Second", first.doSecond());
}

Ich sehe, dass die Verspottung nicht wirksam wird und die Behauptung fehlschlägt. Gibt es keine Möglichkeit, die Mitgliedsvariablen einer Klasse zu verspotten, die ich testen möchte? ?

Sie müssen eine Möglichkeit für den Zugriff auf die Elementvariablen bereitstellen, damit Sie einen Mock übergeben können (die gebräuchlichste Methode ist eine Setter-Methode oder ein Konstruktor, der einen Parameter verwendet).

Wenn Ihr Code dies nicht bietet, wird er für TDD (Test Driven Development) falsch berücksichtigt.

Dies ist nicht möglich, wenn Sie Ihren Code nicht ändern können. Aber ich mag Abhängigkeitsinjektion und Mockito unterstützt sie:

public class First {    
    @Resource
    Second second;

    public First() {
        second = new Second();
    }

    public String doSecond() {
        return second.doSecond();
    }
}

Dein Test:

@RunWith(MockitoJUnitRunner.class)
public class YourTest {
   @Mock
   Second second;

   @InjectMocks
   First first = new First();

   public void testFirst(){
      when(second.doSecond()).thenReturn("Stubbed Second");
      assertEquals("Stubbed Second", first.doSecond());
   }
}

Das ist sehr schön und einfach.

Wenn Sie sich Ihren Code genau ansehen, werden Sie feststellen, dass die secondEigenschaft in Ihrem Test immer noch eine Instanz von Secondund kein Mock ist (Sie geben den Mock firstin Ihrem Code nicht weiter).

Der einfachste Weg wäre, einen Setter für secondin der FirstKlasse zu erstellen und ihm den Mock explizit zu übergeben.

So was:

public class First {

Second second ;

public First(){
    second = new Second();
}

public String doSecond(){
    return second.doSecond();
}

    public void setSecond(Second second) {
    this.second = second;
    }


}

class Second {

public String doSecond(){
    return "Do Something";
}
}

....

public void testFirst(){
Second sec = mock(Second.class);
when(sec.doSecond()).thenReturn("Stubbed Second");


First first = new First();
first.setSecond(sec)
assertEquals("Stubbed Second", first.doSecond());
}

Eine andere Möglichkeit wäre, eine SecondInstanz als FirstKonstruktorparameter zu übergeben.

Wenn Sie den Code nicht ändern können, besteht meiner Meinung nach die einzige Möglichkeit darin, Reflection zu verwenden:

public void testFirst(){
    Second sec = mock(Second.class);
    when(sec.doSecond()).thenReturn("Stubbed Second");


    First first = new First();
    Field privateField = PrivateObject.class.
        getDeclaredField("second");

    privateField.setAccessible(true);

    privateField.set(first, sec);

    assertEquals("Stubbed Second", first.doSecond());
}

Aber Sie können es wahrscheinlich, da es selten ist, Tests mit Code durchzuführen, den Sie nicht kontrollieren (obwohl man sich ein Szenario vorstellen kann, in dem Sie eine externe Bibliothek testen müssen, weil der Autor dies nicht getan hat :)).

Wenn Sie die Mitgliedsvariable nicht ändern können, können Sie PowerMockit verwenden und aufrufen

Second second = mock(Second.class)
when(second.doSecond()).thenReturn("Stubbed Second");
whenNew(Second.class).withAnyArguments.thenReturn(second);

Das Problem ist nun, dass JEDER Aufruf von new Second dieselbe verspottete Instanz zurückgibt. Aber in Ihrem einfachen Fall wird dies funktionieren.

Ich hatte das gleiche Problem, bei dem kein privater Wert festgelegt wurde, weil Mockito keine Superkonstruktoren aufruft. Hier ist, wie ich das Verspotten mit Nachdenken verstärke.

Zuerst habe ich eine TestUtils-Klasse erstellt, die viele hilfreiche Dienstprogramme enthält, einschließlich dieser Reflexionsmethoden. Der Reflexionszugriff ist jedes Mal etwas schwierig zu implementieren. Ich habe diese Methoden erstellt, um Code für Projekte zu testen, die aus dem einen oder anderen Grund kein Verspottungspaket hatten, und ich wurde nicht eingeladen, ihn einzuschließen.

public class TestUtils {
    // get a static class value
    public static Object reflectValue(Class<?> classToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField  = reflectField(classToReflect, fieldNameValueToFetch);
            reflectField.setAccessible(true);
            Object reflectValue = reflectField.get(classToReflect);
            return reflectValue;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch);
        }
        return null;
    }
    // get an instance value
    public static Object reflectValue(Object objToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField  = reflectField(objToReflect.getClass(), fieldNameValueToFetch);
            Object reflectValue = reflectField.get(objToReflect);
            return reflectValue;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch);
        }
        return null;
    }
    // find a field in the class tree
    public static Field reflectField(Class<?> classToReflect, String fieldNameValueToFetch) {
        try {
            Field reflectField = null;
            Class<?> classForReflect = classToReflect;
            do {
                try {
                    reflectField = classForReflect.getDeclaredField(fieldNameValueToFetch);
                } catch (NoSuchFieldException e) {
                    classForReflect = classForReflect.getSuperclass();
                }
            } while (reflectField==null || classForReflect==null);
            reflectField.setAccessible(true);
            return reflectField;
        } catch (Exception e) {
            fail("Failed to reflect "+fieldNameValueToFetch +" from "+ classToReflect);
        }
        return null;
    }
    // set a value with no setter
    public static void refectSetValue(Object objToReflect, String fieldNameToSet, Object valueToSet) {
        try {
            Field reflectField  = reflectField(objToReflect.getClass(), fieldNameToSet);
            reflectField.set(objToReflect, valueToSet);
        } catch (Exception e) {
            fail("Failed to reflectively set "+ fieldNameToSet +"="+ valueToSet);
        }
    }

}

Dann kann ich die Klasse mit einer privaten Variablen wie dieser testen. Dies ist nützlich, um sich tief in Klassenbäumen zu verspotten, auf die Sie ebenfalls keine Kontrolle haben.

@Test
public void testWithRectiveMock() throws Exception {
    // mock the base class using Mockito
    ClassToMock mock = Mockito.mock(ClassToMock.class);
    TestUtils.refectSetValue(mock, "privateVariable", "newValue");
    // and this does not prevent normal mocking
    Mockito.when(mock.somthingElse()).thenReturn("anotherThing");
    // ... then do your asserts
}

Ich habe meinen Code aus meinem eigentlichen Projekt hier auf Seite geändert. Möglicherweise liegt ein oder zwei Kompilierungsprobleme vor. Ich denke, Sie haben eine allgemeine Vorstellung. Nehmen Sie den Code und verwenden Sie ihn, wenn Sie ihn nützlich finden.

Viele andere haben Ihnen bereits geraten, Ihren Code zu überdenken, um ihn testbarer zu machen - gute Ratschläge und normalerweise einfacher als das, was ich vorschlagen werde.

Wenn Sie den Code nicht ändern können, um ihn testbarer zu machen, wählen Sie PowerMock: https://code.google.com/p/powermock/

PowerMock erweitert Mockito (damit Sie kein neues Mock-Framework erlernen müssen) und bietet zusätzliche Funktionen. Dies beinhaltet die Möglichkeit, dass ein Konstruktor einen Mock zurückgibt. Kraftvoll, aber etwas kompliziert - verwenden Sie es also mit Bedacht.

Sie verwenden einen anderen Mock-Läufer. Und Sie müssen die Klasse vorbereiten, die den Konstruktor aufruft. (Beachten Sie, dass dies ein häufiges Problem ist. Bereiten Sie die Klasse vor, die den Konstruktor aufruft, nicht die konstruierte Klasse.)

@RunWith(PowerMockRunner.class)
@PrepareForTest({First.class})

Anschließend können Sie in Ihrem Testaufbau die whenNew-Methode verwenden, damit der Konstruktor einen Mock zurückgibt

whenNew(Second.class).withAnyArguments().thenReturn(mock(Second.class));

Ja, dies kann durchgeführt werden, wie der folgende Test zeigt (geschrieben mit der von mir entwickelten JMockit-Mocking-API):

@Test
public void testFirst(@Mocked final Second sec) {
    new NonStrictExpectations() {{ sec.doSecond(); result = "Stubbed Second"; }};

    First first = new First();
    assertEquals("Stubbed Second", first.doSecond());
}

Mit Mockito kann ein solcher Test jedoch nicht geschrieben werden. Dies liegt an der Art und Weise, wie das Verspotten in Mockito implementiert wird, wo eine Unterklasse der zu verspottenden Klasse erstellt wird. Nur Instanzen dieser "Schein" -Unterklasse können ein verspottetes Verhalten aufweisen. Daher muss der getestete Code sie anstelle einer anderen Instanz verwenden.

Wenn Sie eine Alternative zu ReflectionTestUtils von Spring in mockito wünschen, verwenden Sie

Whitebox.setInternalState(first, "second", sec);