Introducere în batjocură în Python

Mocking este o bibliotecă de testare în Python. Vă permite să înlocuiți componente ale sistemului dvs. cu obiecte machete și să faceți afirmații despre modul în care au fost folosite. Acest tutorial va discuta în detaliu ce este batjocoritor și cum se utilizează în aplicațiile Python.

Ce e batjocoritor?

Mocking este o bibliotecă pentru testarea în Python, care vă permite să înlocuiți părți ale sistemului dvs. cu test cu obiecte machete și să faceți afirmații despre modul în care au fost folosite.

În Python, batjocura se realizează prin înlocuirea unor părți ale sistemului cu obiecte machete utilizând modulul unittesttest.mock. Acest modul conține o serie de clase și funcții utile, și anume funcția de patch-uri (ca decorator și manager de context) și clasa MagicMock. Aceste două componente sunt foarte importante pentru a obține o batjocură în Python.

Un apel funcțional momeală returnează imediat o valoare predefinită. Modele și metode ale unui obiect machete sunt definite și în test, fără a crea obiectul real.

Mocking vă permite, de asemenea, să returnați valorile predefinite la fiecare apel al funcției atunci când scrieți teste. Acest lucru vă permite să aveți mai mult control atunci când testați.

Cerințe preliminare

Mock este disponibil în Python 3, dar dacă utilizați o versiune Python de mai jos
3.3, puteți utiliza în continuare unittest.mock prin importul ca o bibliotecă separată, așa cum este.

$ pip instalează mock

Beneficii de batjocură

Unele dintre avantajele de batjocură includ:

Evitarea prea multor dependențe. Mockingul reduce dependența funcțiilor. De exemplu, dacă aveți o funcție A de clasă care depinde de o funcție B, va trebui să scrieți câteva teste unitare care acoperă funcțiile oferite de funcția B. Să presupunem că codul crește în viitor și că aveți mai multe funcții, adică A depinde pe B, B depinde de C, iar C depinde de D. Dacă este introdusă o eroare în Z, toate testele unității vor eșua.
Suprasarcină redusă. Acest lucru se aplică în cazul funcțiilor cu resurse intensive. O martoră a acestei funcții ar reduce consumul inutil de resurse în timpul testării, reducând astfel timpul de funcționare a testului.
Bypass constrângerile de timp în funcții. Acest lucru se aplică activităților programate. Imaginați-vă un proces care a fost programat să se execute la fiecare oră. Într-o astfel de situație, batjocorirea sursei de timp vă permite de fapt unitatea de testare a unei astfel de logici, astfel încât testul dvs. nu trebuie să funcționeze timp de ore, așteptând timpul să treacă.

folosire

Utilizarea a-și bate joc este simplu ca:

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

Aici, importăm modulul mock, creăm un obiect fals și specificăm valorile returnate. Când se cheamă obiectul mock, dorim ca acesta să poată returna anumite valori. În cazul nostru, dorim ca obiect mock pentru a reveni o valoare de 10. Dacă vom numi obiect mock cu argumente (1, 4, foo = 'bar'), rezultatul va fi valoarea 10, care a fost definită ca valoare de retur.

Puteți, de asemenea, să ridicați excepții în mocks după cum urmează:

>>> mock = Mock (side_effect = KeyError ('foobar') >>> macheta () Traceback (ultimul apel ultimul): ... KeyError:

efecte secundare argument vă permite să efectuați anumite lucruri, cum ar fi ridicarea unei excepții atunci când este apelat un mock.

Exemplu

Luați în considerare această funcție simplă:

cereri de import def api (): răspuns = requests.get ('https://www.google.com/') răspunsul la întoarcere

Această funcție efectuează o solicitare API pe pagina web Google și returnează un răspuns.

Cazul simplu de testare corespunzător va fi după cum urmează:

import unitatetest din clasa principală de import api TetsApi (unittest.TestCase): def test_api (self): assert api () == 200

Rularea testului de mai sus ar trebui să dea o ieșire cum ar fi:

---------------------------------------------------------------------- Testul Ran 1 în 3.997 este OK

Să introducem o batjocură la acest exemplu, iar testul rezultat cu modulul Mock va fi așa cum este arătat mai jos:

import unitatetest de la importul mocked Mock de la machete import import patch import cereri classtest TetsApi (unittest.TestCase): def test_api (self): cu patch.object (requests, 'get') ca get_mock: get_mock.return_value = mock_response = ) mock_response.status_code = 200 afirmare api () == 200

