Unité testant une application python utilisant la bibliothèque de requêtes

Question

J'écris une application qui effectue des opérations REST à l'aide de la bibliothèque de requêtes de Kenneth Reitz et j'ai du mal à trouver un moyen intéressant de tester ces applications, car les requêtes fournissent ses méthodes via des méthodes au niveau du module.

Ce que je veux, c'est pouvoir synthétiser la conversation entre les deux parties. fournir une série d'affirmations de demande et de réponses.

Answer 1

Si vous utilisez demandes essayez httmock. Il est merveilleusement simple et élégant:

from httmock import urlmatch, HTTMock
import requests

# define matcher:
@urlmatch(netloc=r'(.*\.)?google\.com$')
def google_mock(url, request):
    return 'Feeling lucky, punk?'

# open context to patch
with HTTMock(google_mock):
    # call requests
    r = requests.get('http://google.com/')
print r.content  # 'Feeling lucky, punk?'

Si vous voulez quelque chose de plus générique (par exemple, pour se moquer de n'importe quelle bibliothèque faisant appel http) aller pour httpretty.

Presque comme elegent:

import requests
import httpretty

@httpretty.activate
def test_one():
    # define your patch:
    httpretty.register_uri(httpretty.GET, "http://yipit.com/",
                        body="Find the best daily deals")
    # use!
    response = requests.get('http://yipit.com')
    assert response.text == "Find the best daily deals"

HTTPretty est beaucoup plus riche en fonctionnalités, il offre aussi moqueur code d'état, streaming réponses, la rotation des réponses, des réponses dynamiques (avec un rappel).

Answer 2

Vous pouvez utiliser un moqueur bibliothèque comme Moqueur à intercepter les appels à la demande de la bibliothèque et de rendre un certain nombre de résultats.

Comme un exemple très simple, considérer cette classe qui utilise les demandes de la bibliothèque:

class MyReq(object):
    def doSomething(self):
        r = requests.get('https://api.github.com', auth=('user', 'pass'))
        return r.headers['content-type']

Voici un test unitaire qui intercepte l'appel à requests.get et renvoie un résultat déterminé pour les tests:

import unittest
import requests
import myreq

from mocker import Mocker, MockerTestCase

class MyReqTests(MockerTestCase):
    def testSomething(self):
        # Create a mock result for the requests.get call
        result = self.mocker.mock()
        result.headers
        self.mocker.result({'content-type': 'mytest/pass'})

        # Use mocker to intercept the call to requests.get
        myget = self.mocker.replace("requests.get")
        myget('https://api.github.com', auth=('user', 'pass'))
        self.mocker.result(result)

        self.mocker.replay()

        # Now execute my code
        r = myreq.MyReq()
        v = r.doSomething()

        # and verify the results
        self.assertEqual(v, 'mytest/pass')
        self.mocker.verify()

if __name__ == '__main__':
    unittest.main()

Lorsque j'exécute ce test j'obtiens le résultat suivant:

.
----------------------------------------------------------------------
Ran 1 test in 0.004s

OK

Answer 3

en se moquant comme dans la réponse de srgerg:

 def replacer(method, endpoint, json_string):
    from mocker import Mocker, ANY, CONTAINS
    mocker = Mocker()
    result = mocker.mock()
    result.json()
    mocker.count(1, None)
    mocker.result(json_string)
    replacement = mocker.replace("requests." + method)
    replacement(CONTAINS(endpoint), params=ANY)
    self.mocker.result(result)
    self.mocker.replay()
 

Pour la bibliothèque de requêtes, cela intercepterait la requête en fonction de la méthode et du noeud final que vous frappez et remplacerait le fichier .json () de la réponse par la chaîne json transmise.