Introduzione a Mocking in Python

Mocking è una libreria per test in Python. Ti permette di sostituire parti del tuo sistema sotto test con oggetti finti e di fare affermazioni su come sono stati usati. Questo tutorial discuterà in dettaglio cosa è il mocking e come usarlo nelle applicazioni Python.

Che cosa è beffardo?

Mocking è una libreria per il testing in Python che ti permette di sostituire parti del tuo sistema sotto test con oggetti mock e fare asserzioni su come sono stati usati.

In Python, il mocking si ottiene sostituendo parti del tuo sistema con oggetti finti usando il modulo unittest.mock. Questo modulo contiene una serie di classi e funzioni utili, vale a dire la funzione patch (come decorator e context manager) e la classe MagicMock. Queste due componenti sono molto importanti per ottenere il mocking in Python.

Una chiamata di funzione fittizia di solito restituisce immediatamente un valore predefinito. Anche gli attributi e i metodi dell'oggetto fittizio sono definiti nel test, senza creare l'oggetto reale.

Mocking consente inoltre di restituire valori predefiniti a ciascuna chiamata di funzione durante la scrittura dei test. Questo ti permette di avere più controllo durante i test.

Prerequisiti

Mock è disponibile in Python 3, ma se stai usando una versione di Python qui sotto
3.3, puoi ancora usarlo unittest.mock importandolo come una libreria separata come questa.

$ pip installa mock

Benefici di derisione

Alcuni dei vantaggi del beffeggiamento includono:

1. Evitare troppe dipendenze. Il mocking riduce la dipendenza delle funzioni. Ad esempio, se hai una funzione di classe A che dipende da una funzione B, dovrai scrivere alcuni test unitari che coprono le funzionalità fornite dalla funzione B. Diciamo che il codice cresce in futuro e hai più funzioni, cioè A dipende su B, B dipende da C, e C dipende da D. Se viene introdotto un errore in Z, tutti i test delle unità falliranno.
2. Sovraccarico ridotto. Questo vale per le funzioni ad alta intensità di risorse. Una simulazione di tale funzione ridurrebbe l'uso non necessario delle risorse durante i test, riducendo quindi i tempi di esecuzione dei test.
3. Bypass vincoli di tempo nelle funzioni. Questo vale per le attività programmate. Immagina un processo che è stato programmato per essere eseguito ogni ora. In una situazione del genere, prendere in giro la sorgente del tempo consente di testare in modo unitario tale logica in modo che il test non debba essere eseguito per ore, in attesa che passi il tempo.

uso

Utilizzo di finto è semplice come:

>>> da mock import Mock >>> mock = Mock (return_values ​​= 10) >>> mock (1,4, foo = 'bar')  >>> mock.return_values ​​10 

Qui, importiamo il modulo mock, creiamo un oggetto mock e specifichiamo i valori di ritorno. Quando viene chiamato l'oggetto mock, vogliamo che sia in grado di restituire alcuni valori. Nel nostro caso, vogliamo che l'oggetto mock restituisca un valore di 10. Se chiamiamo l'oggetto fittizio con gli argomenti (1, 4, foo = 'bar'), il risultato sarà il valore 10, che è stato definito come valore di ritorno.

Puoi anche sollevare eccezioni all'interno di mock come segue:

>>> mock = Mock (side_effect = KeyError ('foobar')) >>> mock () Traceback (ultima chiamata ultima): ... KeyError: 'foobar'

Il effetti collaterali argomento ti permette di eseguire determinate cose come sollevare un'eccezione quando viene chiamata una finta.

Esempio

Considera questa semplice funzione:

richieste di importazione def api (): response = requests.get ('https://www.google.com/') risposta di risposta

Questa funzione esegue una richiesta API alla pagina web di Google e restituisce una risposta.

Il caso di test semplice corrispondente sarà il seguente:

import unittest dalla classe di importazione principale TetsApi (unittest.TestCase): def test_api (self): assert api () == 200

Eseguendo il test precedente dovrebbe dare un risultato simile:

---------------------------------------------------------------------- Ran 1 test in 3.997s OK 

Introduciamo il mocking in questo esempio e il test risultante con il modulo Mock sarà come mostrato di seguito:

