¿Cómo puedo burlarme de las solicitudes y la respuesta?

Estoy tratando de usar el paquete simulado Pythons para simular el requestsmódulo Pythons . ¿Cuáles son las llamadas básicas para que trabaje en el siguiente escenario?

En mi views.py, tengo una función que hace una variedad de llamadas request.get () con diferentes respuestas cada vez

def myview(request):
  res1 = requests.get('aurl')
  res2 = request.get('burl')
  res3 = request.get('curl')

En mi clase de prueba quiero hacer algo como esto, pero no puedo entender las llamadas a métodos exactos

Paso 1:

# Mock the requests module
# when mockedRequests.get('aurl') is called then return 'a response'
# when mockedRequests.get('burl') is called then return 'b response'
# when mockedRequests.get('curl') is called then return 'c response'

Paso 2:

Llama mi vista

Paso 3:

verificar respuesta contiene 'una respuesta', 'b respuesta', 'c respuesta'

¿Cómo puedo completar el Paso 1 (burlándose del módulo de solicitudes)?

Así es como puede hacerlo (puede ejecutar este archivo tal cual):

import requests
import unittest
from unittest import mock

# This is the class we want to test
class MyGreatClass:
    def fetch_json(self, url):
        response = requests.get(url)
        return response.json()

# This method will be used by the mock to replace requests.get
def mocked_requests_get(*args, **kwargs):
    class MockResponse:
        def __init__(self, json_data, status_code):
            self.json_data = json_data
            self.status_code = status_code

        def json(self):
            return self.json_data

    if args[0] == 'http://someurl.com/test.json':
        return MockResponse({"key1": "value1"}, 200)
    elif args[0] == 'http://someotherurl.com/anothertest.json':
        return MockResponse({"key2": "value2"}, 200)

    return MockResponse(None, 404)

# Our test case class
class MyGreatClassTestCase(unittest.TestCase):

    # We patch 'requests.get' with our own method. The mock object is passed in to our test case method.
    @mock.patch('requests.get', side_effect=mocked_requests_get)
    def test_fetch(self, mock_get):
        # Assert requests.get calls
        mgc = MyGreatClass()
        json_data = mgc.fetch_json('http://someurl.com/test.json')
        self.assertEqual(json_data, {"key1": "value1"})
        json_data = mgc.fetch_json('http://someotherurl.com/anothertest.json')
        self.assertEqual(json_data, {"key2": "value2"})
        json_data = mgc.fetch_json('http://nonexistenturl.com/cantfindme.json')
        self.assertIsNone(json_data)

        # We can even assert that our mocked method was called with the right parameters
        self.assertIn(mock.call('http://someurl.com/test.json'), mock_get.call_args_list)
        self.assertIn(mock.call('http://someotherurl.com/anothertest.json'), mock_get.call_args_list)

        self.assertEqual(len(mock_get.call_args_list), 3)

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

Nota importante: si su MyGreatClassclase vive en un paquete diferente, digamos my.great.package, debe burlarse en my.great.package.requests.getlugar de simplemente 'request.get'. En ese caso, su caso de prueba se vería así:

import unittest
from unittest import mock
from my.great.package import MyGreatClass

# This method will be used by the mock to replace requests.get
def mocked_requests_get(*args, **kwargs):
    # Same as above


class MyGreatClassTestCase(unittest.TestCase):

    # Now we must patch 'my.great.package.requests.get'
    @mock.patch('my.great.package.requests.get', side_effect=mocked_requests_get)
    def test_fetch(self, mock_get):
        # Same as above

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

¡Disfrutar!

Intenta usar la biblioteca de respuestas . Aquí hay un ejemplo de su documentación :

import responses
import requests

@responses.activate
def test_simple():
    responses.add(responses.GET, 'http://twitter.com/api/1/foobar',
                  json={'error': 'not found'}, status=404)

    resp = requests.get('http://twitter.com/api/1/foobar')

    assert resp.json() == {"error": "not found"}

    assert len(responses.calls) == 1
    assert responses.calls[0].request.url == 'http://twitter.com/api/1/foobar'
    assert responses.calls[0].response.text == '{"error": "not found"}'

Proporciona una comodidad bastante agradable sobre la configuración de todas las burlas usted mismo.

También hay HTTPretty :

No es específico de la requestsbiblioteca, de alguna manera es más potente, aunque descubrí que no se presta muy bien para inspeccionar las solicitudes que interceptó, lo que responseses bastante fácil.

También hay httmock .

Esto es lo que funcionó para mí:

import mock
@mock.patch('requests.get', mock.Mock(side_effect = lambda k:{'aurl': 'a response', 'burl' : 'b response'}.get(k, 'unhandled request %s'%k)))

Usé peticiones simuladas para escribir pruebas para un módulo separado:

# module.py
import requests

