Come deridere un'ultima classe con mockito

Ho una lezione finale, qualcosa del genere:

public final class RainOnTrees{

   public void startRain(){

        // some code here
   }
}

Sto usando questa classe in un'altra classe come questa:

public class Seasons{

   RainOnTrees rain = new RainOnTrees();

   public void findSeasonAndRain(){

        rain.startRain();

    }
}

e nella mia classe di test JUnit per Seasons.javavoglio deridere la RainOnTreesclasse. Come posso farlo con Mockito?

Deridere classi / metodi finali / statici è possibile solo con Mockito v2.

aggiungi questo nel tuo file gradle:

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

Questo non è possibile con Mockito v1, dalle FAQ di Mockito :

Quali sono i limiti di Mockito

• Ha bisogno di java 1.5+

• Impossibile deridere le classi finali

...

Mockito 2 ora supporta classi e metodi finali !

Ma per ora questa è una funzione di "incubazione". Richiede alcuni passaggi per attivarlo, descritti in Novità di Mockito 2 :

La derisione delle classi e dei metodi finali è una caratteristica di incubazione , opt-in. Utilizza una combinazione di strumentazione e sottoclasse degli agenti Java per abilitare la derisione di questi tipi. Dato che funziona diversamente dal nostro attuale meccanismo e questo ha diversi limiti e poiché vogliamo raccogliere esperienza e feedback degli utenti, questa funzione doveva essere esplicitamente attivata per essere disponibile; può essere fatto tramite il meccanismo di estensione mockito creando il file src/test/resources/mockito-extensions/org.mockito.plugins.MockMakercontenente una singola riga:

mock-maker-inline

Dopo aver creato questo file, Mockito utilizzerà automaticamente questo nuovo motore e si può fare:

 final class FinalClass {
   final String finalMethod() { return "something"; }
 }

 FinalClass concrete = new FinalClass(); 

 FinalClass mock = mock(FinalClass.class);
 given(mock.finalMethod()).willReturn("not anymore");

 assertThat(mock.finalMethod()).isNotEqualTo(concrete.finalMethod());

Nelle tappe successive, il team introdurrà un modo programmatico di utilizzare questa funzione. Identificheremo e forniremo supporto per tutti gli scenari non modificabili. Resta sintonizzato e facci sapere cosa ne pensi di questa funzione!

Non puoi deridere un'ultima classe con Mockito, poiché non puoi farlo da solo.

Quello che faccio è creare una classe non finale per avvolgere la classe finale e usarla come delegata. Un esempio di questo è la TwitterFactoryclasse, e questa è la mia classe beffarda:

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();
    }
}

Lo svantaggio è che esiste un sacco di codice del boilerplate; il vantaggio è che è possibile aggiungere alcuni metodi che potrebbero essere correlati all'attività dell'applicazione (come getInstance che richiede un utente anziché un accessoToken, nel caso precedente).

Nel tuo caso, creerei una RainOnTreesclasse non finale da delegare alla classe finale. Oppure, se riesci a renderlo non definitivo, sarebbe meglio.

aggiungi questo nel tuo file gradle:

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

questa è una configurazione per far funzionare mockito con le classi finali

Usa Powermock. Questo link mostra come farlo: https://github.com/jayway/powermock/wiki/MockFinal

Solo per dare seguito. Aggiungi questa riga al tuo file gradle:

testCompile group: 'org.mockito', name: 'mockito-inline', version: '2.8.9'

Ho provato varie versioni di mockito-core e mockito-all. Nessuno dei due funziona.

Immagino tu l'abbia fatto finalperché vuoi impedire che altre classi si estendano RainOnTrees. Come suggerisce Effective Java (elemento 15), c'è un altro modo per mantenere una classe vicina per l'estensione senza renderla final:

1. Rimuovi la finalparola chiave;

2. Crea il suo costruttore private. Nessuna classe sarà in grado di estenderla perché non sarà in grado di chiamare il supercostruttore;

3. Crea un metodo factory statico per creare un'istanza della tua 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
       }
   }

Usando questa strategia, sarai in grado di usare Mockito e tenere la tua classe chiusa per l'estensione con un piccolo codice di targa.

