Wie zum Hohn geschützt Unterklasse die geerbten Methode aus der abstrakten Klasse?

Wie zu verwenden Mockito oder PowerMock zu verspotten, eine protected-Methode, realisiert durch eine Unterklasse, aber geerbt von der abstrakten super-Klasse?

In anderen Worten, ich möchte testen "doSomething" - Methode, während die Verspottung der "doSomethingElse".

Abstrakten super-Klasse

public abstract class TypeA {

    public void doSomething() {     

        //Calls for subclass behavior
        doSomethingElse();      
    }

    protected abstract String doSomethingElse();

}

Unterklasse Umsetzung

public class TypeB extends TypeA {

    @Override
    protected String doSomethingElse() {
        return "this method needs to be mocked";
    }

}

Lösung

Antworten, die hier gegeben werden sind richtig und wird funktionieren, wenn alle beteiligten Klassen im gleichen Paket.

Aber wenn verschiedene Pakete beteiligt sind, ist eine option, um Benutzer PowerMock. Das folgende Beispiel funktionierte für mich. Natürlich könnte es andere Möglichkeiten, es zu tun, das ist eine, die funktioniert.

import static org.junit.Assert.assertEquals;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;

@RunWith(PowerMockRunner.class)
@PrepareForTest({ TypeB.class })
public class TestAbstract {

    @Test
    public void test_UsingPowerMock() throws Exception {
        //Spy a subclass using PowerMock
        TypeB b = PowerMockito.spy(new TypeB());
        String expected = "some value for mock";

        //Mock a method by its name using PowerMock again
        PowerMockito.doReturn(expected).when(b, "doSomethingElse");

        //Calls the 
        String actual = b.doSomething();
        assertEquals(expected, actual);     

    }
}

Hinweis: Tests mit Java 5, jUnit 4.11, Mockito 1.9.0 und PowerMock 1.4.12.

Dieser Ansatz gibt mir ein NullPointerException mit Java 8, JUnit 4.12 und PowerMock 1.6.4.

InformationsquelleAutor BonanzaOne | 2015-08-18

5

Können Sie Mockito.CALLS_REAL_METHODS wenn die Verspottung der abstrakten Methode. Dies ruft den originalen Methoden von der Klasse und Sie verspotten Sie alle abstrakten Methoden von selbst.
```
TypeA typeA = mock(TypeA.class, Mockito.CALLS_REAL_METHODS);
when(typeA.doSomethingElse()).thenReturn("Hello");
typeA.doSomething();
```
Oder testen Sie direkt auf die TypeB mit einem Spion:
```
TypeB typeB = spy(new TypeB());
when(typeB.doSomethingElse()).thenReturn("Hello");
typeB.doSomething();
```
Die 1. option schlägt fehl, weil der Typ a ist Abstrakt. Option 2 funktioniert mit spy() aber wenn ich versuche es in meinem Produktions-code, es gibt mir The method <method name> from the type <subclass name> is not visible. Um herauszufinden, warum.
Eigentlich dein test korrekt ist, aber ich habe die Klassen in verschiedene Pakete, das ist, warum ich war nicht in der Lage, es früher zu tun. Methoden, die nicht sichtbar sind von anderen Paketen, wenn geschützt.
Habe die 1. option funktioniert auch? Ich habe beide getestet mit Mockito 1.10.19 und die Letzte beta-version und beide funktionieren wie erwartet.
In der Tat es funktioniert. Habe vergessen zu sagen, meine Mockito version ist uralt, 1.9.0, weil von Java 5.

InformationsquelleAutor mszalbach
4

Schlage ich vor, mit Mockito:
```
//Create a new Mock
final TypeA a = Mockito.mock(TypeA.class, Mockito.CALLS_REAL_METHODS);

//Call the method
a.doSomething();

//Now verify that our mocked class' method was called
Mockito.verify(a, Mockito.times(1)).doSomethingElse();
```
Es funktioniert, aber ich habe gerade realisiert, dass ich die Klassen in verschiedene Pakete in meinem Produktions-code. Protected-Methoden sind nicht sichtbar, dann.
Dies macht es ein problem. Eine mögliche Lösung wäre die Verwendung von PowerMock, die sollten in der Lage sein zu überprüfen, in privaten Methoden, afaik. Nie benutzt, obwohl.

InformationsquelleAutor Florian Schaetz

Können Sie testen Sie Ihre abtract-Klasse mit mockito in der folgenden Weise

TypeA typA = Mockito.mock(TypeA.class, Mockito.CALLS_REAL_METHODS);
when(typA.doSomethingElse()).thenReturn("doSomethingElse");
Assert.assertSomething(typeA.doSomething());

InformationsquelleAutor jozzy

0

Zu verspotten Methoden, die void zurückgibt, in abstrakten Klassen, die wir verwenden könnten:
```
MyAbstractClass abs = Mockito.mock(MyAbstractClass.class);
Mockito.doNothing().when(abs).myMethod(arg1,arg2....));
```
Können wir ersetzen Argumente mit Mockito.anyString() etc wie pro Anforderungen.

InformationsquelleAutor Virtual

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.