import unittest da mock import Mock da mock import patch import richieste import unittest class TetsApi (unittest.TestCase): def test_api (self): con patch.object (request, 'get') as get_mock: get_mock.return_value = mock_response = Mock ( ) mock_response.status_code = 200 assert api () == 200

Eseguendo il test precedente dovrebbe dare un risultato simile:

---------------------------------------------------------------------- Ran 1 test in 0.001s OK

Come visto sopra, il modulo di simulazione impiega meno tempo per effettuare la stessa chiamata API del caso di test normale.

Esempio più grande

Supponiamo che tu abbia uno script che interagisce con un'API esterna e che effettui chiamate a tale API ogni volta che viene chiamata una determinata funzione. In questo esempio, useremo l'API di Twitter per implementare uno script Python che pubblicherà sulla pagina del profilo di Twitter.

Non vogliamo pubblicare messaggi su Twitter ogni volta che testiamo lo script, ed è qui che entra in gioco Mocking.

Iniziamo. Useremo la libreria python-twitter e la prima cosa che faremo è creare una cartella python_mock e, all'interno della cartella, creare due file, vale a dire tweet.py e mock_test.py.

Scrivi il seguente codice nel file tweet.py.

# Pip install python-twitter importazione di Twitter # definiscono credenziali di autenticazione consumer_key = consumer_secret 'iYD2sKY4NC8teRb9BUM8UguRa' = access_token_key 'uW3tHdH6UAqlxA7yxmcr8FSMSzQIBIpcC4NNS7jrvkxREdJ15m' = '314.746.354-Ucq36TRDnfGAxpOVtnK1qZxMfRKzFHFhyRqzNpTx7wZ1qHS0qycy0aNjoMDpKhcfzuLm6uAbhB2LilxZzST8w' access_token_secret = '7wZ1qHS0qycy0aNjoMDpKhcfzuLm6uAbhB2LilxZzST8w' def post_tweet (api, Tweet): # messaggio di stato Tweet = api.PostUpdate (tweet) return status def main (): api = twitter.Api (consumer_key = consumer_key, consumer_secret = consumer_secret, access_token_key = access_token_key, access_token_secret = access_token_secret) message = raw_input ("Inserisci il tuo tweet:") post_tweet (api, message) se __name__ == '__main__': main () 

Nel codice sopra, prima importiamo la libreria di Twitter e poi definiamo le credenziali di autenticazione, che puoi facilmente ottenere dalla pagina delle app di Twitter.

L'API di Twitter è esposta tramite twitter.Api classe, quindi creiamo la classe passando i nostri token e le nostre chiavi segrete.

Il post_tweet la funzione accetta un oggetto di autenticazione e il messaggio e quindi pubblica il tweet sul profilo Twitter.

Quindi procediamo e prendiamo in giro la chiamata API a Twitter in modo che l'API non invii messaggi su Twitter ogni volta che viene chiamata. Vai avanti e apri il mock_test.py file e aggiungi il seguente codice.

# mock_test.py #! / usr / bin / env python import unittest da mock import Mock import tweet class TweetTest (unittest.TestCase): def test_example (self): mock_twitter = Mock () tweet.post_tweet (mock_twitter, "Creazione di un task Manager App Using Ionic: Part 1 ") mock_twitter.PostUpdate.assert_called_with (" Creazione di un'app Task Manager tramite Ionic: parte 1 ") se __name__ == '__main__': unittest.main ()

Eseguendo il test precedente dovrebbe dare un risultato simile:

---------------------------------------------------------------------- Ran 1 test in 0.001s OK 

Conclusione

Questo tutorial ha coperto la maggior parte delle nozioni di base di mocking e come utilizzare il mocking per eseguire chiamate API esterne. Per ulteriori informazioni, visitare la documentazione di mocking ufficiale di Python. In questo tutorial puoi trovare ulteriori risorse sull'autenticazione con l'API di Twitter.

Inoltre, non esitare a vedere ciò che abbiamo a disposizione per la vendita e per studiare nel mercato Envato, e per favore vai avanti e fai tutte le domande e fornisci il tuo prezioso feedback usando il feed qui sotto.