À l'aide de Mockito pour tester les classes abstraites

La suggestion suivante vous permet de tester les classes abstraites sans la création d'un "réel" sous - classe- de la Maquette est la sous-classe.

utilisation Mockito.mock(My.class, Mockito.CALLS_REAL_METHODS), puis se moquer de toutes les méthodes abstraites qui sont invoquées.

Exemple:

public abstract class My {
  public Result methodUnderTest() { ... }
  protected abstract void methodIDontCareAbout();
}

public class MyTest {
    @Test
    public void shouldFailOnNullIdentifiers() {
        My my = Mockito.mock(My.class, Mockito.CALLS_REAL_METHODS);
        Assert.assertSomething(my.methodUnderTest());
    }
}

Remarque: La beauté de cette solution est que vous n'avez pas ont pour mettre en œuvre les méthodes abstraites, tant qu'ils ne sont jamais invoquées.

À mon avis honnête, c'est plus propre qu'à l'aide d'un espion, depuis un espion requiert une instance, ce qui signifie que vous devez créer un instantiatable sous-classe de votre classe abstraite.

Vous pouvez atteindre cet objectif en utilisant un espion (utiliser la dernière version de Mockito de 1,8+ si).

public abstract class MyAbstract {
  public String concrete() {
    return abstractMethod();
  }
  public abstract String abstractMethod();
}

public class MyAbstractImpl extends MyAbstract {
  public String abstractMethod() {
    return null;
  }
}

//your test code below

MyAbstractImpl abstractImpl = spy(new MyAbstractImpl());
doReturn("Blah").when(abstractImpl).abstractMethod();
assertTrue("Blah".equals(abstractImpl.concrete()));

Essayer en utilisant une mesure de répondre.

Par exemple:

import org.mockito.Mockito;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;

public class CustomAnswer implements Answer<Object> {

    public Object answer(InvocationOnMock invocation) throws Throwable {

        Answer<Object> answer = null;

        if (isAbstract(invocation.getMethod().getModifiers())) {

            answer = Mockito.RETURNS_DEFAULTS;

        } else {

            answer = Mockito.CALLS_REAL_METHODS;
        }

        return answer.answer(invocation);
    }
}

Ce sera le retour de la maquette pour les méthodes abstraites et fera appel à la vraie méthode pour les méthodes concrètes.

En supposant que votre test de classes sont dans le même package (en vertu d'une source différente de la racine) que vos classes en cours de test, vous pouvez simplement créer la maquette:

YourClass yourObject = mock(YourClass.class);

et appeler les méthodes que vous souhaitez tester comme vous le feriez de toute autre méthode.

Vous devez fournir les attentes pour chaque méthode est appelée avec l'attente sur toutes les méthodes concrètes de l'appel de la méthode super - ne sais pas comment vous pouvez le faire avec Mockito, mais je crois que c'est possible avec EasyMock.

Tout cela est en train de faire est de créer un béton instance de YouClass et vous économisez de l'effort de fournir des implémentations vides de chaque méthode abstraite.

En aparté, je trouve souvent qu'il est utile de mettre en œuvre la classe abstraite dans mon test, où il sert comme un exemple de mise en oeuvre que je test via son interface publique, bien que cela dépendra de la fonctionnalité fournie par la classe abstraite.

Vous pouvez instancier une classe anonyme, injecter, se moque de puis de tester cette classe.

@RunWith(MockitoJUnitRunner.class)
public class ClassUnderTest_Test {

    private ClassUnderTest classUnderTest;

    @Mock
    MyDependencyService myDependencyService;

    @Before
    public void setUp() throws Exception {
        this.classUnderTest = getInstance();
    }

    private ClassUnderTest getInstance() {
        return new ClassUnderTest() {

            private ClassUnderTest init(
                    MyDependencyService myDependencyService
            ) {
                this.myDependencyService = myDependencyService;
                return this;
            }

            @Override
            protected void myMethodToTest() {
                return super.myMethodToTest();
            }
        }.init(myDependencyService);
    }
}

Gardez à l'esprit que la visibilité doit être protected pour le bien myDependencyService de la classe abstraite ClassUnderTest.

Mockito permet de se moquant de classes abstraites par le biais de la @Mock annotation:

public abstract class My {

    public abstract boolean myAbstractMethod();

    public void myNonAbstractMethod() {
        //...
    }
}

@RunWith(MockitoJUnitRunner.class)
public class MyTest {

    @Mock(answer = Answers.CALLS_REAL_METHODS)
    private My my;

    @Test
    private void shouldPass() {
        BDDMockito.given(my.myAbstractMethod()).willReturn(true);
        my.myNonAbstractMethod();
        //...
    }
}

L'inconvénient est qu'il ne peut pas être utilisé si vous avez besoin de paramètres du constructeur.