Big refactoring.

- clubs, booking platforms and user are now defined in customization files -> there are less environment variables
- the responsibility of the session moved
- booking cancellation is available

tests/fixtures.py

@@ -3,19 +3,16 @@ from pathlib import Path
 
 import pendulum
 import pytest
-from gestion_sports.payload_builders import GestionSportsBookingPayloadBuilder
 
-from resa_padel.models import BookingFilter, Club, User
+from resa_padel.models import BookingFilter, User
 
 user = User(login="padel.testing@jouf.fr", password="ridicule", club_id="123")
-url = "https://tpc.padel.com"
-club = Club(id="123", url=url, courts_ids=[606, 607, 608])
 
 courts = [606, 607, 608]
-sport_id = 217
+sport_name = "padel"
 tz_info = "Europe/Paris"
 booking_date = pendulum.now().add(days=6).set(hour=18, minute=0, second=0, tz=tz_info)
-booking_filter = BookingFilter(sport_id=sport_id, date=booking_date)
+booking_filter = BookingFilter(sport_name=sport_name, date=booking_date)
 
 booking_failure_response = json.dumps(
     {
@@ -36,12 +33,6 @@ booking_success_response = json.dumps(
 
 date_format = "%d/%m/%Y"
 time_format = "%H:%M"
-booking_payload = (
-    GestionSportsBookingPayloadBuilder()
-    .booking_filter(booking_filter)
-    .court_id(courts[0])
-    .build()
-)
 
 html_file = Path(__file__).parent / "data" / "mes_resas.html"
 _mes_resas_html = html_file.read_text(encoding="utf-8")
@@ -57,11 +48,6 @@ def a_booking_filter() -> BookingFilter:
     return booking_filter
 
 
-@pytest.fixture
-def a_club() -> Club:
-    return club
-
-
 @pytest.fixture
 def a_booking_success_response() -> str:
     return booking_success_response
@@ -72,11 +58,6 @@ def a_booking_failure_response() -> str:
     return booking_failure_response
 
 
-@pytest.fixture
-def a_booking_payload() -> str:
-    return booking_payload
-
-
 @pytest.fixture
 def mes_resas_html() -> str:
     return _mes_resas_html

tests/gestion_sports/test_gestion_sports_payload_builder.py

@@ -1,8 +1,9 @@
-from resa_padel.gestion_sports.payload_builders import (
+from payload_builders import (
     GestionSportsBookingPayloadBuilder,
     GestionSportsLoginPayloadBuilder,
     GestionSportsUsersBookingsPayloadBuilder,
 )
+
 from tests.fixtures import a_booking_filter, a_club, a_user
 
 

tests/test_booking.py

@@ -1,77 +1,70 @@
+import asyncio
 import os
 from unittest.mock import patch
 
+import config
 import pendulum
-from aioresponses import aioresponses
-from models import BookingFilter, Club
-from pendulum import Time
+from models import BookingFilter, User
 
 from resa_padel import booking
-from tests import fixtures, utils
-from tests.fixtures import (
-    a_booking_failure_response,
-    a_booking_success_response,
-    mes_resas_html,
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
 )
+def test_real_booking():
+    club = config.get_club()
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+    booking_filter = BookingFilter(
+        sport_name="Padel", date=pendulum.parse("2024-03-21T13:30:00+01:00")
+    )
+    booked_court, user_that_booked = asyncio.run(
+        booking.book_court(club, [user], booking_filter)
+    )
+    assert booked_court is not None
+    assert user_that_booked == user
 
-login = "user"
-password = "password"
-available_credentials = login + ":" + password + ",some_user:some_password"
-club_id = "88"
-court_id = "11"
-paris_tz = "Europe/Paris"
-datetime_to_book = (
-    pendulum.now().add(days=6).set(hour=18, minute=0, second=0, tz=paris_tz)
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
 )
+def test_real_cancellation():
+    club = config.get_club()
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+    asyncio.run(booking.cancel_booking_id(club, user, 3605033))
 
 
-@patch("pendulum.now")
 @patch.dict(
     os.environ,
     {
-        "LOGIN": login,
-        "PASSWORD": password,
-        "CLUB_ID": club_id,
-        "CLUB_URL": fixtures.url,
-        "COURT_IDS": "7,8,10",
-        "SPORT_ID": "217",
-        "DATE_TIME": datetime_to_book.isoformat(),
-        "AVAILABLE_USERS_CREDENTIALS": available_credentials,
+        "CLUB_ID": "tpc",
+        "ACTION": "book",
+        "SPORT_NAME": "Padel",
+        "DATE_TIME": "2024-03-21T13:30:00+01:00",
     },
     clear=True,
 )
-def test_main(
-    mock_now,
-    a_booking_success_response: str,
-    a_booking_failure_response: str,
-    mes_resas_html: str,
-):
-    """
-    Test the main function to book a court
+def test_main_booking():
+    court, user = booking.main()
+    assert court is not None
+    assert user.username == "padel.testing@jouf"
 
-    :param mock_now: the pendulum.now() mock
-    :param a_booking_success_response: the success json response
-    :param a_booking_failure_response: the failure json response
-    """
-    booking_filter = BookingFilter(sport_id=666, date=datetime_to_book)
-    club = Club(
-        id="club",
-        url="some.url",
-        courts_ids=[7, 8, 10],
-        booking_open_days_before=7,
-        booking_opening_time=Time(hour=0, minute=0),
-    )
-    booking_datetime = utils.retrieve_booking_datetime(booking_filter, club)
-    mock_now.side_effect = [booking_datetime]
 
-    with aioresponses() as aio_mock:
-        utils.mock_rest_api_from_connection_to_booking(
-            aio_mock,
-            fixtures.url,
-            a_booking_failure_response,
-            a_booking_success_response,
-            mes_resas_html,
-        )
-
-        court_booked = booking.main()
-        assert court_booked == 8
+@patch.dict(
+    os.environ,
+    {
+        "CLUB_ID": "tpc",
+        "ACTION": "cancel",
+        "SPORT_NAME": "Padel",
+        "DATE_TIME": "2024-03-21T13:30:00+01:00",
+        "LOGIN": "padel.testing@jouf.fr",
+        "PASSWORD": "ridicule",
+    },
+    clear=True,
+)
+def test_main_cancellation():
+    booking.main()

tests/test_config.py

@@ -2,40 +2,20 @@ import os
 from unittest.mock import patch
 
 import config
-from pendulum import DateTime, Time, Timezone
+from pendulum import DateTime, Timezone
 
 
 @patch.dict(
     os.environ,
     {
-        "CLUB_URL": "club.url",
-        "COURT_IDS": "7,8,10",
-        "CLUB_ID": "666",
-        "BOOKING_OPEN_DAYS_BEFORE": "5",
-        "BOOKING_OPENING_TIME": "18:37",
-    },
-    clear=True,
-)
-def test_get_club():
-    club = config.get_club()
-    assert club.url == "club.url"
-    assert club.courts_ids == [7, 8, 10]
-    assert club.id == "666"
-    assert club.booking_open_days_before == 5
-    assert club.booking_opening_time == Time(hour=18, minute=37)
-
-
-@patch.dict(
-    os.environ,
-    {
-        "SPORT_ID": "666",
+        "SPORT_NAME": "Padel",
         "DATE_TIME": "2024-02-03T22:38:45Z",
     },
     clear=True,
 )
 def test_get_booking_filter():
     booking_filter = config.get_booking_filter()
-    assert booking_filter.sport_id == 666
+    assert booking_filter.sport_id == "padel"
     assert booking_filter.date == DateTime(
         year=2024,
         month=2,
@@ -61,14 +41,11 @@ def test_get_available_user():
     assert user.password == "gloups"
 
 
-@patch.dict(
-    os.environ,
-    {"AVAILABLE_USERS_CREDENTIALS": "login@user.tld:gloups,other@user.tld:patatras"},
-    clear=True,
-)
-def test_user():
-    users = config.get_available_users()
-    assert users[0].login == "login@user.tld"
-    assert users[0].password == "gloups"
-    assert users[1].login == "other@user.tld"
-    assert users[1].password == "patatras"
+def test_read_clubs():
+    clubs = config.get_clubs()
+    assert len(clubs) == 2
+
+
+def test_get_users():
+    users = config.get_users("tpc")
+    assert len(users) == 2

tests/test_connectors.py

@@ -0,0 +1,411 @@
+import os
+from pathlib import Path
+from unittest.mock import patch
+
+import aiohttp
+import config
+import pendulum
+import pytest
+from aiohttp import ClientSession
+from connectors import GestionSportsConnector
+from models import Booking, BookingFilter, User
+from yarl import URL
+
+from tests import utils
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+def test_urls():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    assert (
+        connector.landing_url
+        == "https://toulousepadelclub.gestion-sports.com/connexion.php"
+    )
+    assert (
+        connector.login_url
+        == "https://toulousepadelclub.gestion-sports.com/connexion.php"
+    )
+    assert (
+        connector.booking_url
+        == "https://toulousepadelclub.gestion-sports.com/membre/reservation.html"
+    )
+    assert (
+        connector.user_bookings_url
+        == "https://toulousepadelclub.gestion-sports.com/membre/mesresas.html"
+    )
+    assert (
+        connector.booking_cancellation_url
+        == "https://toulousepadelclub.gestion-sports.com/membre/mesresas.html"
+    )
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc", "RESOURCES_FOLDER": "/some/path"},
+    clear=True,
+)
+def test_urls_payload_templates():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    resources_folder = Path("/some", "path", "gestion-sports")
+    assert connector.login_template == resources_folder / "login-payload.txt"
+    assert connector.booking_template == resources_folder / "booking-payload.txt"
+    assert (
+        connector.user_bookings_template
+        == resources_folder / "user-bookings-payload.txt"
+    )
+    assert (
+        connector.booking_cancellation_template
+        == resources_folder / "booking-cancellation-payload.txt"
+    )
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_landing_page():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    async with aiohttp.ClientSession() as session:
+        response = await connector.land(session)
+
+        assert response.status == 200
+        assert response.request_info.method == "GET"
+        assert response.content_type == "text/html"
+        assert response.request_info.url == URL(connector.landing_url)
+        assert response.charset == "UTF-8"
+        assert response.cookies.get("PHPSESSID") is not None
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_login():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    async with aiohttp.ClientSession() as session:
+        await connector.land(session)
+
+        response = await connector.login(session, user)
+
+        assert response.status == 200
+        assert response.request_info.method == "POST"
+        assert response.content_type == "text/html"
+        assert response.request_info.url == URL(connector.landing_url)
+        assert response.charset == "UTF-8"
+        assert response.cookies.get("COOK_COMPTE") is not None
+        assert response.cookies.get("COOK_ID_CLUB").value == "88"
+        assert response.cookies.get("COOK_ID_USER").value == "232382"
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+def test_get_booked_court():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+
+    session = ClientSession()
+    bookings = [
+        (session, 601, False),
+        (session, 602, False),
+        (session, 603, False),
+        (session, 614, False),
+        (session, 605, False),
+        (session, 606, True),
+        (session, 607, False),
+        (session, 608, False),
+    ]
+
+    court = connector.get_booked_court(bookings, "padel")
+    assert court.number == 9
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_book_one_court():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    async with aiohttp.ClientSession() as session:
+        await connector.land(session)
+        await connector.login(session, user)
+        response, court_id, ok = await connector.send_booking_request(
+            session, pendulum.parse("2024-03-21T13:30:00Z"), 610, 217
+        )
+
+        assert response.status == 200
+        assert response.request_info.method == "POST"
+        assert response.content_type == "text/html"
+        assert response.request_info.url == URL(connector.booking_url)
+        assert response.charset == "UTF-8"
+        assert response.text is not None
+        assert court_id == 610
+        assert ok is True
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_book():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+    booking_filter = BookingFilter(
+        sport_name="Padel", date=pendulum.parse("2024-03-21T13:30:00Z")
+    )
+
+    booked_court = await connector.book(user, booking_filter)
+
+    assert booked_court is not None
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+def test_build_booking_datetime():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    booking_filter = BookingFilter(
+        sport_name="Padel", date=pendulum.parse("2024-03-21T13:30:00Z")
+    )
+
+    opening_datetime = connector.build_booking_datetime(booking_filter)
+    assert opening_datetime.year == 2024
+    assert opening_datetime.month == 3
+    assert opening_datetime.day == 14
+    assert opening_datetime.hour == 0
+    assert opening_datetime.minute == 0
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@patch("pendulum.now")
+def test_wait_until_booking_time(mock_now):
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    booking_filter = BookingFilter(
+        sport_name="Padel", date=pendulum.parse("2024-03-21T13:30:00Z")
+    )
+
+    booking_datetime = utils.retrieve_booking_datetime(booking_filter, club)
+
+    seconds = [
+        booking_datetime.subtract(seconds=3),
+        booking_datetime.subtract(seconds=2),
+        booking_datetime.subtract(seconds=1),
+        booking_datetime,
+        booking_datetime.add(microseconds=1),
+        booking_datetime.add(microseconds=2),
+    ]
+    mock_now.side_effect = seconds
+
+    connector.wait_until_booking_time(booking_filter)
+
+    assert pendulum.now() == booking_datetime.add(microseconds=1)
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_get_hash():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    async with aiohttp.ClientSession() as session:
+        await connector.land(session)
+        await connector.login(session, user)
+
+        hash_value = await connector.send_hash_request(session)
+        assert hash_value is not None
+
+
+def test_get_hash_input():
+    resources_folder = Path(__file__).parent / "data"
+    html_file = resources_folder / "user_bookings_html_response.html"
+    html = html_file.read_text(encoding="utf-8")
+
+    hash_value = GestionSportsConnector.get_hash_input(html)
+
+    assert hash_value == "63470fa38e300fd503de1ee21a71b3bdb6fb206b"
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_get_bookings():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    async with aiohttp.ClientSession() as session:
+        await connector.land(session)
+        await connector.login(session, user)
+
+        hash_value = await connector.send_hash_request(session)
+        payload = f"ajax=loadResa&hash={hash_value}"
+
+        bookings = await connector.send_user_bookings_request(session, payload)
+        print(bookings)
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_get_ongoing_bookings():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    async with aiohttp.ClientSession() as session:
+        await connector.land(session)
+        await connector.login(session, user)
+
+        bookings = await connector.get_ongoing_bookings(session)
+        print(bookings)
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_has_user_ongoing_bookings():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    assert await connector.has_user_ongoing_booking(user)
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_cancel_booking_id():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+
+    async with aiohttp.ClientSession() as session:
+        await connector.land(session)
+        await connector.login(session, user)
+        ongoing_bookings = await connector.get_ongoing_bookings(session)
+        booking_id = ongoing_bookings[0].id
+
+        response = await connector.cancel_booking_id(user, booking_id)
+
+        assert len(await connector.get_ongoing_bookings(session)) == 0
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+def test_is_booking_matching_filter():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    filter_date = pendulum.parse("2024-03-02T15:00:00+01:00")
+    booking = Booking(
+        id=1,
+        dateResa="02/03/2024",
+        startTime="15:00",
+        sport="Padel",
+        court="10",
+    )
+    booking_filter = BookingFilter(date=filter_date, sport_name="Padel")
+
+    assert connector.is_booking_matching_filter(booking, booking_filter)
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+def test_is_booking_not_matching_filter():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    filter_date = pendulum.parse("2024-03-02T15:00:00+01:00")
+    booking = Booking(
+        id=1,
+        dateResa="02/03/2024",
+        startTime="16:00",
+        sport="Padel",
+        court="10",
+    )
+    booking_filter = BookingFilter(date=filter_date, sport_name="Padel")
+
+    assert not connector.is_booking_matching_filter(booking, booking_filter)
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+def test_find_court():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+
+    court = connector.find_court(603, "Padel")
+
+    assert court.number == 6
+
+
+@patch.dict(
+    os.environ,
+    {"CLUB_ID": "tpc"},
+    clear=True,
+)
+@pytest.mark.asyncio
+async def test_cancel_booking():
+    club = config.get_club()
+    connector = GestionSportsConnector(club)
+    user = User(login="padel.testing@jouf.fr", password="ridicule")
+    filter_date = pendulum.parse("2024-03-21T13:30:00+01:00")
+    booking_filter = BookingFilter(date=filter_date, sport_name="Padel")
+    await connector.cancel_booking(user, booking_filter)

tests/utils.py

@@ -1,5 +1,6 @@
 from urllib.parse import urljoin
 
+import pendulum
 from models import BookingFilter, Club
 from pendulum import DateTime
 
@@ -7,7 +8,6 @@ from tests.fixtures import (
     a_booking_failure_response,
     a_booking_filter,
     a_booking_success_response,
-    a_club,
     mes_resas_html,
 )
 
@@ -65,11 +65,13 @@ def retrieve_booking_datetime(
     :param a_booking_filter: the booking filter that contains the date to book
     :param a_club: the club which has the number of days before the date and the booking time
     """
-    booking_hour = a_club.booking_opening_time.hour
-    booking_minute = a_club.booking_opening_time.minute
+    booking_opening = a_club.booking_platform.booking_opening
+    opening_time = pendulum.parse(booking_opening.opening_time)
+    booking_hour = opening_time.hour
+    booking_minute = opening_time.minute
 
     date_to_book = a_booking_filter.date
-    return date_to_book.subtract(days=a_club.booking_open_days_before).at(
+    return date_to_book.subtract(days=booking_opening.days_before).at(
         booking_hour, booking_minute
     )