Mock oder Stub für verketteten Anruf

protected int parseExpire(CacheContext ctx) throws AttributeDefineException {
    Method targetMethod = ctx.getTargetMethod();
    CacheEnable cacheEnable = targetMethod.getAnnotation(CacheEnable.class);
    ExpireExpr cacheExpire = targetMethod.getAnnotation(ExpireExpr.class);
    // check for duplicate setting
    if (cacheEnable.expire() != CacheAttribute.DO_NOT_EXPIRE && cacheExpire != null) {
        throw new AttributeDefineException("expire are defined both in @CacheEnable and @ExpireExpr");
    }
    // expire time defined in @CacheEnable or @ExpireExpr
    return cacheEnable.expire() != CacheAttribute.DO_NOT_EXPIRE ? cacheEnable.expire() : parseExpireExpr(cacheExpire, ctx.getArgument());
}

das ist die Methode zu testen,

Method targetMethod = ctx.getTargetMethod();
CacheEnable cacheEnable = targetMethod.getAnnotation(CacheEnable.class);

Ich muss drei CacheContext, Method und CacheEnable verspotten. Gibt es eine Idee, den Testfall viel einfacher zu gestalten?

Mockito kann mit verketteten Stummeln umgehen :

Foo mock = mock(Foo.class, RETURNS_DEEP_STUBS);

// note that we're stubbing a chain of methods here: getBar().getName()
when(mock.getBar().getName()).thenReturn("deep");

// note that we're chaining method calls: getBar().getName()
assertEquals("deep", mock.getBar().getName());

AFAIK, die erste Methode in der Kette, gibt ein Modell zurück, das so eingerichtet ist, dass es Ihren Wert beim zweiten verketteten Methodenaufruf zurückgibt.

Die Autoren von Mockito weisen darauf hin, dass dies nur für Legacy-Code verwendet werden sollte . Andernfalls ist es besser, das Verhalten in Ihren CacheContext zu übertragen und alle Informationen bereitzustellen, die für die Ausführung des Auftrags selbst erforderlich sind. Die Menge an Informationen, die Sie aus CacheContext abrufen, deutet darauf hin, dass Ihre Klasse über Feature-Neid verfügt .

Nur für den Fall, dass Sie Kotlin verwenden. MockK sagt nichts über Verkettungs eine schlechte Praxis zu sein und einfach können Sie tun dies .

val car = mockk<Car>()

every { car.door(DoorType.FRONT_LEFT).windowState() } returns WindowState.UP

car.door(DoorType.FRONT_LEFT) // returns chained mock for Door
car.door(DoorType.FRONT_LEFT).windowState() // returns WindowState.UP

verify { car.door(DoorType.FRONT_LEFT).windowState() }

confirmVerified(car)

Mein Vorschlag, Ihren Testfall zu vereinfachen, besteht darin, Ihre Methode zu überarbeiten.

Immer wenn ich Probleme beim Testen einer Methode habe, riecht es nach Code und ich frage, warum es schwierig ist, sie zu testen. Und wenn Code schwer zu testen ist, ist er wahrscheinlich schwer zu verwenden und zu warten.

In diesem Fall liegt es daran, dass Sie eine Methodenkette haben, die mehrere Ebenen tief geht. Übergeben Sie möglicherweise ctx, cacheEnable und cacheExpire als Parameter.

Ich fand JMockit einfacher zu bedienen und komplett darauf umgestellt. Siehe Testfälle, die es verwenden:

https://github.com/ko5tik/andject/blob/master/src/test/java/de/pribluda/android/andject/ViewInjectionTest.java

Hier verspotte ich die Aktivitätsbasisklasse, die von Android SKD stammt und komplett gestoppt ist. Mit JMockit können Sie Dinge verspotten, die endgültig, privat, abstrakt oder was auch immer sind.

In Ihrem Testfall würde es so aussehen:

public void testFoo(@Mocked final Method targetMethod, 
                    @Mocked  final CacheContext context,
                    @Mocked final  CacheExpire ce) {
    new Expectations() {
       {
           // specify expected sequence of infocations here

           context.getTargetMethod(); returns(method);
       }
    };

    // call your method
    assertSomething(objectUndertest.cacheExpire(context))