Comment simuler une classe finale avec mockito

Se moquant de finale de la statique/classes/méthodes est possible avec Mockito v2 uniquement.

ajouter ceci dans votre gradle fichier:

testImplementation 'org.mockito:mockito-inline:2.13.0'

Ce n'est pas possible avec Mockito v1, de la Mockito FAQ:

Quelles sont les limites de Mockito

• Besoins de java 1.5+

• Ne peut pas se moquer de finale classes

...

Vous ne pouvez pas se moquer d'une classe finale avec Mockito, que vous ne pouvez pas le faire par vous-même.

Ce que je fais, est de créer une classe finale pour envelopper la finale de la classe et de l'utiliser en tant que délégué. Un exemple de ceci est TwitterFactory classe, et c'est mon mockable classe:

public class TwitterFactory {

    private final twitter4j.TwitterFactory factory;

    public TwitterFactory() {
        factory = new twitter4j.TwitterFactory();
    }

    public Twitter getInstance(User user) {
        return factory.getInstance(accessToken(user));
    }

    private AccessToken accessToken(User user) {
        return new AccessToken(user.getAccessToken(), user.getAccessTokenSecret());
    }

    public Twitter getInstance() {
        return factory.getInstance();
    }
}

L'inconvénient, c'est qu'il y a beaucoup de code réutilisable; l'avantage est que vous pouvez ajouter quelques méthodes qui peuvent se rapporter à votre application d'entreprise (comme la getInstance qui est prise d'un utilisateur au lieu d'une accessToken, dans le cas ci-dessus).

Dans votre cas, je voudrais créer un non définitif RainOnTrees classe que délégué de la classe finale. Ou, si vous pouvez le faire non définitive, elle serait mieux.

Utilisation Powermock. Ce lien montre, comment le faire: https://github.com/jayway/powermock/wiki/MockFinal

Je suppose que vous l'avez fait final parce que vous voulez empêcher les autres classes de l'extension de RainOnTrees. Comme Efficace Java suggère (article 15), il y a une autre façon de garder une classe à proximité de l'extension sans en faire final:

1. Supprimer la final de mots-clés;

2. Faire son constructeur private. Aucune classe ne sera en mesure de le prolonger, car il ne sera pas en mesure d'appeler le super constructeur;

3. Créer une statique de la méthode de factorisation pour instancier ta classe.

   //No more final keyword here.
   public class RainOnTrees {
   
       public static RainOnTrees newInstance() {
           return new RainOnTrees();
       }
   
   
       private RainOnTrees() {
           //Private constructor.
       }
   
       public void startRain() {
   
           //some code here
       }
   }

Par l'utilisation de cette stratégie, vous serez en mesure d'utiliser Mockito et de garder votre classe fermée pour l'extension avec un peu de code réutilisable.

Donner à ceci un essai:

Mockito.mock(SomeMockableType.class,AdditionalAnswers.delegatesTo(someInstanceThatIsNotMockableOrSpyable));

Il a travaillé pour moi. "SomeMockableType.class" la classe parent de ce que vous voulez de se moquer ou d'espionnage, et someInstanceThatIsNotMockableOrSpyable est la classe réelle que vous voulez pour se moquer ou espion.

Pour plus de détails, veuillez consulter ici

En fait, il ya une façon dont je me sers pour l'espionnage. Il serait travailler pour vous, que si deux conditions sont remplies:

1. Vous utilisez une sorte de DI injecter une instance de la classe finale
2. Finale de la classe implémente une interface

Rappelons l'Article 16 de Efficace Java. Vous pouvez créer un wrapper (non définitif) et de transférer tous les appels à l'instance de la classe finale:

