Perché Mockito non prende in giro i metodi statici?

Ho letto alcuni thread qui sui metodi statici e penso di aver compreso i problemi che un uso improprio / eccessivo di metodi statici può causare. Ma non ho davvero capito perché è difficile prendere in giro i metodi statici.

So che altri framework beffardi, come PowerMock, possono farlo, ma perché non può farlo Mockito?

Ho letto questo articolo , ma l'autore sembra essere religiosamente contrario alla parola static, forse è la mia scarsa comprensione.

Una semplice spiegazione / collegamento sarebbe fantastico.

Penso che il motivo potrebbe essere che le librerie di oggetti fittizi in genere creano mock creando dinamicamente classi in fase di esecuzione (utilizzando cglib ). Ciò significa che implementano un'interfaccia in fase di esecuzione (è quello che fa EasyMock se non sbaglio) o ereditano dalla classe per deridere (questo è ciò che fa Mockito se non sbaglio). Entrambi gli approcci non funzionano per i membri statici, poiché non è possibile sovrascriverli utilizzando l'ereditarietà.

L'unico modo per simulare la statica è modificare il byte code di una classe in fase di esecuzione, che suppongo sia un po 'più complicato dell'ereditarietà.

Questa è la mia ipotesi, per quello che vale ...

Se hai bisogno di deridere un metodo statico, è un forte indicatore di un cattivo design. Di solito, deridi la dipendenza della tua classe sottoposta a test. Se la tua classe sottoposta a test fa riferimento a un metodo statico, come java.util.Math # sin, ad esempio, significa che la classe sottoposta a test necessita esattamente di questa implementazione (ad esempio, precisione e velocità). Se vuoi astrarre da un'implementazione concreta del seno, probabilmente hai bisogno di un'interfaccia (vedi dove va a finire)?

Mockito [3.4.0] può simulare metodi statici!

1. Sostituisci mockito-coredipendenza con mockito-inline:3.4.0.

2. Classe con metodo statico:

   class Buddy {
     static String name() {
       return "John";
     }
   }
   

3. Usa un nuovo metodo Mockito.mockStatic():

   @Test
   void lookMomICanMockStaticMethods() {
     assertThat(Buddy.name()).isEqualTo("John");
   
     try (MockedStatic<Buddy> theMock = Mockito.mockStatic(Buddy.class)) {
       theMock.when(Buddy::name).thenReturn("Rafael");
       assertThat(Buddy.name()).isEqualTo("Rafael");
     }
   
     assertThat(Buddy.name()).isEqualTo("John");
   }
   

   Mockito sostituisce il metodo statico trysolo all'interno del blocco.

Penso seriamente che sia odore di codice se hai bisogno di deridere anche i metodi statici.

• Metodi statici per accedere a funzionalità comuni? -> Usa un'istanza singleton e inseriscila
• Codice di terze parti? -> Inseriscilo nella tua interfaccia / delegato (e se necessario rendilo anche singleton)

L'unica volta che questo mi sembra eccessivo, sono librerie come Guava, ma non dovresti aver bisogno di deridere questo tipo comunque perché fa parte della logica ... (cose come Iterables.transform (..)) In
questo modo il tuo codice rimane pulito, puoi deridere tutte le tue dipendenze in modo pulito e hai uno strato anti-corruzione contro le dipendenze esterne. Ho visto PowerMock in pratica e tutte le classi per cui avevamo bisogno erano mal progettate. Anche l'integrazione di PowerMock a volte ha causato seri problemi
(es. Https://code.google.com/p/powermock/issues/detail?id=355 )

PS: lo stesso vale anche per i metodi privati. Non credo che i test dovrebbero conoscere i dettagli dei metodi privati. Se una classe è così complessa da tentare di deridere i metodi privati, è probabilmente un segno per dividere quella classe ...

Mockito restituisce oggetti ma static significa "livello di classe, non livello di oggetto" Quindi mockito darà un'eccezione al puntatore nullo per static.

In alcuni casi, i metodi statici possono essere difficili da testare, soprattutto se devono essere derisi, motivo per cui la maggior parte dei framework beffardi non li supporta. Ho trovato questo post sul blog molto utile per determinare come simulare metodi e classi statici.

In aggiunta alla risposta di Gerold Broser , ecco un esempio di derisione di un metodo statico con argomenti:

class Buddy {
  static String addHello(String name) {
    return "Hello " + name;
  }
}

...

@Test
void testMockStaticMethods() {
  assertThat(Buddy.addHello("John")).isEqualTo("Hello John");

  try (MockedStatic<Buddy> theMock = Mockito.mockStatic(Buddy.class)) {
    theMock.when(() -> Buddy.addHello("John")).thenReturn("Guten Tag John");
    assertThat(Buddy.addHello("John")).isEqualTo("Guten Tag John");
  }

  assertThat(Buddy.addHello("John")).isEqualTo("Hello John");
}