Test een client zonder server

Elke controle van who_am_i en trail_httpx tot nu toe had een server nodig: pl_http startte de jouwe, en de bibliotheken praatten ermee. Tests horen dat niet te doen. In Networks with Python testte je socketcode door die via een geïnjecteerde functie connect een vervangende socket te geven. In Python in Practice testte je een requests-functie door haar een vervangende sessie mee te geven. Beide bibliotheken in dit hoofdstuk hebben een plek waar een vervanger past, en deze les gebruikt ze allebei.

Een transport is de naad (seam)

Een httpx-client doet zijn HTTP-werk in twee lagen. De client bouwt het verzoek, volgt doorverwijzingen, bewaart cookies en past de time-out toe. Daaronder neemt een transport één afgewerkt verzoek, haalt er één antwoord voor op en geeft dat terug. Normaal opent het transport een verbinding. httpx.MockTransport is een transport dat in plaats daarvan een functie van jou aanroept:

import httpx

def answer(request):
    if request.url.path == "/v0/books/2":
        return httpx.Response(308, headers={"location": "/books/2"})
    return httpx.Response(200, json={"id": 2, "title": "Café Society", "author": "Ana Ruiz"})

client = httpx.Client(transport=httpx.MockTransport(answer))

De functie, vaak een handler genoemd, krijgt een httpx.Request en geeft een httpx.Response terug. Het verzoek bevat alles wat de client zou hebben verstuurd: request.method, request.url.path, request.headers (met host er al in) en request.content, de body als bytes. httpx.Response(200, json=...) codeert de JSON en voegt content-type: application/json voor je toe.

Alles boven het transport draait zoals gewoonlijk. Wanneer answer de 308 teruggeeft en de aanroep follow_redirects=True meegaf, lost de client de location op, bouwt het volgende verzoek en roept answer opnieuw aan met pad /books/2. Op geen enkel moment wordt er een socket geopend; de handler is de hele server.

Een functie aan een andere functie meegeven is iets wat je doet sinds de geïnjecteerde connect in Networks with Python. Hier is de handler de waarde, en MockTransport roept hem aan.

De handler kan ook de time-out zien. httpx hangt die aan elk verzoek als request.extensions["timeout"], een dict van de vier fasen. Met de HTTPX_TIMEOUT van de cursus, httpx.Timeout(2.0, connect=1.0), is dat {'connect': 1.0, 'read': 2.0, 'write': 2.0, 'pool': 2.0}; zonder opgegeven time-out is elke fase de 5.0 van httpx. Een handler die elk verzoek, of de delen waar hij om geeft, aan een lijst toevoegt, laat een test achteraf controleren wat er verstuurd is.

De vervangende sessie die je kent

requests heeft ook transports, maar who_am_i neemt een hele sessie, dus de vervanger kan een hele sessie zijn. Open fakes.py. fake_session(replies, calls) geeft een object terug met request, get, post, put en delete, de methoden die who_am_i aanroept. Elke aanroep voegt een dict toe aan je lijst calls, met elk keyword dat requests zou hebben ontvangen: method, url, params, headers, json, auth, timeout, allow_redirects. Daarna antwoordt hij met het volgende item van replies, of werpt het op als dat item een exception is.

fake_response(status, data) bouwt de antwoorden. Het heeft status_code, json(), headers die hoofdletterongevoelig zijn, en een raise_for_status() die requests.HTTPError opwerpt bij 4xx en 5xx, dus who_am_i draait er ongewijzigd tegen:

calls = []
replies = [fakes.fake_response(200, {"user": "ana"}), fakes.fake_response(200, {"user": "ana"})]
session = fakes.fake_session(replies, calls)

Nadat who_am_i gedraaid heeft, is calls[0] de login en calls[1] de /me. Een test kan nu met een assert controleren wat geen server je rechtstreeks zou laten zien: de inloggegevens die in auth zijn meegegeven, en de time-out van elke aanroep.

Test via de module

Je tests worden ook gecontroleerd. Check my work draait ze tegen je eigen side_by_side.py, en daarna opnieuw met één functie vervangen door een versie met een fout, om te zien of een test dat merkt. Hij zet elke versie op haar plek door haar op de module in te stellen, side_by_side.trail_httpx = .... Een test die side_by_side.trail_httpx(...) aanroept, zoekt de naam op op het moment dat hij draait, dus hij treft de versie die er op dat moment staat. Een regel from side_by_side import trail_httpx kopieert het origineel naar een eigen naam in je testbestand, en de verwisseling bereikt die nooit.

De versies met fouten zijn de versies waarnaar de twee tests van deze les vernoemd zijn: een trail_httpx die de doorverwijzing niet volgt, en een who_am_i waarvan de GET /me geen time-out meegeeft. Een test die alleen de time-out van de loginaanroep controleert, slaagt bij de tweede, dus controleer beide aanroepen.

Je opdracht

Beide functies nemen hun vervanger na de * in hun definitie, dus een test geeft hem bij naam mee, als client=client of session=session:

def trail_httpx(url, *, client=None, timeout=HTTPX_TIMEOUT):
    ...

def who_am_i(base_url, user, password, *, session, timeout=TIMEOUT):
    ...

Vervang in tests/test_side_by_side.py de twee plaatshouders die assert False, "not written yet" zeggen:

1. test_trail_httpx_follows_a_redirect: schrijf een handler die voor het ene pad 308 met een location antwoordt en voor het volgende 200, maak een client met httpx.MockTransport(handler), roep side_by_side.trail_httpx(url, client=client) aan, en controleer met een assert dat het spoor beide regels bevat, de 308 eerst.

2. test_who_am_i_sends_credentials_and_timeouts: geef side_by_side.who_am_i een fakes.fake_session met twee antwoorden en een time-out naar keuze, en controleer daarna met asserts de teruggegeven waarde, de auth van de loginaanroep en de timeout van beide aanroepen.

Namen en extra tests zijn aan jou. Elke test moet zijn eigen vervanger aan de functie meegeven; een test die client of session weglaat, zou een netwerk nodig hebben, en faalt hier. Draai alleen dit bestand, want tests/test_client.py wacht op les 6:

python -m pytest -q tests/test_side_by_side.py

Het zou 2 passed moeten melden, of meer als je er meer schreef. Klik daarna op Check my work. Les 5 bekijkt de regels die beide bibliotheken versturen zonder dat iemand erom vroeg.