public final class RainOnTrees implement IRainOnTrees {
    @Override public void startRain() { //some code here }
}

public class RainOnTreesWrapper implement IRainOnTrees {
    private IRainOnTrees delegate;
    public RainOnTreesWrapper(IRainOnTrees delegate) {this.delegate = delegate;}
    @Override public void startRain() { delegate.startRain(); }
}

Maintenant, non seulement pouvez-vous vous moquer de votre classe finale, mais aussi espionner:

public class Seasons{
    RainOnTrees rain;
    public Seasons(IRainOnTrees rain) { this.rain = rain; };
    public void findSeasonAndRain(){
        rain.startRain();
   }
}

IRainOnTrees rain = spy(new RainOnTreesWrapper(new RainOnTrees()) //or mock(IRainOnTrees.class)
doNothing().when(rain).startRain();
new Seasons(rain).findSeasonAndRain();

Gain de temps pour les gens qui sont confrontés à la même question (Mockito + Classe Finale) sur Android + Kotlin. Comme dans Kotlin classes sont finales par défaut. J'ai trouvé une solution dans un de Google Android échantillons avec l'Architecture du composant. Solution choisi à partir d'ici : https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample

Créer des annotations suivantes :

/**
 * This annotation allows us to open some classes for mocking purposes while they are final in
 * release builds.
 */
@Target(AnnotationTarget.ANNOTATION_CLASS)
annotation class OpenClass

/**
 * Annotate a class with [OpenForTesting] if you want it to be extendable in debug builds.
 */
@OpenClass
@Target(AnnotationTarget.CLASS)
annotation class OpenForTesting

Modifier votre gradle fichier. Prenez par exemple à partir d'ici : https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample/app/build.gradle

apply plugin: 'kotlin-allopen'

allOpen {
    //allows mocking for classes w/o directly opening them for release builds
    annotation 'com.android.example.github.testing.OpenClass'
}

Maintenant, vous pouvez annoter toute la classe pour faire ouvrir pour les essais de :

@OpenForTesting
class RepoRepository 

Veuillez jeter un oeil à JMockit. Il possède une vaste documentation, avec beaucoup d'exemples. Ici vous avez un exemple de solution de votre problème (pour simplifier, j'ai ajouté constructeur de Seasons à injecter moqué RainOnTrees exemple):

package jmockitexample;

import mockit.Mocked;
import mockit.Verifications;
import mockit.integration.junit4.JMockit;
import org.junit.Test;
import org.junit.runner.RunWith;

@RunWith(JMockit.class)
public class SeasonsTest {

    @Test
    public void shouldStartRain(@Mocked final RainOnTrees rain) {
        Seasons seasons = new Seasons(rain);

        seasons.findSeasonAndRain();

        new Verifications() {{
            rain.startRain();
        }};
    }

    public final class RainOnTrees {
        public void startRain() {
            //some code here
        }

    }

    public class Seasons {

        private final RainOnTrees rain;

        public Seasons(RainOnTrees rain) {
            this.rain = rain;
        }

        public void findSeasonAndRain() {
            rain.startRain();
        }

    }
}

Si vous essayez d'exécuter des tests unitaires en vertu de la test dossier, la solution est très bien. Suivez simplement en ajoutant une extension.

Mais si vous voulez l'exécuter avec liés android classe comme contexte ou de l'activité qui est sous androidtest dossier, la réponse est fait pour vous.

Comme d'autres l'ont dit, cela ne peut pas fonctionner hors de la boîte avec Mockito. Je suggère l'utilisation de la réflexion pour définir les champs spécifiques sur l'objet qui est utilisé par le code en cours de test. Si vous vous retrouver à faire beaucoup, vous pouvez envelopper cette fonction dans une bibliothèque.

En aparté, si vous êtes l'un marquage des classes de finale, arrêter de faire ça. J'ai couru à travers cette question, parce que je suis en train de travailler avec une API où tout a été marquée final pour empêcher mon besoin légitime d'extension (moqueur), et je souhaite que le développeur n'avait pas supposé que je n'aurait pas besoin d'étendre la classe.

N'essayez pas définitif, mais pour le privé, l'utilisation de la réflexion supprimer le modificateur travaillé ! avoir vérifié encore, il ne fonctionne pas pour la finale.