Rularea testului de mai sus ar trebui să dea o ieșire cum ar fi:

---------------------------------------------------------------------- Ran 1 test în 0.001s OK

După cum am văzut mai sus, modulul de batjocură durează mai puțin timp pentru a face același apel API ca și cazul normal de testare.

Exemplu mai mare

Să presupunem că aveți un script care interacționează cu un API extern și face apeluri către respectivul API ori de câte ori este apelată o anumită funcție. În acest exemplu, vom folosi API-ul Twitter pentru a implementa un script Python care va fi postat pe pagina de profil Twitter.

Nu vrem să trimitem mesaje pe Twitter de fiecare dată când testăm scenariul și acolo intră Mocking.

Să începem. Vom folosi biblioteca python-twitter și primul lucru pe care îl vom face este crearea unui dosar python_mock și, în interiorul dosarului, creați două fișiere, și anume tweet.py și mock_test.py.

Scrieți următorul cod în fișier tweet.py.

# Pip install-piton twitter import twitter # definesc acreditările de autentificare consumer_key = consumer_secret 'iYD2sKY4NC8teRb9BUM8UguRa' = access_token_key 'uW3tHdH6UAqlxA7yxmcr8FSMSzQIBIpcC4NNS7jrvkxREdJ15m' = '314746354-Ucq36TRDnfGAxpOVtnK1qZxMfRKzFHFhyRqzNpTx7wZ1qHS0qycy0aNjoMDpKhcfzuLm6uAbhB2LilxZzST8w' access_token_secret = '7wZ1qHS0qycy0aNjoMDpKhcfzuLm6uAbhB2LilxZzST8w' def post_tweet (api, tweet): # posta status tweet = api.PostUpdate (tweet) starea de returnare def principal (): 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 (" __name__ == '__main__': main ()

În codul de mai sus, vom importa mai întâi biblioteca Twitter și apoi vom defini acreditările de autentificare, pe care le puteți obține cu ușurință de pe pagina Aplicații Twitter.

API - ul Twitter este expus prin twitter.Api clasa, astfel încât să creăm clasa trecând cheile și cheile noastre secrete.

post_tweet funcția ia un obiect de autentificare și mesajul și apoi publică tweet-ul în profilul Twitter.

Apoi continuăm și batem apelul API către Twitter, astfel încât API-ul să nu posteze pe Twitter de fiecare dată când este chemat. Mergeți și deschideți mock_test.py fișier și adăugați următorul cod.

# mock_test.py #! / usr / bin / env Python import unitatetest de la mock import Mock import tweet class TweetTest (unittest.TestCase): def test_example (auto): mock_twitter = Mock () tweet.post_tweet (mock_twitter, Aplicația Manager folosind Ionic: Partea 1 ") mock_twitter.PostUpdate.assert_called_with (" Crearea unui aplicație Manager de activități utilizând Ionic: Partea 1 ") dacă __name__ == '__main__': unittest.main ()

Rularea testului de mai sus ar trebui să dea o ieșire cum ar fi:

---------------------------------------------------------------------- Ran 1 test în 0.001s OK

Concluzie

Acest tutorial a acoperit cele mai multe dintre fundamentele de batjocură și cum să utilizați batjocorirea pentru a efectua apeluri externe API. Pentru mai multe informații, vizitați documentația oficială Python. De asemenea, puteți găsi resurse suplimentare pentru autentificare cu API-ul Twitter în acest tutorial.

În plus, nu ezitați să vedeți ceea ce avem la dispoziție pentru vânzare și pentru studiul pe piața Envato și vă rugăm să continuați și să puneți întrebări și să oferiți feedback-ul dvs. valoros utilizând feedul de mai jos.

Cod