Derisione contro spionaggio in quadri beffardi

Nei framework beffardi, puoi deridere un oggetto o spiarlo . Qual è la differenza tra i due e quando dovrei / dovrei usarne uno rispetto all'altro?

Guardando Mockito , per esempio, vedo cose simili fatte usando spie e beffe , ma non sono sicuro della distinzione tra i due.

L'oggetto finto sostituisce completamente la classe derisa, restituendo valori registrati o predefiniti. È possibile creare finto dal "nulla". Questo è ciò che viene utilizzato principalmente durante i test unitari.

Durante lo spionaggio, prendi un oggetto esistente e "sostituisci" solo alcuni metodi. Questo è utile quando hai una classe enorme e vuoi deridere solo alcuni metodi (derisione parziale). Vorrei citare la documentazione di Mockito :

Puoi creare spie di oggetti reali. Quando usi la spia , vengono chiamati i metodi reali (a meno che un metodo non sia stato stub).

Le vere spie dovrebbero essere usate con attenzione e occasionalmente , ad esempio quando si tratta di codice legacy.

In caso di dubbio, usare beffe.

Mockito avverte che il derisione parziale non è una buona pratica e dovresti rivedere la tua architettura orientata agli oggetti. Si consiglia di spiare (o deridere parzialmente) per testare il codice legacy .

Proverò a spiegare usando un esempio qui:

// Difference between mocking, stubbing and spying
@Test
public void differenceBetweenMockingSpyingAndStubbing() {
    List list = new ArrayList();
    list.add("abc");
    assertEquals(1, list.size());

    List mockedList = spy(list);
    when(mockedList.size()).thenReturn(10);
    assertEquals(10, mockedList.size());
}

Qui, avevamo un vero oggetto iniziale list, in cui abbiamo aggiunto un elemento e ci aspettavamo che la dimensione fosse uno.

Noi spiamo significato oggetto reale che possiamo indicare quale metodo da spense . Così abbiamo dichiarato che spense il metodo - size()sul oggetto di spionaggio che restituirà 10, non importa quale è la dimensione reale.

In poche parole, spiando l'oggetto reale e stub alcuni dei metodi .

Riferimento: http://javapointers.com/tutorial/difference-between-spy-and-mock-in-mockito/

Quando si usano oggetti finti, il comportamento predefinito del metodo quando non lo stub è non fare nulla. Semplice significa che, se è un metodo nullo, allora non farà nulla quando si chiama il metodo o se è un metodo con un ritorno, allora può restituire un valore nullo, vuoto o predefinito.

Mentre si trova negli oggetti spia, ovviamente, poiché si tratta di un metodo reale, quando non si sta testando il metodo, verrà chiamato il comportamento del metodo reale. Se vuoi cambiare e deridere il metodo, allora devi stubarlo.

Gli oggetti fittizi vengono fatti passare ma mai effettivamente utilizzati. Di solito vengono utilizzati solo per riempire elenchi di parametri.

Gli oggetti falsi in realtà hanno implementazioni funzionanti, ma di solito prendono alcuni collegamenti che li rendono non adatti alla produzione (un database in memoria è un buon esempio).

Gli stub forniscono risposte predefinite alle chiamate effettuate durante il test, di solito non rispondono a nulla al di fuori di ciò che è programmato per il test.

Le spie sono stub che registrano anche alcune informazioni in base al modo in cui sono state chiamate. Una forma di questo potrebbe essere un servizio di posta elettronica che registra quanti messaggi è stato inviato.

Le finte sono ciò di cui stiamo parlando qui: oggetti pre-programmati con aspettative che formano una specifica delle chiamate che dovrebbero ricevere.

Mock Aren't Stubs di Martin Fowler

Le spie hanno due definizioni. Uno è dove viene chiamato il metodo reale, un altro dove non viene chiamata alcuna funzionalità e vengono restituiti solo valori equivalenti nulli o nulli, ma i metodi sono stati chiamati e il loro stato è stato registrato, comunemente come il metodo x è stato chiamato y volte.

In Mockito se si assegna qualsiasi oggetto alla variabile di istanza di Mock Object, ciò non influisce su Mock Object.

Ma nel caso di Spy, se si assegna qualsiasi oggetto alla variabile di istanza di Spy Object, ciò influisce su Spy Object perché Spy si comporta come una modifica dell'oggetto in tempo reale.

Per un esempio di riferimento sono

@RunWith(MockitoJUnitRunner.class)
public class MockSpyExampleTest {

    @Mock
    private List<String> mockList;

    @Spy
    private List<String> spyList = new ArrayList();

    @Test
    public void testMockList() {
        //by default, calling the methods of mock object will do nothing
        mockList.add("test");
        assertNull(mockList.get(0));
    }

    @Test
    public void testSpyList() {
        //spy object will call the real method when not stub
        spyList.add("test");
        assertEquals("test", spyList.get(0));
    }
}