class A():

    def get_response(self, url):
        response = requests.get(url)
        return response.text

Y las pruebas:

# tests.py
import requests_mock
import unittest

from module import A


class TestAPI(unittest.TestCase):

    @requests_mock.mock()
    def test_get_response(self, m):
        a = A()
        m.get('http://aurl.com', text='a response')
        self.assertEqual(a.get_response('http://aurl.com'), 'a response')
        m.get('http://burl.com', text='b response')
        self.assertEqual(a.get_response('http://burl.com'), 'b response')
        m.get('http://curl.com', text='c response')
        self.assertEqual(a.get_response('http://curl.com'), 'c response')

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

así es como se burlan de request.post, cámbielo a su método http

@patch.object(requests, 'post')
def your_test_method(self, mockpost):
    mockresponse = Mock()
    mockpost.return_value = mockresponse
    mockresponse.text = 'mock return'

    #call your target method now

Si desea burlarse de una respuesta falsa, otra forma de hacerlo es simplemente instanciar una instancia de la clase base HttpResponse, de esta manera:

from django.http.response import HttpResponseBase

self.fake_response = HttpResponseBase()

Una posible forma de evitar las solicitudes es usar la biblioteca betamax, registra todas las solicitudes y luego, si realiza una solicitud en la misma URL con los mismos parámetros, betamax usará la solicitud registrada, la he estado usando para probar el rastreador web y me ahorró mucho tiempo

import os

import requests
from betamax import Betamax
from betamax_serializers import pretty_json


WORKERS_DIR = os.path.dirname(os.path.abspath(__file__))
CASSETTES_DIR = os.path.join(WORKERS_DIR, u'resources', u'cassettes')
MATCH_REQUESTS_ON = [u'method', u'uri', u'path', u'query']

Betamax.register_serializer(pretty_json.PrettyJSONSerializer)
with Betamax.configure() as config:
    config.cassette_library_dir = CASSETTES_DIR
    config.default_cassette_options[u'serialize_with'] = u'prettyjson'
    config.default_cassette_options[u'match_requests_on'] = MATCH_REQUESTS_ON
    config.default_cassette_options[u'preserve_exact_body_bytes'] = True


class WorkerCertidaoTRT2:
    session = requests.session()

    def make_request(self, input_json):
        with Betamax(self.session) as vcr:
            vcr.use_cassette(u'google')
            response = session.get('http://www.google.com')

https://betamax.readthedocs.io/en/latest/

Solo una sugerencia útil para aquellos que todavía están luchando, convirtiendo de urllib o urllib2 / urllib3 a solicitudes Y tratando de burlarse de una respuesta: recibí un error un poco confuso al implementar mi simulación:

with requests.get(path, auth=HTTPBasicAuth('user', 'pass'), verify=False) as url:

AttributeError: __enter__

Bueno, por supuesto, si supiera algo sobre cómo withfunciona (no lo sé), sabría que es un contexto vestigial e innecesario (de PEP 343 ). Innecesario cuando se utiliza la biblioteca de solicitudes, ya que básicamente hace lo mismo para usted bajo el capó . Solo quítatelo withy usa desnudo requests.get(...)y Bob es tu tío .

Agregaré esta información ya que me costó mucho imaginarme cómo burlarme de una llamada API asíncrona.

Esto es lo que hice para burlarme de una llamada asincrónica.

Aquí está la función que quería probar

async def get_user_info(headers, payload):
    return await httpx.AsyncClient().post(URI, json=payload, headers=headers)

Aún necesitas la clase MockResponse

class MockResponse:
    def __init__(self, json_data, status_code):
        self.json_data = json_data
        self.status_code = status_code

    def json(self):
        return self.json_data

Agrega la clase MockResponseAsync

class MockResponseAsync:
    def __init__(self, json_data, status_code):
        self.response = MockResponse(json_data, status_code)

    async def getResponse(self):
        return self.response

Aquí está la prueba. Lo importante aquí es crear la respuesta antes, ya que la función init no puede ser asíncrona y la llamada a getResponse es asíncrona, por lo que todo se verificó.

@pytest.mark.asyncio
@patch('httpx.AsyncClient')
async def test_get_user_info_valid(self, mock_post):
    """test_get_user_info_valid"""
    # Given
    token_bd = "abc"
    username = "bob"
    payload = {
        'USERNAME': username,
        'DBNAME': 'TEST'
    }
    headers = {
        'Authorization': 'Bearer ' + token_bd,
        'Content-Type': 'application/json'
    }
    async_response = MockResponseAsync("", 200)
    mock_post.return_value.post.return_value = async_response.getResponse()

    # When
    await api_bd.get_user_info(headers, payload)

    # Then
    mock_post.return_value.post.assert_called_once_with(
        URI, json=payload, headers=headers)

Si tienes una mejor manera de hacerlo, dímelo pero creo que es bastante limpio así.