Added a lot of unit tests

tests/unit_tests/test_gestion_sports_connector.py

@@ -0,0 +1,315 @@
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from aiohttp import ClientSession
+from connectors import GestionSportsConnector
+
+
+def make_landing_request_success(aioresponses, connector, landing_response):
+    aioresponses.get(
+        connector.landing_url,
+        status=200,
+        headers={"Set-Cookie": "PHPSESSID=987512"},
+        body=landing_response,
+    )
+
+
+def make_login_request_fail(aioresponses, connector, login_failure_response):
+    aioresponses.post(
+        connector.login_url,
+        status=200,
+        payload=login_failure_response,
+    )
+
+
+def make_login_request_success(aioresponses, connector, login_success_response):
+    aioresponses.post(
+        connector.login_url,
+        status=200,
+        headers={"Set-Cookie": "COOK_COMPTE=e2be1;" "COOK_ID_CLUB=22;COOK_ID_USER=666"},
+        payload=login_success_response,
+    )
+
+
+def set_booking_request(aioresponses, connector, booking_response):
+    aioresponses.post(connector.booking_url, status=200, payload=booking_response)
+
+
+def set_full_booking_requests_responses(aioresponses, connector, responses_list):
+    make_landing_request_success(aioresponses, connector, responses_list[0])
+    make_login_request_success(aioresponses, connector, responses_list[1])
+    for response in responses_list[2:]:
+        set_booking_request(aioresponses, connector, response)
+
+
+def set_ongoing_bookings_response(
+    aioresponses, connector, user_bookings_get_response, user_bookings_post_response
+):
+    set_hash_response(aioresponses, connector, user_bookings_get_response)
+    set_bookings_response(aioresponses, connector, user_bookings_post_response)
+
+
+def set_hash_response(aioresponses, connector, user_bookings_get_response):
+    aioresponses.get(
+        connector.user_bookings_url, status=200, body=user_bookings_get_response
+    )
+
+
+def set_bookings_response(aioresponses, connector, user_bookings_post_response):
+    aioresponses.post(
+        connector.user_bookings_url, status=200, payload=user_bookings_post_response
+    )
+
+
+def set_full_user_bookings_responses(aioresponses, connector, responses):
+    make_landing_request_success(aioresponses, connector, responses[0])
+    make_login_request_success(aioresponses, connector, responses[1])
+    set_ongoing_bookings_response(aioresponses, connector, *responses[2:])
+
+
+def set_cancellation_response(aioresponses, connector, response):
+    aioresponses.post(connector.booking_cancellation_url, status=200, payload=response)
+
+
+def set_full_cancellation_by_id_responses(aioresponses, connector, responses):
+    make_landing_request_success(aioresponses, connector, responses[0])
+    make_login_request_success(aioresponses, connector, responses[1])
+    set_hash_response(aioresponses, connector, responses[2])
+    set_cancellation_response(aioresponses, connector, responses[3])
+
+
+def set_full_cancellation_responses(aioresponses, connector, responses):
+    make_landing_request_success(aioresponses, connector, responses[0])
+    make_login_request_success(aioresponses, connector, responses[1])
+
+    # the request to get the hash is made twice
+    set_hash_response(aioresponses, connector, responses[2])
+    set_hash_response(aioresponses, connector, responses[2])
+
+    set_bookings_response(aioresponses, connector, responses[3])
+    set_cancellation_response(aioresponses, connector, responses[4])
+
+
+def test_urls(a_club):
+    connector = GestionSportsConnector(a_club)
+    base_url = a_club.booking_platform.url
+    relative_urls = a_club.booking_platform.urls
+
+    relative_landing_url = relative_urls.get("landing-page").path
+    assert connector.landing_url == f"{base_url}/{relative_landing_url}"
+
+    relative_login_url = relative_urls.get("login").path
+    assert connector.login_url == f"{base_url}/{relative_login_url}"
+
+    relative_booking_url = relative_urls.get("booking").path
+    assert connector.booking_url == f"{base_url}/{relative_booking_url}"
+
+    relative_user_bookings_url = relative_urls.get("user-bookings").path
+    assert connector.user_bookings_url == f"{base_url}/{relative_user_bookings_url}"
+
+    relative_cancel_url = relative_urls.get("cancellation").path
+    assert connector.booking_cancellation_url == f"{base_url}/{relative_cancel_url}"
+
+
+@patch("config.get_resources_folder")
+def test_urls_payload_templates(mock_resources, a_club):
+    path_to_resources = Path("some/path/to/resource")
+    mock_resources.return_value = path_to_resources
+
+    connector = GestionSportsConnector(a_club)
+    relative_urls = a_club.booking_platform.urls
+
+    login_payload = relative_urls.get("login").payload_template
+    assert connector.login_template == path_to_resources / login_payload
+
+    booking_payload = relative_urls.get("booking").payload_template
+    assert connector.booking_template == path_to_resources / booking_payload
+
+    user_bookings_payload = relative_urls.get("user-bookings").payload_template
+    assert connector.user_bookings_template == path_to_resources / user_bookings_payload
+
+    cancel_payload = relative_urls.get("cancellation").payload_template
+    assert connector.booking_cancel_template == path_to_resources / cancel_payload
+
+
+@pytest.mark.asyncio
+async def test_landing_page(aioresponses, connector, landing_response):
+    make_landing_request_success(aioresponses, connector, landing_response)
+
+    async with ClientSession() as session:
+        response = await connector.land(session)
+
+    assert response.status == 200
+    assert response.cookies.get("PHPSESSID").value == "987512"
+    assert await response.text() == landing_response
+
+
+@pytest.mark.asyncio
+async def test_login_success(aioresponses, connector, user, login_success_response):
+    make_login_request_success(aioresponses, connector, login_success_response)
+
+    async with ClientSession() as session:
+        response = await connector.login(session, user)
+
+    assert response.status == 200
+    assert response.cookies.get("COOK_COMPTE").value == "e2be1"
+    assert response.cookies.get("COOK_ID_CLUB").value == "22"
+    assert response.cookies.get("COOK_ID_USER").value == "666"
+    assert await response.json() == login_success_response
+
+
+@pytest.mark.asyncio
+async def test_login_failure(aioresponses, connector, user, login_failure_response):
+    make_login_request_fail(aioresponses, connector, login_failure_response)
+
+    async with ClientSession() as session:
+        response = await connector.login(session, user)
+
+    assert response.status == 200
+    assert len(response.cookies) == 0
+    assert await response.json() == login_failure_response
+
+
+@pytest.mark.asyncio
+async def test_booking_success(
+    aioresponses,
+    connector,
+    user,
+    booking_filter,
+    booking_success_from_start,
+):
+    set_full_booking_requests_responses(
+        aioresponses, connector, booking_success_from_start
+    )
+
+    court_booked = await connector.book(user, booking_filter)
+
+    assert court_booked.id == 2
+
+
+@pytest.mark.asyncio
+async def test_booking_failure(
+    aioresponses,
+    connector,
+    user,
+    booking_filter,
+    booking_failure_from_start,
+):
+    set_full_booking_requests_responses(
+        aioresponses, connector, booking_failure_from_start
+    )
+
+    court_booked = await connector.book(user, booking_filter)
+
+    assert court_booked is None
+
+
+@pytest.mark.asyncio
+async def test_get_ongoing_bookings(
+    aioresponses,
+    connector,
+    user,
+    user_bookings_get_response,
+    user_bookings_list,
+):
+    set_ongoing_bookings_response(
+        aioresponses, connector, user_bookings_get_response, user_bookings_list
+    )
+
+    async with ClientSession() as session:
+        bookings = await connector.get_ongoing_bookings(session)
+
+    assert len(bookings) == 2
+
+
+@pytest.mark.asyncio
+async def test_get_ongoing_bookings(
+    aioresponses,
+    connector,
+    user,
+    user_bookings_get_response,
+    user_bookings_list,
+):
+    set_ongoing_bookings_response(
+        aioresponses, connector, user_bookings_get_response, user_bookings_list
+    )
+
+    async with ClientSession() as session:
+        bookings = await connector.get_ongoing_bookings(session)
+
+    assert len(bookings) == 2
+
+
+@pytest.mark.asyncio
+async def test_has_user_ongoing_bookings(
+    aioresponses,
+    connector,
+    user,
+    user_has_ongoing_bookings_from_start,
+):
+    set_full_user_bookings_responses(
+        aioresponses, connector, user_has_ongoing_bookings_from_start
+    )
+
+    has_bookings = await connector.has_user_ongoing_booking(user)
+
+    assert has_bookings
+
+
+@pytest.mark.asyncio
+async def test_has_user_ongoing_bookings(
+    aioresponses,
+    connector,
+    user,
+    user_has_no_ongoing_bookings_from_start,
+):
+    set_full_user_bookings_responses(
+        aioresponses, connector, user_has_no_ongoing_bookings_from_start
+    )
+    has_bookings = await connector.has_user_ongoing_booking(user)
+
+    assert not has_bookings
+
+
+@pytest.mark.asyncio
+async def test_cancellation_request(
+    aioresponses, connector, user_bookings_get_response, cancellation_response
+):
+    set_hash_response(aioresponses, connector, user_bookings_get_response)
+    set_cancellation_response(aioresponses, connector, cancellation_response)
+
+    async with ClientSession() as session:
+        response = await connector.send_cancellation_request(session, 123)
+
+    assert await response.json() == cancellation_response
+
+
+@pytest.mark.asyncio
+async def test_cancel_booking_id(
+    aioresponses, connector, user, cancellation_by_id_from_start
+):
+    set_full_cancellation_by_id_responses(
+        aioresponses, connector, cancellation_by_id_from_start
+    )
+
+    response = await connector.cancel_booking_id(user, 132)
+
+    assert await response.json() == cancellation_by_id_from_start[3]
+
+
+@pytest.mark.asyncio
+async def test_cancel_booking_success(
+    aioresponses,
+    connector,
+    user,
+    cancellation_success_booking_filter,
+    cancellation_success_from_start,
+):
+    set_full_cancellation_responses(
+        aioresponses, connector, cancellation_success_from_start
+    )
+
+    response = await connector.cancel_booking(user, cancellation_success_booking_filter)
+
+    assert await response.json() == cancellation_success_from_start[4]