Ho avuto lo stesso problema. Poiché la classe che stavo cercando di prendere in giro era una classe semplice, ho semplicemente creato un'istanza di essa e l'ho restituita.

Prova questo:

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

Ha funzionato per me. "SomeMockableType.class" è la classe padre di ciò che vuoi deridere o spiare, e someInstanceThatIsNotMockableOrSpyable è la classe effettiva che vuoi deridere o spiare.

Per maggiori dettagli dai un'occhiata qui

Un'altra soluzione alternativa, che può essere applicabile in alcuni casi, è quella di creare un'interfaccia implementata da quella classe finale, modificare il codice per utilizzare l'interfaccia anziché la classe concreta e quindi deridere l'interfaccia. Ciò consente di separare il contratto (interfaccia) dall'implementazione (classe finale). Naturalmente, se ciò che vuoi è davvero legare alla classe finale, questo non si applica.

In realtà c'è un modo, che uso per spiare. Funzionerebbe per te solo se fossero soddisfatte due condizioni preliminari:

1. Si utilizza un tipo di DI per iniettare un'istanza della classe finale
2. La classe finale implementa un'interfaccia

Ricorda l'articolo 16 di Effective Java . È possibile creare un wrapper (non finale) e inoltrare tutte le chiamate all'istanza della 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(); }
}

Ora non solo puoi deridere la tua classe finale, ma anche spiarla:

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();

In Mockito 3 e altro ho lo stesso problema e risolto come da questo link

Mock Final Classes and Methods con Mockito come segue

Prima che Mockito possa essere usato per deridere classi e metodi finali, deve essere> configurato.

Dobbiamo aggiungere un file di testo alla directory src / test / resources / mockito-extensions del progetto denominata org.mockito.plugins.MockMaker e aggiungere una singola riga di testo:

mock-maker-inline

Mockito controlla la directory delle estensioni per i file di configurazione quando viene caricato. Questo file consente di deridere i metodi e le classi finali.

Risparmio di tempo per le persone che affrontano lo stesso problema (Mockito + Final Class) su Android + Kotlin. Come in Kotlin, le classi sono definitive per impostazione predefinita. Ho trovato una soluzione in uno degli esempi di Google Android con il componente Architecture. Soluzione scelta da qui: https://github.com/googlesamples/android-architecture-components/blob/master/GithubBrowserSample

Crea le seguenti annotazioni:

