def test_getReasons():
# Test offline
def app(request: httpx.Request) -> httpx.Response:
assert (re.match(
r"/v1/solar/entities/[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/reasons",
request.url.path,
) != None)
path = Path("tests/fixtures/ordoclic/reasons.json")
return httpx.Response(200, json=json.loads(path.read_text()))
client = httpx.Client(transport=httpx.MockTransport(app))
data_file = Path("tests/fixtures/ordoclic/reasons.json")
data = json.loads(data_file.read_text())
assert get_reasons("e9c4990e-711f-4af6-aee2-354de59c9e4e", client) == data
# Test erreur HTTP
def app(request: httpx.Request) -> httpx.Response:
return httpx.Response(403, json={})
client = httpx.Client(transport=httpx.MockTransport(app))
assert get_reasons("e9c4990e-711f-4af6-aee2-354de59c9e4e", client) is None
# Test timeout
def app2(request: httpx.Request) -> httpx.Response:
raise httpx.TimeoutException(message="Timeout", request=request)
client = httpx.Client(transport=httpx.MockTransport(app2))
assert get_reasons("e9c4990e-711f-4af6-aee2-354de59c9e4e", client) is None
# Test online
schema_file = Path("tests/fixtures/ordoclic/reasons.schema")
schema = json.loads(schema_file.read_text())
live_data = get_reasons("e9c4990e-711f-4af6-aee2-354de59c9e4e")
validate(instance=live_data, schema=schema)
def test_search():
# Test offline
def app(request: httpx.Request) -> httpx.Response:
assert request.url.path == "/api/Organizations/public/covid"
path = Path("tests/fixtures/avecmondoc/search-result.json")
return httpx.Response(200,
json=json.loads(path.read_text(encoding="utf8")))
client = httpx.Client(transport=httpx.MockTransport(app))
data_file = Path("tests/fixtures/avecmondoc/search-result.json")
data = json.loads(data_file.read_text(encoding="utf8"))
assert search(client=client) == data
# Test erreur HTTP
def response_unavailable(request: httpx.Request) -> httpx.Response:
return httpx.Response(403, json={})
client = httpx.Client(transport=httpx.MockTransport(response_unavailable))
assert search(client) is None
# Test timeout
def response_timeout(request: httpx.Request) -> httpx.Response:
raise httpx.TimeoutException(message="Timeout", request=request)
client = httpx.Client(transport=httpx.MockTransport(response_timeout))
assert search(client) is None
# Test online
schema_file = Path("tests/fixtures/avecmondoc/search-result.schema")
schema = json.loads(schema_file.read_text())
live_data = search()
if live_data:
validate(instance=live_data, schema=schema)
def test_keldoc_requests():
# Timeout test
def app_timeout(request: httpx.Request) -> httpx.Response:
raise httpx.TimeoutException(message="Timeout", request=request)
client = httpx.Client(transport=httpx.MockTransport(app_timeout))
scraper = KeldocCenterScraper(session=client)
assert not scraper.send_keldoc_request("https://keldoc.com")
# Status test
def app_status(request: httpx.Request) -> httpx.Response:
res = httpx.Response(403, json={})
raise httpx.HTTPStatusError(message="status error",
request=request,
response=res)
client = httpx.Client(transport=httpx.MockTransport(app_status))
scraper = KeldocCenterScraper(session=client)
assert not scraper.send_keldoc_request("https://keldoc.com")
# Remote error test
def app_remote_error(request: httpx.Request) -> httpx.Response:
res = httpx.Response(403, json={})
raise httpx.RemoteProtocolError(message="status error",
request=request)
client = httpx.Client(transport=httpx.MockTransport(app_remote_error))
scraper = KeldocCenterScraper(session=client)
assert not scraper.send_keldoc_request("https://keldoc.com")
def test_fetch():
def app(requested: httpx.Request) -> httpx.Response:
assert "User-Agent" in requested.headers
return httpx.Response(responsecode, json=slots)
bimedoc.PLATFORM_ENABLED = True
center_data = dict()
center_data = json.load(io.open(TEST_CENTRE_INFO, "r", encoding="utf-8-sig"))
center_info = CenterInfo.from_csv_data(center_data)
# This center has availabilities and should return a date, non null appointment_count and vaccines
request = ScraperRequest(
"https://server.bimedoc.com/vmd/pharmacy-with-slots/9cf46288-0080-4a8d-8856-8e9998ced9f7?start_date=2021-08-10&end_date=2021-08-17",
"2021-08-10",
center_info,
)
slots = json.load(io.open(Path("tests", "fixtures", "bimedoc", "slots_available.json"), "r", encoding="utf-8-sig"))
# Response 200
responsecode = 200
client = httpx.Client(transport=httpx.MockTransport(app))
center_with_availability = bimedoc.BimedocSlots(client=client)
response = center_with_availability.fetch(request)
assert response == "2021-08-11T08:15:00Z"
# Response 403
responsecode = 403
client = httpx.Client(transport=httpx.MockTransport(app))
center_with_availability = bimedoc.BimedocSlots(client=client)
with pytest.raises(Exception):
response = center_with_availability.fetch(request)
assert response == None
def test_fetch():
def app(requested: httpx.Request) -> httpx.Response:
assert "User-Agent" in requested.headers
return httpx.Response(responsecode, json=slots)
valwin.PLATFORM_ENABLED = True
center_data = dict()
center_data = json.load(io.open(TEST_CENTRE_INFO, "r", encoding="utf-8-sig"))
center_info = CenterInfo.from_csv_data(center_data)
# This center has availabilities and should return a date, non null appointment_count and vaccines
request = ScraperRequest(
"https://pharma-api.epharmacie.pro/global/api/meetings/v2/pharmabest75-plateau-lyon/slots",
"2021-08-10",
center_info,
)
slots = json.load(io.open(Path("tests", "fixtures", "valwin", "slots_available.json"), "r", encoding="utf-8-sig"))
# Response 200
responsecode = 200
client = httpx.Client(transport=httpx.MockTransport(app))
center_with_availability = valwin.Slots(client=client)
response = center_with_availability.fetch(request)
assert response == "2021-09-17T10:00:00"
# Response 403
responsecode = 403
client = httpx.Client(transport=httpx.MockTransport(app))
center_with_availability = valwin.Slots(client=client)
with pytest.raises(Exception):
response = center_with_availability.fetch(request)
assert response == None
async def test_mounted_transport():
transport = httpx.MockTransport(unmounted)
mounts = {"custom://": httpx.MockTransport(mounted)}
async with httpx.AsyncClient(transport=transport, mounts=mounts) as client:
response = await client.get("https://www.example.com")
assert response.status_code == 200
assert response.json() == {"app": "unmounted"}
response = await client.get("custom://www.example.com")
assert response.status_code == 200
assert response.json() == {"app": "mounted"}
def test_fetch():
mesoigner.PLATFORM_ENABLED = True
center_data = dict()
center_data = json.load(
io.open(TEST_CENTRE_INFO, "r", encoding="utf-8-sig"))
center_info = CenterInfo.from_csv_data(center_data)
# This center has availabilities and should return a date, non null appointment_count and vaccines
request = ScraperRequest(
"https://pharmacie-des-pyrenees.pharmaxv.fr/rendez-vous/vaccination/269-vaccination-covid-19/pre-inscription",
"2021-06-16",
center_info,
)
slots = json.load(
io.open(Path("tests", "fixtures", "mesoigner", "slots_available.json"),
"r",
encoding="utf-8-sig"))
def app(requested: httpx.Request) -> httpx.Response:
assert "User-Agent" in requested.headers
return httpx.Response(200, json=slots)
client = httpx.Client(transport=httpx.MockTransport(app))
center_with_availability = mesoigner.MesoignerSlots(client=client)
response = center_with_availability.fetch(request)
assert response == "2021-06-16T14:50:00+02:00"
def test_keldoc_timeout():
center1_url = "https://vaccination-covid.keldoc.com/centre-hospitalier-regional/foo/bar?specialty=no"
def app(request: httpx.Request) -> httpx.Response:
if request.url.path == "/centre-hospitalier-regional/foo/bar":
raise TimeoutError
if request.url.path == "/api/patients/v2/searches/resource":
raise TimeoutError
if request.url.path == "/api/patients/v2/clinics/1/specialties/1/cabinets":
raise TimeoutError
return httpx.Response(200, json={})
client = httpx.Client(transport=httpx.MockTransport(app))
request = ScraperRequest(center1_url, "2020-04-04")
test_center_1 = KeldocCenter(request, client=client)
# Test center info TA
with pytest.raises(TimeoutError):
test_center_1.parse_resource()
with pytest.raises(TimeoutError):
test_center_1.fetch_center_data()
# Test cabinet TA
test_center_1.id = 1
test_center_1.vaccine_specialties = [1]
with pytest.raises(TimeoutError):
test_center_1.fetch_vaccine_cabinets()
assert not test_center_1.vaccine_cabinets
def test_blocked_by_doctolib_par_availabilities():
# Cas de base.
start_date = "2021-04-03"
base_url = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
scrap_request = ScraperRequest(base_url, start_date)
def app(request: httpx.Request) -> httpx.Response:
assert "User-Agent" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib", "basic-booking.json")
return httpx.Response(200, json=json.loads(path.read_text()))
return httpx.Response(403, text="Anti dDos")
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client, cooldown_interval=0)
error = None
try:
next_date = slots.fetch(scrap_request)
except Exception as e:
error = e
assert True is isinstance(error, BlockedByDoctolibError)
def test_doctolib_motive_categories():
# Certains centres opèrent une distinction de motifs pour les professionnels de santé /
# non professionnels de santé.
# On doit gérer ces cas-là.
start_date = "2021-04-03"
base_url = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
scrap_request = ScraperRequest(base_url, start_date)
def app(request: httpx.Request) -> httpx.Response:
assert "User-Agent" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib",
"category-booking.json")
return httpx.Response(200, json=json.loads(path.read_text()))
assert request.url.path == "/availabilities.json"
path = Path("tests", "fixtures", "doctolib",
"category-availabilities.json")
return httpx.Response(200, json=json.loads(path.read_text()))
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client, cooldown_interval=0)
next_date = slots.fetch(scrap_request)
assert next_date == '2021-04-10'
def test_keldoc_parse_center():
center1_url = "https://vaccination-covid.keldoc.com/centre-hospitalier-regional/lorient-56100/groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff?cabinet=16913&specialty=144"
path = Path("tests", "fixtures", "keldoc", "center1-cabinet-16913.json")
input_data = json.loads(path.read_text(encoding="utf-8"))
request = ScraperRequest(center1_url, "2020-04-04", input_data=input_data)
client = httpx.Client(transport=httpx.MockTransport(app_center1))
test_center_1 = KeldocCenter(request, client=client)
# Fetch vaccine cabinets
cabinets = filter_vaccine_motives(test_center_1.appointment_motives)
agendas = []
for match in cabinets:
agendas.extend(match.get("agendas"))
agendas = list(set(agendas))
assert agendas == [51414, 49335]
# Fetch motives
motives = filter_vaccine_motives(test_center_1.appointment_motives)
assert motives == json.loads(
Path("tests", "fixtures", "keldoc",
"center1-motives.json").read_text())
# Find first availability date
fake_now = dt.datetime(2020, 4, 4, 8, 15)
with mock_datetime_now(fake_now):
date, count = test_center_1.find_first_availability("2020-04-04")
assert not date
test_center_1.vaccine_motives = motives
with mock_datetime_now(fake_now):
date, count = test_center_1.find_first_availability("2020-04-04")
tz = datetime.timezone(datetime.timedelta(seconds=7200))
assert date == datetime.datetime(2021, 4, 20, 16, 55, tzinfo=tz)
def test_blocked_by_doctolib_par_centre():
# Cas de base.
start_date = "2021-04-03"
base_url = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
scrap_request = ScraperRequest(base_url, start_date)
def app(request: httpx.Request) -> httpx.Response:
assert "User-Agent" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib", "basic-booking.json")
return httpx.Response(403, text="Anti dDos")
assert request.url.path == "/availabilities.json"
params = dict(httpx.QueryParams(request.url.query))
assert params == {
"start_date": start_date,
"visit_motive_ids": "2",
"agenda_ids": "3",
"insurance_sector": "public",
"practice_ids": "4",
"destroy_temporary": "true",
"limit": str(DOCTOLIB_CONF.pagination["pages"]),
}
path = Path("tests", "fixtures", "doctolib", "basic-availabilities.json")
return httpx.Response(200, json=json.loads(path.read_text(encoding="utf-8")))
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client, cooldown_interval=0)
with pytest.raises(BlockedByDoctolibError):
slots.fetch(scrap_request)
async def test_async_event_hooks():
events = []
async def on_request(request):
events.append({"event": "request", "headers": dict(request.headers)})
async def on_response(response):
events.append({"event": "response", "headers": dict(response.headers)})
event_hooks = {"request": [on_request], "response": [on_response]}
async with httpx.AsyncClient(
event_hooks=event_hooks, transport=httpx.MockTransport(app)
) as http:
await http.get("http://127.0.0.1:8000/", auth=("username", "password"))
assert events == [
{
"event": "request",
"headers": {
"host": "127.0.0.1:8000",
"user-agent": f"python-httpx/{httpx.__version__}",
"accept": "*/*",
"accept-encoding": "gzip, deflate, br",
"connection": "keep-alive",
"authorization": "Basic dXNlcm5hbWU6cGFzc3dvcmQ=",
},
},
{
"event": "response",
"headers": {"server": "testserver"},
},
]
def test_fragment_redirect():
client = httpx.Client(transport=httpx.MockTransport(redirects))
response = client.get("https://example.org/relative_redirect#fragment",
follow_redirects=True)
assert response.status_code == httpx.codes.OK
assert response.url == "https://example.org/#fragment"
assert len(response.history) == 1
def test_redirect_302():
client = httpx.Client(transport=httpx.MockTransport(redirects))
response = client.post("https://example.org/redirect_302",
follow_redirects=True)
assert response.status_code == httpx.codes.OK
assert response.url == "https://example.org/"
assert len(response.history) == 1
def test_doctolib():
# Cas de base.
start_date = "2021-04-03"
rdv_site_web = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
def app(request: httpx.Request) -> httpx.Response:
assert "X-Covid-Tracker-Key" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib", "basic-booking.json")
return httpx.Response(200, json=json.loads(path.read_text()))
assert request.url.path == "/availabilities.json"
params = dict(httpx.QueryParams(request.url.query))
assert params == {
"start_date": start_date,
"visit_motive_ids": "2",
"agenda_ids": "3",
"insurance_sector": "public",
"practice_ids": "4",
"destroy_temporary": "true",
"limit": str(DOCTOLIB_SLOT_LIMIT),
}
path = Path("tests", "fixtures", "doctolib",
"basic-availabilities.json")
return httpx.Response(200, json=json.loads(path.read_text()))
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client)
next_date = slots.fetch(rdv_site_web, start_date)
assert next_date == "2021-04-10"
def test_blocked_by_doctolib_par_availabilities():
# Cas de base.
start_date = "2021-04-03"
base_url = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
center_info = CenterInfo(departement="07",
nom="Mon Super Centre",
url=base_url)
scrap_request = ScraperRequest(base_url, start_date, center_info)
def app(request: httpx.Request) -> httpx.Response:
assert "User-Agent" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib", "basic-booking.json")
return httpx.Response(200,
json=json.loads(
path.read_text(encoding="utf-8")))
return httpx.Response(403, text="Anti dDos")
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client, cooldown_interval=0)
with pytest.raises(Blocked403):
slots.fetch(scrap_request)
def test_keldoc_parse_complex():
center1_url = "https://vaccination-covid.keldoc.com/centre-hospitalier-regional/lorient-56100/groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff?cabinet=16913&specialty=144"
path = Path("tests", "fixtures", "keldoc", "center1-cabinet-16913.json")
input_data = json.loads(path.read_text(encoding="utf-8"))
request = ScraperRequest(center1_url, "2020-04-04", input_data=input_data)
client = httpx.Client(transport=httpx.MockTransport(app_center1))
test_center_1 = KeldocCenter(request, client=client)
# Fetch vaccine cabinets
cabinets = filter_vaccine_motives(test_center_1.appointment_motives)
appointments = []
data = {
"availabilities": {
"2021-04-20": [
{
"start_time": "2021-04-20T16:53:00.000000+0200"
},
{
"start_time": "2021-04-20T16:50:00.000000+0200"
},
{
"start_time": "2021-04-20T18:59:59.000000+0200"
},
],
"2021-04-21": [{
"start_time": "2021-04-21T08:12:12.000000+0200"
}],
}
}
availability, new_count = parse_keldoc_availability(
test_center_1, data, appointments)
assert availability.isoformat() == "2021-04-20T16:50:00+02:00"
def test_cross_domain_redirect_with_auth_header():
client = httpx.Client(transport=httpx.MockTransport(redirects))
url = "https://example.com/cross_domain"
headers = {"Authorization": "abc"}
response = client.get(url, headers=headers, follow_redirects=True)
assert response.url == "https://example.org/cross_domain_target"
assert "authorization" not in response.json()["headers"]
def test_client_decode_text_using_explicit_encoding():
# Ensure that a 'default_encoding="..."' on the response is used for text decoding
# when no "Content-Type: text/plain; charset=..."" info is present.
#
# Here we have some french text encoded with ISO-8859-1, rather than UTF-8.
text = (
"Non-seulement Despréaux ne se trompait pas, mais de tous les écrivains "
"que la France a produits, sans excepter Voltaire lui-même, imprégné de "
"l'esprit anglais par son séjour à Londres, c'est incontestablement "
"Molière ou Poquelin qui reproduit avec l'exactitude la plus vive et la "
"plus complète le fond du génie français."
)
def cp1252_but_no_content_type(request):
content = text.encode("ISO-8859-1")
return httpx.Response(200, content=content)
transport = httpx.MockTransport(cp1252_but_no_content_type)
with httpx.Client(transport=transport, default_encoding=autodetect) as client:
response = client.get("http://www.example.com")
assert response.status_code == 200
assert response.reason_phrase == "OK"
assert response.encoding == "ISO-8859-1"
assert response.text == text
def test_keldoc_motives_connect_error():
center1_url = (
"https://vaccination-covid.keldoc.com/centre-hospitalier-regional/lorient-56100/groupe-hospitalier"
"-bretagne-sud-lorient-hopital-du-scorff?specialty=144 ")
center1_data = json.loads(
Path("tests", "fixtures", "keldoc", "center1-info.json").read_text())
request = ScraperRequest(center1_url, "2020-04-04")
def mock_client(request: httpx.Request) -> httpx.Response:
if request.url.path == "/api/patients/v2/searches/resource":
raise httpx.ConnectError("Unable to connect", request=request)
if (request.url.path ==
"/centre-hospitalier-regional/lorient-56100/groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff"
):
return httpx.Response(
302,
headers={
"Location":
"https://vaccination-covid.keldoc.com/redirect/?dom=centre-hospitalier-regional&inst=lorient-56100&user=groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff&specialty=144 "
},
)
for path in CENTER1_KELDOC:
if request.url.path == path:
return httpx.Response(200,
json=get_test_data(CENTER1_KELDOC[path]))
return httpx.Response(200, json={})
client = httpx.Client(transport=httpx.MockTransport(mock_client))
test_center_1 = KeldocCenter(request, client=client)
assert not test_center_1.vaccine_motives
def test_malformed_redirect():
# https://github.com/encode/httpx/issues/771
client = httpx.Client(transport=httpx.MockTransport(redirects))
response = client.get("http://example.org/malformed_redirect")
assert response.status_code == httpx.codes.OK
assert response.url == "https://example.org:443/"
assert len(response.history) == 1
def test_no_center_data():
path_centerinfo = Path("tests", "fixtures", "keldoc",
"cabinet-16913-centerinfo.json")
centerinfo_1 = json.loads(path_centerinfo.read_text(encoding="utf-8"))
center_info = CenterInfo.from_csv_data(centerinfo_1)
center1_url = "https://www.keldoc.com/centre-hospitalier-regional/lorient-56100/groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff?specialty=144"
request = ScraperRequest(center1_url,
"2020-04-04",
center_info=center_info)
def app(request: httpx.Request) -> httpx.Response:
if (request.url.path ==
"/centre-hospitalier-regional/lorient-56100/groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff"
):
return httpx.Response(
302,
headers={
"Location":
"https://vaccination-covid.keldoc.com/redirect/?dom=centre-hospitalier-regional&inst=lorient-56100&user=groupe-hospitalier-bretagne-sud-lorient-hopital-du-scorff&specialty=144 "
},
)
if request.url.path == "/redirect/":
return httpx.Response(200, json={})
return httpx.Response(403, json={})
keldoc.session = httpx.Client(transport=httpx.MockTransport(app))
date = fetch_slots(request)
assert not date
def test_same_domain_redirect():
client = httpx.Client(transport=httpx.MockTransport(redirects))
url = "https://example.org/cross_domain"
headers = {"Authorization": "abc"}
response = client.get(url, headers=headers)
assert response.url == "https://example.org/cross_domain_target"
assert response.json()["headers"]["authorization"] == "abc"
def test_fetch_slots():
def app(request: httpx.Request) -> httpx.Response:
try:
with open(Path("tests", "fixtures", "mapharma", "slots.json"),
encoding="utf8") as f:
return httpx.Response(200, content=f.read())
except IOError:
return httpx.Response(404, content="")
client = httpx.Client(transport=httpx.MockTransport(app))
request = ScraperRequest("https://mapharma.net/97200?c=60&l=1",
"2021-04-14")
first_availability = fetch_slots(request,
client,
opendata_file=TEST_OPEN_DATA_FILE)
assert first_availability == "2021-04-19T17:15:00"
# test campagne["total_libres"]: 0
request = ScraperRequest("https://mapharma.net/88400?c=92&l=1",
"2021-04-14")
first_availability = fetch_slots(request,
client,
opendata_file=TEST_OPEN_DATA_FILE)
assert first_availability == None
def test_can_stream_if_no_redirect():
client = httpx.Client(transport=httpx.MockTransport(redirects))
url = "https://example.org/redirect_301"
with client.stream("GET", url, allow_redirects=False) as response:
assert not response.is_closed
assert response.status_code == httpx.codes.MOVED_PERMANENTLY
assert response.headers["location"] == "https://example.org/"
def test_doctolib_next_slot():
# Cas de repli : c'est surprenant, mais parfois la liste des dispos
# est vide, mais il y a un champ 'next_slot' qui contient la date de
# la prochaine visite, que l'on utilise dans ce cas.
start_date = "2021-04-03"
base_url = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
scrap_request = ScraperRequest(base_url, start_date)
def app(request: httpx.Request) -> httpx.Response:
assert "User-Agent" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib",
"next-slot-booking.json")
return httpx.Response(200, json=json.loads(path.read_text()))
assert request.url.path == "/availabilities.json"
path = Path("tests", "fixtures", "doctolib",
"next-slot-availabilities.json")
return httpx.Response(200, json=json.loads(path.read_text()))
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client, cooldown_interval=0)
next_date = slots.fetch(scrap_request)
# Next slot should not be used
assert next_date is None
def test_redirect_cookie_behavior():
client = httpx.Client(transport=httpx.MockTransport(cookie_sessions))
# The client is not logged in.
response = client.get("https://example.com/")
assert response.url == "https://example.com/"
assert response.text == "Not logged in"
# Login redirects to the homepage, setting a session cookie.
response = client.post("https://example.com/login")
assert response.url == "https://example.com/"
assert response.text == "Logged in"
# The client is logged in.
response = client.get("https://example.com/")
assert response.url == "https://example.com/"
assert response.text == "Logged in"
# Logout redirects to the homepage, expiring the session cookie.
response = client.post("https://example.com/logout")
assert response.url == "https://example.com/"
assert response.text == "Not logged in"
# The client is not logged in.
response = client.get("https://example.com/")
assert response.url == "https://example.com/"
assert response.text == "Not logged in"
def test_doctolib():
# Cas de base.
start_date = "2021-04-03"
base_url = "https://partners.doctolib.fr/centre-de-vaccinations-internationales/ville1/centre1?pid=practice-165752&enable_cookies_consent=1" # noqa
scrap_request = ScraperRequest(base_url, start_date)
def app(request: httpx.Request) -> httpx.Response:
assert "User-Agent" in request.headers
if request.url.path == "/booking/centre1.json":
path = Path("tests", "fixtures", "doctolib", "basic-booking.json")
return httpx.Response(200, json=json.loads(path.read_text()))
assert request.url.path == "/availabilities.json"
params = dict(httpx.QueryParams(request.url.query))
path = Path("tests", "fixtures", "doctolib",
"basic-availabilities.json")
return httpx.Response(200, json=json.loads(path.read_text()))
client = httpx.Client(transport=httpx.MockTransport(app))
slots = DoctolibSlots(client=client, cooldown_interval=0)
next_date = slots.fetch(scrap_request)
assert next_date == '2021-04-10'
def test_setting_client_cookies_to_cookiejar() -> None:
"""
Send a request including a cookie, using a `CookieJar` instance.
"""
url = "http://example.org/echo_cookies"
cookies = CookieJar()
cookie = Cookie(
version=0,
name="example-name",
value="example-value",
port=None,
port_specified=False,
domain="",
domain_specified=False,
domain_initial_dot=False,
path="/",
path_specified=True,
secure=False,
expires=None,
discard=True,
comment=None,
comment_url=None,
rest={"HttpOnly": ""},
rfc2109=False,
)
cookies.set_cookie(cookie)
client = httpx.Client(
cookies=cookies, transport=httpx.MockTransport(get_and_set_cookies)
)
response = client.get(url)
assert response.status_code == 200
assert response.json() == {"cookies": "example-name=example-value"}