/**
 * 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

Modifica il tuo file gradle. Prendi esempio da qui: 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'
}

Ora puoi annotare qualsiasi classe per renderla aperta ai test:

@OpenForTesting
class RepoRepository 

Questo può essere fatto se si utilizza Mockito2, con la nuova funzione di incubazione che supporta il derisione di classi e metodi finali.

Punti chiave da notare:
1. Creare un file semplice con il nome "org.mockito.plugins.MockMaker" e posizionarlo in una cartella denominata "mockito-extensions". Questa cartella dovrebbe essere resa disponibile sul percorso di classe.
2. Il contenuto del file creato sopra dovrebbe essere una riga singola come indicato di seguito:
mock-maker-inline

I due passaggi precedenti sono necessari per attivare il meccanismo di estensione mockito e utilizzare questa funzione di attivazione.

Le classi di esempio sono le seguenti: -

FinalClass.java

public final class FinalClass {

public final String hello(){
    System.out.println("Final class says Hello!!!");
    return "0";
}

}

Foo.java

public class Foo {

public String executeFinal(FinalClass finalClass){
    return finalClass.hello();
}

}

FooTest.java

public class FooTest {

@Test
public void testFinalClass(){
    // Instantiate the class under test.
    Foo foo = new Foo();

    // Instantiate the external dependency
    FinalClass realFinalClass = new FinalClass();

    // Create mock object for the final class. 
    FinalClass mockedFinalClass = mock(FinalClass.class);

    // Provide stub for mocked object.
    when(mockedFinalClass.hello()).thenReturn("1");

    // assert
    assertEquals("0", foo.executeFinal(realFinalClass));
    assertEquals("1", foo.executeFinal(mockedFinalClass));

}

}

Spero che sia d'aiuto.

Articolo completo presente qui beffardo-il-smontabile .

Sì, lo stesso problema qui, non possiamo prendere in giro un'ultima classe con Mockito. Per essere precisi, Mockito non può deridere / spiare quanto segue:

• lezioni finali
• lezioni anonime
• tipi primitivi

Ma usare una classe wrapper mi sembra un grande prezzo da pagare, quindi prendi invece PowerMockito.

Penso che tu debba pensare di più in linea di principio. Invece la classe finale usa invece la sua interfaccia e la sua interfaccia simulata.

Per questo:

 public class RainOnTrees{

   fun startRain():Observable<Boolean>{

        // some code here
   }
}

Inserisci

interface iRainOnTrees{
  public void startRain():Observable<Boolean>
}

e ti deridi interfaccia:

 @Before
    fun setUp() {
        rainService= Mockito.mock(iRainOnTrees::class.java)

        `when`(rainService.startRain()).thenReturn(
            just(true).delay(3, TimeUnit.SECONDS)
        )

    }

Si prega di guardare JMockit . Ha una vasta documentazione con molti esempi. Qui hai una soluzione di esempio del tuo problema (per semplificare ho aggiunto il costruttore Seasonsper iniettare RainOnTreesun'istanza derisa ):

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();
        }

    }
}

Le soluzioni fornite da RC e Luigi R. Viggiano insieme sono probabilmente l'idea migliore.

Sebbene Mockito non possa , in base alla progettazione, deridere le classi finali, l'approccio della delega è possibile . Questo ha i suoi vantaggi:

1. Non sei obbligato a cambiare la tua classe in non definitiva se questo è ciò che la tua API intende in primo luogo (le classi finali hanno i loro vantaggi ).
2. Stai testando la possibilità di una decorazione attorno alla tua API.

Nel tuo caso di test, inoltri deliberatamente le chiamate al sistema in prova. Quindi, dal design, la tua decorazione no fa nulla.

Quindi il test può anche dimostrare che l'utente può solo decorare l'API invece di estenderla.

Su una nota più soggettiva: preferisco limitare al minimo i framework, motivo per cui JUnit e Mockito sono in genere sufficienti per me. In effetti, limitare questo modo a volte mi costringe anche a fare il refactoring per il bene.

Se si sta tentando di eseguire unit-test nella cartella test , la soluzione migliore va bene. Basta seguirlo aggiungendo un'estensione.

Ma se vuoi eseguirlo con una classe relativa ad Android come il contesto o l'attività che si trova nella cartella androidtest , la risposta è per te.

Aggiungi queste dipendenze per eseguire mockito correttamente:

testImplementation 'org.mockito: mockito-core: 2.24.5'
testImplementation "org.mockito: mockito-inline: 2.24.5"

Come altri hanno già affermato, con Mockito non funzionerà immediatamente. Suggerirei di utilizzare la riflessione per impostare i campi specifici sull'oggetto che viene utilizzato dal codice in prova. Se ti ritrovi a fare molto, puoi avvolgere questa funzionalità in una libreria.

Per inciso, se sei l'unico a classificare le classi, smetti di farlo. Ho incontrato questa domanda perché sto lavorando con un'API in cui tutto è stato contrassegnato come definitivo per impedire il mio legittimo bisogno di estensione (derisione) e vorrei che lo sviluppatore non avesse assunto che non avrei mai avuto bisogno di estendere la classe.

Per noi, è stato perché abbiamo escluso il mockito-inline dal test koin. Un modulo gradle in realtà aveva bisogno di questo e per motivi non riusciva solo nelle build di rilascio (build di debug nell'IDE funzionavano) :-P

Per la classe finale aggiungi sotto per deridere e chiama statico o non statico.

1- aggiungi questo a livello di classe @SuppressStatucInitializationFor (valore = {nome classe con pacchetto})
2- PowerMockito.mockStatic (classname.class) deriderà la classe
3- quindi usa la tua istruzione quando per restituire un oggetto simulato quando chiama il metodo di questa classe.

Godere

Non ho provato final, ma per il privato, usando la reflection rimuovi il modificatore ha funzionato! ho controllato ulteriormente, non funziona per la finale.