Resolve pending commit links

Add review record RC-020 for MIL-006
Add My Bookings verification and date-independent booking (steps 7 and 8)
2026-10-28 18:02:52 +08:00 · 2026-10-28 18:02:50 +08:00 · 2026-10-28 18:02:44 +08:00 · 2026-10-28 10:54:26 +01:00 · 2026-10-28 17:54:19 +08:00 · 2026-10-28 17:54:17 +08:00
34 changed files with 2727 additions and 35 deletions
@@ -16,7 +16,7 @@ document of a type. `Primary File` may contain a glob (e.g.
 | PP | Project Plan | docs/project-plan.md | 002 |
 | MIL | Milestone / Gateway | docs/milestones/*.md | 009 |
 | ADR | Architecture Decision Record | docs/adr/adr-NNNN-*.md | 0004 |
-| RC | SQA Review Record | docs/sqa/reviews/rc-*.md | 018 |
+| RC | SQA Review Record | docs/sqa/reviews/rc-*.md | 021 |
 | TM | Traceability Matrix | docs/sqa/traceability-matrix.md | 002 |
 | DICT | Domain Dictionary | docs/dictionary.md | 002 |
@@ -9,7 +9,7 @@
 ## Version History
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
-| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-003 | pending |
+| 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-003 | [245dd16] |
 ---
@@ -59,3 +59,4 @@ Go-with-conditions - the code of MIL-003 meets every Mandatory criterion of QC-P
 [MIL-003]: ../../milestones/mil-003-login.md
 [QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
 [245dd16]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/245dd1689e10cc8d87c6f2a4934286cc36ca34e2
@@ -0,0 +1,62 @@
 # SQA Review Record
 ## Metadata
 | Key | Value |
 | --- | --- |
 | ID | RC-018 |
 | CrossReference | [MIL-004], [QC-PY-001] |
 ## Version History
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
 | 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-004 | [41b0dac] |
 ---
 ## Artifact Under Review
 - Instance reviewed: [MIL-004]
 - Checklist used: [QC-PY-001] (`QC-PY-001`)
 - Scope: full review of the source and tests of MIL-004
 - Language and domain: n/a
 - Language reviewer: none
 - Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
 ## Checklist Results
 | # | Criterion | Status | Evidence/Notes |
 | --- | --- | --- | --- |
 | 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
 | 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
 | 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
 | 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
 | 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
 | 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
 | 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
 | 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
 | 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
 | 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
 | 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 103 unit tests (models, parsing, decisions, booking, recorder, command line) need no browser or network; 9 container tests run the adapter against local HTML fixtures; coverage of the non-infrastructure modules is 100%. |
 | 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
 | 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
 | 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
 | 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
 | 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
 | 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
 | 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
 ## Overall Verdict
 Go-with-conditions - the code of MIL-004 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criterion 1 (unit tests of the four button states and the parsing) is met. Criterion 2 (a container run that books or recognises the Tuesday class on the live site) is not verified, and criterion 3 is not met: `step-3.png` and `step-4.png` come from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site, so the live run was not made; the adapter is verified against local fixtures that copy the site's element IDs, button texts and day labels. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
 ## Action Items
 | Action | Owner | Due |
 | --- | --- | --- |
 | Run the bot with your own account and keep `docs/images/step-3.png` and `step-4.png`; report any selector that failed | S01 | when S01 has time |
 ---
 [MIL-004]: ../../milestones/mil-004-book-class.md
 [QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
 [41b0dac]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/41b0dace113f17d9fc0ffece8a1133ad15d0fb21
@@ -0,0 +1,62 @@
 # SQA Review Record
 ## Metadata
 | Key | Value |
 | --- | --- |
 | ID | RC-019 |
 | CrossReference | [MIL-005], [QC-PY-001] |
 ## Version History
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
 | 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-005 | [45e6fc7] |
 ---
 ## Artifact Under Review
 - Instance reviewed: [MIL-005]
 - Checklist used: [QC-PY-001] (`QC-PY-001`)
 - Scope: full review of the source and tests of MIL-005
 - Language and domain: n/a
 - Language reviewer: none
 - Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
 ## Checklist Results
 | # | Criterion | Status | Evidence/Notes |
 | --- | --- | --- | --- |
 | 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
 | 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
 | 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
 | 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
 | 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
 | 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
 | 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
 | 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
 | 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
 | 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
 | 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 122 unit tests (target lookup, counters, summary and detail text, booking of all target classes, command line) need no browser or network; 10 container tests run the adapter against local fixtures; coverage of the non-infrastructure modules is 100%. |
 | 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
 | 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
 | 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
 | 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
 | 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
 | 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
 | 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
 ## Overall Verdict
 Go-with-conditions - the code of MIL-005 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criterion 1 (unit tests of counters, summary and detail list) is met. Criterion 2 (a container run on the live site that processes every Tuesday and Thursday card once) is not verified, and criterion 3 is not met: `step-5.png` and `step-6.png` come from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site; a container test against the local fixture checks that every target card is processed once. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
 ## Action Items
 | Action | Owner | Due |
 | --- | --- | --- |
 | Run the bot with your own account and keep `docs/images/step-5.png` and `step-6.png` | S01 | when S01 has time |
 ---
 [MIL-005]: ../../milestones/mil-005-counters-and-both-days.md
 [QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
 [45e6fc7]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/45e6fc72dfb39d3bb58b4129a159fe3727aa26c2
@@ -0,0 +1,62 @@
 # SQA Review Record
 ## Metadata
 | Key | Value |
 | --- | --- |
 | ID | RC-020 |
 | CrossReference | [MIL-006], [QC-PY-001] |
 ## Version History
 | Date | Status | Author | Reviewer | Change | Commit |
 | --- | --- | --- | --- | --- | --- |
 | 2026-10-28 | Accepted | Jens Tirsvad Nielsen | AI as stand-in for S02 | Review record, full review of the source and tests of MIL-006 | [f57040e] |
 ---
 ## Artifact Under Review
 - Instance reviewed: [MIL-006]
 - Checklist used: [QC-PY-001] (`QC-PY-001`)
 - Scope: full review of the source and tests of MIL-006
 - Language and domain: n/a
 - Language reviewer: none
 - Mode: autonomous, not independent (the reviewer is `AI as stand-in for S02`)
 ## Checklist Results
 | # | Criterion | Status | Evidence/Notes |
 | --- | --- | --- | --- |
 | 1 | Packages, modules, functions, variables, classes and constants follow PEP 8 casing (`snake_case`, `PascalCase`, `UPPER_SNAKE`) | Pass | Modules, functions and variables are `snake_case`, classes `PascalCase`, constants `UPPER_SNAKE`; `ruff check` with the N rules passes. |
 | 2 | Names state purpose in the domain's language; no unexplained abbreviations, no single-letter names outside tiny scopes | Pass | Names state purpose (for example `retry`, `login`, `book_class`, `get_my_bookings`); no single-letter names outside comprehensions. |
 | 3 | Code is produced by the project's formatter and passes its linter with no unexplained suppressions | Pass | `ruff format` leaves 0 files changed and `ruff check` reports 0 findings; there is no suppression. |
 | 4 | Every function and method signature is type-annotated, including `-> None` | Pass | Every function and method has annotations (ruff ANN rules pass), including `-> None`. |
 | 5 | No bare `except:`, no swallowed exceptions; specific exceptions are raised and the cause is kept (`raise ... from`) | Pass | No bare `except`; specific exceptions are caught, and re-raised with `raise ... from` where the cause matters. |
 | 6 | No mutable default arguments and no shadowed builtins | Pass | No mutable default arguments; no builtin is shadowed (ruff B and A-style checks pass). |
 | 7 | Files, locks and connections are managed with context managers | Pass | Files and the browser are managed with `with`/`try-finally`; no unmanaged file handle exists. |
 | 8 | Public modules, classes and functions have docstrings that say what, not how | Pass | Public modules, classes and functions have Doxygen docstrings (`@brief`, `@param`, `@return`). |
 | 9 | Logging uses `logging`, not `print`; no secrets or personal data in log output | Pass | No print calls; messages go through `logging`. |
 | 10 | Classes and operations trace to the Design Class Diagram they implement; deviations are recorded | N-A | No Design Class Diagram exists; ADR-0001 records that design artifacts are skipped. Classes follow ADR-0002. |
 | 11 | Tests exist for new behaviour, are named for the behaviour, and do not depend on order or the network | Pass | 174 unit tests (booking entries, verification, date independence for all seven starting weekdays, command line) need no browser or network; 15 container tests run the adapter against local fixtures; coverage of the non-infrastructure modules is 100%. |
 | 12 | Type checker runs in strict mode without errors; `Any` is justified in a comment | N-A | No strict type checker is configured; annotations are complete and checked by ruff. |
 | 13 | Dependencies are declared and pinned in the project's dependency file, none unused | Pass | `pyproject.toml` declares Selenium (runtime) and pytest, pytest-cov, ruff (dev) with lower bounds; none is unused. |
 | 14 | Each piece of knowledge (a business rule, constant, format, validation or query) is defined in one place; code is merged only where it expresses the same knowledge, not where it merely looks alike | Pass | Each rule, constant and message exists once (constants in `constants.py`, rules in `domain/`). |
 | 15 | Imports point inward: business-rule modules import no framework, database, UI or delivery-mechanism code, and there are no import cycles | Pass | `domain` and `application` import no Selenium; only `infrastructure` imports it; no import cycle exists. |
 | 16 | SOLID holds: a class or module has one reason to change; new behaviour is added by extension, not by editing a type test in several places; subclasses honour the contract of their base; protocols are narrow; high-level code depends on protocols or abstract types and receives its implementations | Pass | One reason to change per module; the adapter hides Selenium behind a port; fakes honour the port contract. |
 | 17 | Source is laid out in the layers and folders of the clean architecture folder structure (`domain`, `application`, `infrastructure`, `presentation` packages under `src/`, and `unit`, `integration` and `e2e` under `tests/`), in `snake_case`, and imports between the layers point inward | Pass | Layout follows `src/snack_and_lift/{domain,application,infrastructure}` and `tests/{unit,integration,e2e}`; there is no presentation layer for a command-line bot (ADR-0002). |
 | 18 | File and folder names are English, contain no space and no character outside letters, digits, `-`, `_` and `.`, and follow the casing of the language for files | Pass | All file and folder names are English lowercase with `_`, `-` and `.` only. |
 ## Overall Verdict
 Go-with-conditions - the code of MIL-006 meets every Mandatory criterion of QC-PY-001 and there is no blocking finding, but part of the gate evidence cannot be produced by the stand-in. Gate criterion 1 (unit tests of the comparison and the mismatch message) is met, and the date independence is tested for every starting weekday (no hardcoded date, no list-position rule). Criteria 2 and 3 (container runs on the live site, including after the admin advances 3 days) are not verified, and criterion 4 is not met: `step-7.png` and `step-8.png` come from a run with an account. The framework forbids the stand-in to enter passwords or register on a third-party site; the admin time controls also need a login. The review is not independent: the AI wrote and reviewed it as stand-in for S02, and S01 can challenge it in the end-of-run summary.
 ## Action Items
 | Action | Owner | Due |
 | --- | --- | --- |
 | Run the bot with your own account (also after advancing the site 3 days as admin) and keep `docs/images/step-7.png` and `step-8.png` | S01 | when S01 has time |
 ---
 [MIL-006]: ../../milestones/mil-006-verify-and-time-travel.md
 [QC-PY-001]: ../../../framework/qc/code/qc-programming-python.md
 [f57040e]: https://git.tirsystem.com/Tirsvad-Udemy-100-days-of-code/049-snack-and-lift/commit/f57040e136feac01f10d99279038f48992518f43
@@ -38,6 +38,9 @@ Tracks backward and forward links between artifact instances so that the Busines
 | [MIL-008] | Milestone | en | it | [BC-001], [PP-001] | - | RC-015 |
 | Source and tests of [MIL-002] | Python source code | - | - | [MIL-002], [ADR-0002], [ADR-0003] | - | RC-016 |
 | Source and tests of [MIL-003] | Python source code | - | - | [MIL-003], [ADR-0002], [ADR-0003] | - | RC-017 (Go-with-conditions) |
 | Source and tests of [MIL-004] | Python source code | - | - | [MIL-004], [ADR-0002] | - | RC-018 (Go-with-conditions) |
 | Source and tests of [MIL-005] | Python source code | - | - | [MIL-005], [ADR-0002] | - | RC-019 (Go-with-conditions) |
 | Source and tests of [MIL-006] | Python source code | - | - | [MIL-006], [ADR-0002] | - | RC-020 (Go-with-conditions) |
 ## Concern Coverage
@@ -0,0 +1,85 @@
 """@file booking.py
@brief Lecture steps 3 to 6: book the Tuesday and Thursday 6pm classes and report their state.
 """
 import logging
 from collections.abc import Callable
 from snack_and_lift import constants
 from snack_and_lift.application.ports import GymPort
 from snack_and_lift.domain.errors import GymError
 from snack_and_lift.domain.models import ButtonState, ClassCard, ClassResult
 from snack_and_lift.domain.rules import (
    CONFIRMED_STATE,
    OUTCOME_OF_ACTION,
    decide_outcome_action,
    find_next_class,
    find_target_classes,
    format_outcome,
 )
 logger = logging.getLogger(__name__)
 def book_class(gym: GymPort, card: ClassCard) -> ClassResult:
    """@brief Book or waitlist a class, or report that it already is.
    @param gym The gym site.
    @param card The class, as read from the page.
    @return The class and what happened.
    @exception UnknownButtonError The button is busy, completed or unknown.
    @exception GymError The click failed or was not confirmed by the button.
    """
    action = decide_outcome_action(card)
    expected = CONFIRMED_STATE.get(action)
    if expected is not None:
        new_text = gym.press_class_button(card.card_id)
        if ButtonState.from_text(new_text) is not expected:
            raise GymError(f"click not confirmed: the button says {new_text!r}")
    outcome = OUTCOME_OF_ACTION[action]
    logger.info(format_outcome(outcome, card))
    return ClassResult(card, outcome)
 def book_next_tuesday(gym: GymPort) -> ClassResult | None:
    """@brief Book the next Tuesday class at the target time.
    @param gym The gym site.
    @return The result, or None when the schedule has no such class.
    @exception GymError The page could not be read or the booking failed.
    """
    card = find_next_class(gym.list_class_cards(), constants.NEXT_CLASS_WEEKDAY)
    if card is None:
        logger.warning(
            constants.MESSAGE_NO_CLASS_FOUND.format(
                weekday=constants.NEXT_CLASS_WEEKDAY,
                time=constants.TARGET_TIME_TEXT,
            )
        )
        return None
    return book_class(gym, card)
 def book_target_classes(
    gym: GymPort, on_result: Callable[[ClassResult], None] | None = None
 ) -> list[ClassResult]:
    """@brief Book every Tuesday and Thursday class at the target time, in page order.
    The cards are listed once; each class is found again by its id when it is pressed.
    @param gym The gym site.
    @param on_result Called after each class was handled, for example to take a screenshot.
    @return What happened to each class; empty when the schedule has none.
    @exception GymError The page could not be read or a booking failed.
    """
    cards = find_target_classes(gym.list_class_cards())
    if not cards:
        logger.warning(constants.MESSAGE_NO_TARGET_CLASSES.format(time=constants.TARGET_TIME_TEXT))
        return []
    results: list[ClassResult] = []
    for card in cards:
        result = book_class(gym, card)
        results.append(result)
        if on_result is not None:
            on_result(result)
    return results
@@ -5,6 +5,9 @@
 from pathlib import Path
 from typing import Protocol
 from snack_and_lift.domain.booking_entry import BookingEntry
 from snack_and_lift.domain.models import ClassCard
 class GymPort(Protocol):
    """@brief The gym site as the use cases see it."""
@@ -26,6 +29,47 @@ class GymPort(Protocol):
        """
        ...
    def list_class_cards(self) -> list[ClassCard]:
        """@brief Read every class card of the schedule, in page order.
        @return The classes, each with the day of its group.
        @exception GymError The schedule could not be read.
        """
        ...
    def press_class_button(self, card_id: str) -> str:
        """@brief Click the button of a class and wait until the request has finished.
        @param card_id The id of the card without its prefix.
        @return The new text of the button.
        @exception GymError The site shows an error for the class (the message is its text)
            or nothing settled in time.
        """
        ...
    def open_my_bookings(self) -> None:
        """@brief Open the My Bookings page and wait until it is shown.
        @exception GymError The page did not load.
        """
        ...
    def list_my_bookings(self) -> list[BookingEntry]:
        """@brief Read every confirmed booking and waitlist entry of the My Bookings page.
        @return The entries, confirmed ones first; empty when the page shows its empty state.
        @exception GymError The page shows an error (the message is its text) or did not settle.
        """
        ...
    def save_text_screenshot(self, text: str, path: Path) -> None:
        """@brief Save an image of console text.
        @param text The lines to draw, in a dark monospace style.
        @param path The PNG file to write; its folders are created.
        """
        ...
    def save_screenshot(self, path: Path) -> None:
        """@brief Save a screenshot of the current page.
@@ -0,0 +1,47 @@
 """@file verification.py
@brief Lecture steps 7 and 8: check the bookings on the My Bookings page.
 """
 import logging
 from collections.abc import Sequence
 from snack_and_lift import constants
 from snack_and_lift.application.ports import GymPort
 from snack_and_lift.domain.booking_entry import BookingEntry, is_target_entry
 from snack_and_lift.domain.errors import NoBookingsFoundError
 from snack_and_lift.domain.models import ClassResult
 from snack_and_lift.domain.verification import VerificationResult, build_verification
 logger = logging.getLogger(__name__)
 def get_my_bookings(gym: GymPort) -> list[BookingEntry]:
    """@brief Open the My Bookings page and read all its entries.
    @param gym The gym site.
    @return Every confirmed booking and waitlist entry, not only the target classes.
    @exception NoBookingsFoundError The page shows no entry at all.
    @exception GymError The page could not be opened or read.
    """
    gym.open_my_bookings()
    entries = gym.list_my_bookings()
    if not entries:
        raise NoBookingsFoundError(constants.MESSAGE_NO_BOOKINGS_FOUND)
    return entries
 def verify_bookings(gym: GymPort, results: Sequence[ClassResult]) -> VerificationResult:
    """@brief Compare what the bot booked with the My Bookings page.
    The page is not opened when the bot handled no class.
    @param gym The gym site.
    @param results What happened to each class.
    @return The comparison of the expected entries with the Tuesday and Thursday 6pm entries.
    @exception NoBookingsFoundError Classes were handled but the page shows no entry.
    @exception GymError The page could not be opened or read.
    """
    if not results:
        return build_verification(results, [])
    entries = [entry for entry in get_my_bookings(gym) if is_target_entry(entry)]
    return build_verification(results, entries)
@@ -9,11 +9,18 @@ import sys
 from collections.abc import Callable, Sequence
 from pathlib import Path
-from snack_and_lift.application.credentials import load_credentials
+from snack_and_lift import constants
 from snack_and_lift.application.booking import book_next_tuesday, book_target_classes
 from snack_and_lift.application.credentials import Credentials, load_credentials
 from snack_and_lift.application.ports import GymPort
 from snack_and_lift.application.session import login
-from snack_and_lift.domain.errors import LoginFailedError, MissingCredentialsError
+from snack_and_lift.application.verification import verify_bookings
 from snack_and_lift.domain.errors import GymError, LoginFailedError, MissingCredentialsError
 from snack_and_lift.domain.models import ClassResult
 from snack_and_lift.domain.report import format_detail_list, format_summary
 from snack_and_lift.domain.verification import format_verification
 from snack_and_lift.infrastructure.browser import create_driver, default_profile_dir
 from snack_and_lift.infrastructure.console_recorder import ConsoleRecorder
 from snack_and_lift.infrastructure.selenium_gym import SeleniumGym
 ## Builds the gym site from (headless, profile folder, keep open).
@@ -42,6 +49,10 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
    parser = argparse.ArgumentParser(
        prog="snack-and-lift",
        description="Books the Tuesday and Thursday 6pm classes at the Snack and Lift gym.",
        epilog=(
            "exit codes: 0 done, 1 a step failed, 2 credentials missing, "
            "3 the My Bookings page does not match the bookings made"
        ),
    )
    parser.add_argument(
        "--headless",
@@ -66,6 +77,11 @@ def parse_args(argv: Sequence[str] | None = None) -> argparse.Namespace:
        default=None,
        help="save a screenshot after each step into this folder",
    )
    parser.add_argument(
        "--first-tuesday-only",
        action="store_true",
        help="book only the next Tuesday 6pm class (lecture steps 3 and 4); skips the verification",
    )
    args = parser.parse_args(argv)
    if args.keep_open is None:
        args.keep_open = not args.headless
@@ -92,17 +108,98 @@ def _save_step(gym: GymPort, screenshot_dir: Path | None, name: str) -> None:
        gym.save_screenshot(screenshot_dir / name)
 def _save_console(gym: GymPort, screenshot_dir: Path | None, text: str, name: str) -> None:
    """@brief Save console text as an image when a folder was asked for.
    @param gym The gym site.
    @param screenshot_dir The folder, or None for no screenshots.
    @param text The console text to draw.
    @param name The file name.
    """
    if screenshot_dir is not None:
        gym.save_text_screenshot(text, screenshot_dir / name)
 def _run(
    gym: GymPort, args: argparse.Namespace, recorder: ConsoleRecorder, credentials: Credentials
 ) -> bool:
    """@brief Open the site, log in, book the classes and verify them, saving the step images.
    Books every Tuesday and Thursday 6pm class, logs the summary and the detailed list and
    verifies the bookings on the My Bookings page; with `--first-tuesday-only` it books the
    next Tuesday class only and does not verify.
    @param gym The gym site.
    @param args The parsed options.
    @param recorder The recorded console lines, drawn for step 4.
    @param credentials The account to log in with.
    @return False when the My Bookings page does not match the bookings made, else True.
    @exception GymError A step failed.
    """
    gym.open_site()
    _save_step(gym, args.screenshot_dir, "step-1.png")
    login(gym, credentials)
    _save_step(gym, args.screenshot_dir, "step-2.png")
    if args.first_tuesday_only:
        book_next_tuesday(gym)
        _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_3)
        _save_console(gym, args.screenshot_dir, recorder.text, constants.SCREENSHOT_STEP_4)
        return True
    window_saved = False
    def save_window_once(_: ClassResult) -> None:
        nonlocal window_saved
        if not window_saved:
            _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_3)
            window_saved = True
    results = book_target_classes(gym, save_window_once)
    if not window_saved:
        _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_3)
    _save_console(gym, args.screenshot_dir, recorder.text, constants.SCREENSHOT_STEP_4)
    summary = format_summary(results)
    logger.info("%s", summary)
    _save_console(gym, args.screenshot_dir, summary, constants.SCREENSHOT_STEP_5)
    detail = format_detail_list(results)
    logger.info("%s", detail)
    _save_console(gym, args.screenshot_dir, f"{summary}\n{detail}", constants.SCREENSHOT_STEP_6)
    verification = verify_bookings(gym, results)
    _save_step(gym, args.screenshot_dir, constants.SCREENSHOT_STEP_7)
    verification_text = format_verification(verification)
    logger.info("%s", verification_text)
    _save_console(gym, args.screenshot_dir, verification_text, constants.SCREENSHOT_STEP_8)
    return verification.is_success
 def main(
    argv: Sequence[str] | None = None,
    gym_factory: GymFactory = selenium_gym_factory,
 ) -> int:
-    """@brief Start the bot: open the site and log in.
+    """@brief Start the bot: open the site, log in and book the next Tuesday 6pm class.
    @param argv Arguments without the program name; None reads `sys.argv`.
    @param gym_factory Builds the gym site; tests pass a fake.
-    @return Process exit code: 0 done, 1 login failed, 2 credentials missing.
+    @return Process exit code: 0 done, 1 a step failed, 2 credentials missing, 3 mismatch.
    """
    logging.basicConfig(level=logging.INFO, format="%(message)s")
    root = logging.getLogger()
    root.setLevel(logging.INFO)
    recorder = ConsoleRecorder()
    root.addHandler(recorder)
    try:
        return _main(argv, gym_factory, recorder)
    finally:
        root.removeHandler(recorder)
 def _main(argv: Sequence[str] | None, gym_factory: GymFactory, recorder: ConsoleRecorder) -> int:
    """@brief The body of `main`, run while the recorder is attached.
    @param argv Arguments without the program name.
    @param gym_factory Builds the gym site.
    @param recorder The console recorder.
    @return Process exit code.
    """
    _use_utf8_output()
    args = parse_args(argv)
    try:
@@ -112,14 +209,14 @@ def main(
        return 2
    gym = gym_factory(args.headless, args.profile_dir, args.keep_open)
    try:
-        gym.open_site()
+        verified = _run(gym, args, recorder, credentials)
        _save_step(gym, args.screenshot_dir, "step-1.png")
        login(gym, credentials)
        _save_step(gym, args.screenshot_dir, "step-2.png")
    except LoginFailedError as error:
        logger.error("Login failed: %s", error)
        return 1
    except GymError as error:
        logger.error("Failed: %s", error)
        return 1
    finally:
        if not args.keep_open:
            gym.close()
-    return 0
+    return 0 if verified else constants.EXIT_VERIFICATION_MISMATCH
@@ -64,3 +64,142 @@ HEADLESS_BROWSER_ARGUMENTS: Final[tuple[str, ...]] = (
    "--disable-dev-shm-usage",
    "--disable-gpu",
 )
 ## Weekday of the class that lecture steps 3 and 4 book, as the site abbreviates it.
 NEXT_CLASS_WEEKDAY: Final[str] = "Tue"
 ## Hour (24-hour clock) of the class the bot books.
 TARGET_HOUR: Final[int] = 18
 ## Minute of the class the bot books.
 TARGET_MINUTE: Final[int] = 0
 ## CSS selector of every class card on the schedule.
 CLASS_CARD_CSS: Final[str] = "div[id^='class-card-']"
 ## Prefix of the element ids of one card; the card id (for example "123") follows it.
 CLASS_CARD_ID_PREFIX: Final[str] = "class-card-"
 CLASS_NAME_ID_PREFIX: Final[str] = "class-name-"
 CLASS_TIME_ID_PREFIX: Final[str] = "class-time-"
 BOOK_BUTTON_ID_PREFIX: Final[str] = "book-button-"
 COMPLETED_LABEL_ID_PREFIX: Final[str] = "completed-label-"
 CLASS_ERROR_ID_PREFIX: Final[str] = "class-error-"
 ## XPath, relative to a card, of the title of the day group the card is in (the "ancestor" hint).
 DAY_TITLE_XPATH: Final[str] = (
    "ancestor::div[starts-with(@id,'day-group-')]//h2[starts-with(@id,'day-title-')]"
 )
 ## Texts of the button of a card.
 BUTTON_TEXT_BOOK: Final[str] = "Book Class"
 BUTTON_TEXT_JOIN_WAITLIST: Final[str] = "Join Waitlist"
 BUTTON_TEXT_BOOKED: Final[str] = "Booked"
 BUTTON_TEXT_WAITLISTED: Final[str] = "Waitlisted"
 BUTTON_TEXT_BOOKING: Final[str] = "Booking..."
 BUTTON_TEXT_JOINING: Final[str] = "Joining..."
 BUTTON_TEXT_COMPLETED: Final[str] = "Completed"
 ## Prefix of the time text of a card ("Time: 6:00 PM").
 TIME_TEXT_PREFIX: Final[str] = "Time:"
 ## Day labels the site wraps around the date of the next two days.
 DAY_LABEL_WRAPPERS: Final[tuple[str, ...]] = ("Today", "Tomorrow")
 ## Console messages of the booking, with the class name and the day label as the site shows it.
 MESSAGE_BOOKED: Final[str] = "✓ Successfully booked: {name} on {day}"
 MESSAGE_WAITLISTED: Final[str] = "✓ Joined waitlist for: {name} on {day}"
 MESSAGE_ALREADY_BOOKED: Final[str] = "✓ Already booked: {name} on {day}"
 MESSAGE_ALREADY_WAITLISTED: Final[str] = "✓ Already on waitlist: {name} on {day}"
 MESSAGE_NO_CLASS_FOUND: Final[str] = "No {weekday} class at {time} found on the schedule"
 ## Logged when the schedule has no class on a target weekday at the target time.
 MESSAGE_NO_TARGET_CLASSES: Final[str] = (
    "No Tuesday or Thursday class at {time} found on the schedule"
 )
 ## Time of the target classes as written in messages (24-hour clock).
 TARGET_TIME_TEXT: Final[str] = f"{TARGET_HOUR:02d}:{TARGET_MINUTE:02d}"
 ## Lines of the booking summary (lecture step 5).
 SUMMARY_TITLE: Final[str] = "--- BOOKING SUMMARY ---"
 SUMMARY_NEW_BOOKINGS: Final[str] = "New bookings: {count}"
 SUMMARY_NEW_WAITLIST: Final[str] = "New waitlist entries: {count}"
 SUMMARY_ALREADY_DONE: Final[str] = "Already booked/waitlisted: {count}"
 SUMMARY_TOTAL: Final[str] = "Total Tuesday & Thursday 6pm classes: {count}"
 ## Lines of the detailed class list (lecture step 6).
 DETAIL_TITLE: Final[str] = "--- DETAILED CLASS LIST ---"
 DETAIL_LINE: Final[str] = "  • [{tag}] {name} on {day}"
 DETAIL_NONE: Final[str] = "  No matching class found"
 DETAIL_TAG_NEW_BOOKING: Final[str] = "New Booking"
 DETAIL_TAG_NEW_WAITLIST: Final[str] = "New Waitlist"
 DETAIL_TAG_ALREADY_BOOKED: Final[str] = "Already Booked"
 DETAIL_TAG_ALREADY_WAITLISTED: Final[str] = "Already Waitlisted"
 ## File names of the screenshots of lecture steps 3 to 6.
 SCREENSHOT_STEP_3: Final[str] = "step-3.png"
 SCREENSHOT_STEP_4: Final[str] = "step-4.png"
 SCREENSHOT_STEP_5: Final[str] = "step-5.png"
 SCREENSHOT_STEP_6: Final[str] = "step-6.png"
 ## `string.Template` of the page that renders console text for a screenshot.
 CONSOLE_PAGE_TEMPLATE: Final[str] = (
    "<!DOCTYPE html><html><head><meta charset='utf-8'></head>"
    "<body style='margin:0;background:#1e1e1e;color:#d4d4d4'>"
    "<pre style='margin:0;padding:16px;font:16px/1.5 monospace;white-space:pre-wrap'>"
    "$text</pre></body></html>"
 )
 ## Prefix of the `data:` URL that carries the console page.
 CONSOLE_PAGE_URL_PREFIX: Final[str] = "data:text/html;charset=utf-8,"
 ## File names of the screenshots of lecture steps 7 and 8.
 SCREENSHOT_STEP_7: Final[str] = "step-7.png"
 SCREENSHOT_STEP_8: Final[str] = "step-8.png"
 ## Process exit code when the My Bookings page does not match what the bot did.
 EXIT_VERIFICATION_MISMATCH: Final[int] = 3
 ## Id of the navigation link that opens the My Bookings page.
 MY_BOOKINGS_LINK_ID: Final[str] = "my-bookings-link"
 ## Id of the My Bookings page, shown after its bookings were loaded.
 MY_BOOKINGS_PAGE_ID: Final[str] = "my-bookings-page"
 ## Id of the element shown when the account has no booking and no waitlist entry.
 EMPTY_BOOKINGS_STATE_ID: Final[str] = "empty-bookings-state"
 ## CSS selectors of the confirmed booking cards and the waitlist cards.
 BOOKING_CARD_CSS: Final[str] = "#confirmed-bookings-section div[id^='booking-card-']"
 WAITLIST_CARD_CSS: Final[str] = "#waitlist-section div[id^='waitlist-card-']"
 ## Prefixes of the element ids of a booking card and of a waitlist card.
 BOOKING_CARD_ID_PREFIX: Final[str] = "booking-card-"
 BOOKING_NAME_ID_PREFIX: Final[str] = "booking-class-name-"
 WAITLIST_CARD_ID_PREFIX: Final[str] = "waitlist-card-"
 WAITLIST_NAME_ID_PREFIX: Final[str] = "waitlist-class-name-"
 ## XPath, relative to a card, of the paragraph "When: Tue, Aug 12, 6:00 PM".
 WHEN_XPATH: Final[str] = ".//p[strong[starts-with(normalize-space(), 'When:')]]"
 ## Prefix of the date and time text of a booking card.
 WHEN_TEXT_PREFIX: Final[str] = "When:"
 ## Suffix the My Bookings page adds to the name of a waitlist entry.
 WAITLIST_NAME_SUFFIX: Final[str] = " (Waitlist)"
 ## Message of the error raised when the My Bookings page shows no booking at all.
 MESSAGE_NO_BOOKINGS_FOUND: Final[str] = "The My Bookings page shows no booking or waitlist entry"
 ## Lines of the verification on the My Bookings page (lecture steps 7 and 8).
 VERIFY_TITLE: Final[str] = "--- VERIFYING ON MY BOOKINGS PAGE ---"
 VERIFY_LINE_VERIFIED: Final[str] = "  ✓ Verified: {name}"
 VERIFY_RESULT_TITLE: Final[str] = "--- VERIFICATION RESULT ---"
 VERIFY_EXPECTED: Final[str] = "Expected: {count} {noun}"
 VERIFY_FOUND: Final[str] = "Found: {count} {noun}"
 VERIFY_NOUN_SINGULAR: Final[str] = "booking"
 VERIFY_NOUN_PLURAL: Final[str] = "bookings"
 VERIFY_SUCCESS: Final[str] = "✅ SUCCESS: All bookings verified!"
 VERIFY_MISMATCH: Final[str] = "❌ MISMATCH: Missing {count} bookings"
 VERIFY_LINE_MISSING: Final[str] = "  ✗ Missing: {entry}"
 VERIFY_LINE_UNEXPECTED: Final[str] = "  ? Unexpected: {entry}"
@@ -0,0 +1,88 @@
 """@file booking_entry.py
@brief One entry of the My Bookings page: a confirmed booking or a waitlist entry.
 """
 import re
 from dataclasses import dataclass
 from snack_and_lift import constants
 from snack_and_lift.domain.day_label import parse_day_label
 from snack_and_lift.domain.errors import PageFormatError
 from snack_and_lift.domain.rules import parse_time
 _WHEN = re.compile(r"(?P<date>[A-Z][a-z]{2}, [A-Z][a-z]{2} \d{1,2}), (?P<time>.+)")
@dataclass(frozen=True, slots=True)
 class BookingEntry:
    """@brief A booking or waitlist entry, as read from the My Bookings page.
    `name` is the class name WITHOUT the ` (Waitlist)` suffix the page adds to a waitlist
    entry; `waitlisted` carries that fact. `when_text` is the page text without the
    `When:` prefix, for example `Tue, Aug 12, 6:00 PM`.
    """
    name: str
    when_text: str
    waitlisted: bool
    @classmethod
    def from_page(cls, heading: str, when_text: str, waitlisted: bool) -> "BookingEntry":
        """@brief Build an entry from the texts of its card.
        @param heading The class name as the page shows it, possibly with the waitlist suffix.
        @param when_text The date and time paragraph, with or without the `When:` prefix.
        @param waitlisted True for a card of the waitlist section.
        @return The entry, with the suffix and the prefix removed.
        """
        name = heading.strip().removesuffix(constants.WAITLIST_NAME_SUFFIX.strip()).strip()
        when = when_text.strip().removeprefix(constants.WHEN_TEXT_PREFIX).strip()
        return cls(name, when, waitlisted)
    def _split_when(self) -> tuple[str, str]:
        """@brief Split the date text from the time text.
        @return The date text (`Tue, Aug 12`) and the time text (`6:00 PM`).
        @exception PageFormatError The text has no date and time.
        """
        match = _WHEN.fullmatch(self.when_text)
        if match is None:
            raise PageFormatError(f"Unexpected booking date and time: {self.when_text!r}")
        return match["date"], match["time"]
    @property
    def weekday(self) -> str:
        """@brief The weekday of the entry (`Tue`).
        @exception PageFormatError The date and time text is not valid.
        """
        return parse_day_label(self._split_when()[0])[0]
    @property
    def date_text(self) -> str:
        """@brief The date of the entry (`Tue, Aug 12`), comparable with a class card's date.
        @exception PageFormatError The date and time text is not valid.
        """
        return parse_day_label(self._split_when()[0])[1]
    @property
    def time(self) -> tuple[int, int]:
        """@brief The hour (0-23) and the minute of the entry.
        @exception PageFormatError The date and time text is not valid.
        """
        return parse_time(self._split_when()[1])
 def is_target_entry(entry: BookingEntry) -> bool:
    """@brief Tell whether the entry is a class the bot books: a target weekday at the target time.
    @param entry The entry.
    @return True for Tuesday or Thursday at `TARGET_HOUR`:`TARGET_MINUTE`.
    @exception PageFormatError The date and time text is not valid.
    """
    return entry.weekday in constants.TARGET_WEEKDAYS and entry.time == (
        constants.TARGET_HOUR,
        constants.TARGET_MINUTE,
    )
@@ -0,0 +1,29 @@
 """@file day_label.py
@brief Reads the title of a day group of the schedule ("Today (Tue, Aug 12)").
 Kept apart from `rules.py` so that `models.py` can use it without a circular import.
 """
 import re
 from snack_and_lift import constants
 from snack_and_lift.domain.errors import PageFormatError
 _DATE = re.compile(r"(?P<weekday>[A-Z][a-z]{2}), [A-Z][a-z]{2} \d{1,2}")
 _WRAPPER = re.compile(rf"(?:{'|'.join(constants.DAY_LABEL_WRAPPERS)}) \((?P<inner>.+)\)")
 def parse_day_label(label: str) -> tuple[str, str]:
    """@brief Split a day label into the weekday and the date text.
    @param label `Today (Tue, Aug 12)`, `Tomorrow (Wed, Aug 13)` or `Thu, Aug 14`.
    @return The weekday (`Tue`) and the date text (`Tue, Aug 12`).
    @exception PageFormatError The label has none of these forms.
    """
    text = label.strip()
    wrapped = _WRAPPER.fullmatch(text)
    date_text = wrapped["inner"] if wrapped else text
    match = _DATE.fullmatch(date_text)
    if match is None:
        raise PageFormatError(f"Unexpected day label: {label!r}")
    return match["weekday"], date_text
@@ -1,15 +1,31 @@
-"""@file errors.py
+"""@file errors.py
-@brief The errors of the bot.
+@brief The errors of the bot.
-"""
+"""
-
+
-
+
-class GymError(Exception):
+class GymError(Exception):
-    """@brief The gym site did not behave as the bot expected (a page, element or timeout)."""
+    """@brief The gym site did not behave as the bot expected (a page, element or timeout)."""
-
+
-
+
-class LoginFailedError(GymError):
+class LoginFailedError(GymError):
-    """@brief The site refused the login; the message is the text the site shows."""
+    """@brief The site refused the login; the message is the text the site shows."""
-
+
-
+
-class MissingCredentialsError(Exception):
+class MissingCredentialsError(Exception):
-    """@brief The account e-mail or password is not set in the environment."""
+    """@brief The account e-mail or password is not set in the environment."""
 class UnknownButtonError(GymError):
    """@brief A class button shows a text the bot cannot act on (busy, completed or unknown)."""
 class PageFormatError(GymError):
    """@brief A text read from the page (a day label or a time) has an unexpected format."""
 class NoBookingsFoundError(GymError):
    """@brief The My Bookings page shows no booking where the bot expects some.
    The project's counterpart of Selenium's `NoSuchElementException`, which the lecture asks
    the student to raise when the bookings that should be there are missing.
    """
@@ -0,0 +1,94 @@
 """@file models.py
@brief Plain data of the schedule: the button state, a class card and the result of a booking.
 """
 from dataclasses import dataclass
 from enum import Enum, auto
 from snack_and_lift import constants
 from snack_and_lift.domain.day_label import parse_day_label
 class ButtonState(Enum):
    """@brief What the button of a class card says."""
    BOOK = auto()
    JOIN_WAITLIST = auto()
    BOOKED = auto()
    WAITLISTED = auto()
    BUSY = auto()
    COMPLETED = auto()
    UNKNOWN = auto()
    @classmethod
    def from_text(cls, text: str) -> "ButtonState":
        """@brief Map the text of a button to its state.
        @param text The visible text of the button (or the label of a past class).
        @return The state; UNKNOWN for a text the bot does not know.
        """
        return _STATE_BY_TEXT.get(text.strip(), cls.UNKNOWN)
 _STATE_BY_TEXT: dict[str, ButtonState] = {
    constants.BUTTON_TEXT_BOOK: ButtonState.BOOK,
    constants.BUTTON_TEXT_JOIN_WAITLIST: ButtonState.JOIN_WAITLIST,
    constants.BUTTON_TEXT_BOOKED: ButtonState.BOOKED,
    constants.BUTTON_TEXT_WAITLISTED: ButtonState.WAITLISTED,
    constants.BUTTON_TEXT_BOOKING: ButtonState.BUSY,
    constants.BUTTON_TEXT_JOINING: ButtonState.BUSY,
    constants.BUTTON_TEXT_COMPLETED: ButtonState.COMPLETED,
 }
@dataclass(frozen=True, slots=True)
 class ClassCard:
    """@brief One class of the schedule, as read from the page.
    `card_id` is the id of the card without the `class-card-` prefix (for example
    "123"); the site builds the ids of the card's other elements from the same suffix.
    """
    card_id: str
    name: str
    day_label: str
    time_text: str
    button_text: str
    @property
    def state(self) -> ButtonState:
        """@brief The state of the button."""
        return ButtonState.from_text(self.button_text)
    @property
    def weekday(self) -> str:
        """@brief The weekday of the day group (`Tue`).
        @exception PageFormatError The day label is not in a known form.
        """
        return parse_day_label(self.day_label)[0]
    @property
    def date_text(self) -> str:
        """@brief The date of the day group (`Tue, Aug 12`).
        @exception PageFormatError The day label is not in a known form.
        """
        return parse_day_label(self.day_label)[1]
 class Outcome(Enum):
    """@brief What the booking did, or found, for a class."""
    NEW_BOOKING = auto()
    NEW_WAITLIST = auto()
    ALREADY_BOOKED = auto()
    ALREADY_WAITLISTED = auto()
@dataclass(frozen=True, slots=True)
 class ClassResult:
    """@brief The class that was handled and what happened to it."""
    card: ClassCard
    outcome: Outcome
@@ -0,0 +1,81 @@
 """@file report.py
@brief Lecture steps 5 and 6: count what the bot did and write the summary and the class list.
 """
 from collections.abc import Sequence
 from dataclasses import dataclass
 from snack_and_lift import constants
 from snack_and_lift.domain.models import ClassResult, Outcome
 _TAG_OF_OUTCOME: dict[Outcome, str] = {
    Outcome.NEW_BOOKING: constants.DETAIL_TAG_NEW_BOOKING,
    Outcome.NEW_WAITLIST: constants.DETAIL_TAG_NEW_WAITLIST,
    Outcome.ALREADY_BOOKED: constants.DETAIL_TAG_ALREADY_BOOKED,
    Outcome.ALREADY_WAITLISTED: constants.DETAIL_TAG_ALREADY_WAITLISTED,
 }
 _ALREADY_DONE = (Outcome.ALREADY_BOOKED, Outcome.ALREADY_WAITLISTED)
@dataclass(frozen=True, slots=True)
 class Counters:
    """@brief How many classes ended in each way."""
    new_bookings: int
    new_waitlist: int
    already_done: int
    @property
    def total(self) -> int:
        """@brief The number of classes handled."""
        return self.new_bookings + self.new_waitlist + self.already_done
 def count_results(results: Sequence[ClassResult]) -> Counters:
    """@brief Count the results by outcome.
    @param results What happened to each class.
    @return The counters; already booked and already waitlisted count together.
    """
    return Counters(
        new_bookings=sum(1 for r in results if r.outcome is Outcome.NEW_BOOKING),
        new_waitlist=sum(1 for r in results if r.outcome is Outcome.NEW_WAITLIST),
        already_done=sum(1 for r in results if r.outcome in _ALREADY_DONE),
    )
 def format_summary(results: Sequence[ClassResult]) -> str:
    """@brief Write the booking summary block.
    @param results What happened to each class.
    @return The block, starting with `--- BOOKING SUMMARY ---`, lines joined by newlines.
    """
    counters = count_results(results)
    return "\n".join(
        [
            constants.SUMMARY_TITLE,
            constants.SUMMARY_NEW_BOOKINGS.format(count=counters.new_bookings),
            constants.SUMMARY_NEW_WAITLIST.format(count=counters.new_waitlist),
            constants.SUMMARY_ALREADY_DONE.format(count=counters.already_done),
            constants.SUMMARY_TOTAL.format(count=counters.total),
        ]
    )
 def format_detail_list(results: Sequence[ClassResult]) -> str:
    """@brief Write the detailed class list, one line per class in the order handled.
    @param results What happened to each class.
    @return The block, starting with `--- DETAILED CLASS LIST ---`; says so when empty.
    """
    lines = [constants.DETAIL_TITLE]
    if not results:
        lines.append(constants.DETAIL_NONE)
    lines.extend(
        constants.DETAIL_LINE.format(
            tag=_TAG_OF_OUTCOME[result.outcome], name=result.card.name, day=result.card.day_label
        )
        for result in results
    )
    return "\n".join(lines)
@@ -0,0 +1,159 @@
 """@file rules.py
@brief The booking rules: which class is the target, what to do for a button state, what to say.
 """
 import re
 from collections.abc import Iterable
 from enum import Enum, auto
 from snack_and_lift import constants
 from snack_and_lift.domain.day_label import parse_day_label
 from snack_and_lift.domain.errors import PageFormatError, UnknownButtonError
 from snack_and_lift.domain.models import ButtonState, ClassCard, Outcome
 __all__ = [
    "CONFIRMED_STATE",
    "OUTCOME_OF_ACTION",
    "Action",
    "decide_outcome_action",
    "find_next_class",
    "find_target_classes",
    "format_outcome",
    "is_target_time",
    "parse_day_label",
    "parse_time",
 ]
 _TIME = re.compile(
    rf"(?:{re.escape(constants.TIME_TEXT_PREFIX)}\s*)?(\d{{1,2}}):(\d{{2}})\s*(AM|PM)",
    re.IGNORECASE,
 )
 _MAX_CLOCK_HOUR = 12
 _MAX_MINUTE = 59
 class Action(Enum):
    """@brief What the bot does for a class card."""
    CLICK_BOOK = auto()
    CLICK_WAITLIST = auto()
    ALREADY_BOOKED = auto()
    ALREADY_WAITLISTED = auto()
 ## The outcome that follows from each action.
 OUTCOME_OF_ACTION: dict[Action, Outcome] = {
    Action.CLICK_BOOK: Outcome.NEW_BOOKING,
    Action.CLICK_WAITLIST: Outcome.NEW_WAITLIST,
    Action.ALREADY_BOOKED: Outcome.ALREADY_BOOKED,
    Action.ALREADY_WAITLISTED: Outcome.ALREADY_WAITLISTED,
 }
 ## The button state that proves a click worked.
 CONFIRMED_STATE: dict[Action, ButtonState] = {
    Action.CLICK_BOOK: ButtonState.BOOKED,
    Action.CLICK_WAITLIST: ButtonState.WAITLISTED,
 }
 _ACTION_OF_STATE: dict[ButtonState, Action] = {
    ButtonState.BOOK: Action.CLICK_BOOK,
    ButtonState.JOIN_WAITLIST: Action.CLICK_WAITLIST,
    ButtonState.BOOKED: Action.ALREADY_BOOKED,
    ButtonState.WAITLISTED: Action.ALREADY_WAITLISTED,
 }
 _MESSAGE_OF_OUTCOME: dict[Outcome, str] = {
    Outcome.NEW_BOOKING: constants.MESSAGE_BOOKED,
    Outcome.NEW_WAITLIST: constants.MESSAGE_WAITLISTED,
    Outcome.ALREADY_BOOKED: constants.MESSAGE_ALREADY_BOOKED,
    Outcome.ALREADY_WAITLISTED: constants.MESSAGE_ALREADY_WAITLISTED,
 }
 def parse_time(text: str) -> tuple[int, int]:
    """@brief Read a 12-hour time such as `6:00 PM`.
    @param text The time, with or without the `Time:` prefix.
    @return The hour (0-23) and the minute.
    @exception PageFormatError The text is not a valid time.
    """
    match = _TIME.fullmatch(text.strip())
    if match is None:
        raise PageFormatError(f"Unexpected time text: {text!r}")
    hour, minute = int(match[1]), int(match[2])
    if not 1 <= hour <= _MAX_CLOCK_HOUR or minute > _MAX_MINUTE:
        raise PageFormatError(f"Time out of range: {text!r}")
    hour %= _MAX_CLOCK_HOUR
    if match[3].upper() == "PM":
        hour += _MAX_CLOCK_HOUR
    return hour, minute
 def is_target_time(card: ClassCard) -> bool:
    """@brief Tell whether the class starts at the time the bot books.
    @param card The class.
    @return True at `TARGET_HOUR`:`TARGET_MINUTE`.
    @exception PageFormatError The time text is not valid.
    """
    return parse_time(card.time_text) == (constants.TARGET_HOUR, constants.TARGET_MINUTE)
 def find_next_class(cards: Iterable[ClassCard], weekday: str) -> ClassCard | None:
    """@brief Find the first class of a weekday at the target time, in page order.
    The weekday is read from each card's day label; the position in the list means nothing.
    Classes already completed are skipped.
    @param cards The classes in the order of the page.
    @param weekday The weekday as the site abbreviates it (`Tue`).
    @return The class, or None when there is none.
    """
    for card in cards:
        if card.state is ButtonState.COMPLETED:
            continue
        if card.weekday == weekday and is_target_time(card):
            return card
    return None
 def find_target_classes(cards: Iterable[ClassCard]) -> list[ClassCard]:
    """@brief Find every class on a target weekday at the target time, in page order.
    The weekday is read from each card's day label; the position in the list means nothing.
    Classes already completed are skipped.
    @param cards The classes in the order of the page.
    @return The classes to handle; empty when there is none.
    @exception PageFormatError A day label or time text is not valid.
    """
    return [
        card
        for card in cards
        if card.state is not ButtonState.COMPLETED
        and card.weekday in constants.TARGET_WEEKDAYS
        and is_target_time(card)
    ]
 def decide_outcome_action(card: ClassCard) -> Action:
    """@brief Decide what to do from the state of the button.
    @param card The class.
    @return The action.
    @exception UnknownButtonError The button is busy, completed or unknown; `retry` can repeat.
    """
    action = _ACTION_OF_STATE.get(card.state)
    if action is None:
        raise UnknownButtonError(f"Cannot act on button {card.button_text!r} of {card.name}")
    return action
 def format_outcome(outcome: Outcome, card: ClassCard) -> str:
    """@brief Build the console message of an outcome.
    @param outcome What happened.
    @param card The class; its day label is shown as the site writes it.
    @return For example `✓ Successfully booked: Spin Class on Tomorrow (Thu, Aug 14)`.
    """
    return _MESSAGE_OF_OUTCOME[outcome].format(name=card.name, day=card.day_label)
@@ -0,0 +1,108 @@
 """@file verification.py
@brief Lecture steps 7 and 8: compare what the bot did with the My Bookings page.
 """
 from collections import Counter
 from collections.abc import Sequence
 from dataclasses import dataclass
 from snack_and_lift import constants
 from snack_and_lift.domain.booking_entry import BookingEntry
 from snack_and_lift.domain.models import ClassResult, Outcome
 _WAITLISTED_OUTCOMES = (Outcome.NEW_WAITLIST, Outcome.ALREADY_WAITLISTED)
 ## An entry is identified by its class name, its date text and whether it is waitlisted.
 _Key = tuple[str, str, bool]
@dataclass(frozen=True, slots=True)
 class VerificationResult:
    """@brief What the My Bookings page shows compared with what the bot did.
    `verified`, `missing` and `unexpected` hold display names, with the waitlist suffix for a
    waitlist entry; `missing` and `unexpected` also say the day (`Spin Class on Tue, Aug 12`).
    """
    expected: int
    found: int
    verified: list[str]
    missing: list[str]
    unexpected: list[str]
    @property
    def is_success(self) -> bool:
        """@brief True when every expected entry was found and nothing else was."""
        return self.expected == self.found and not self.missing and not self.unexpected
 def _display_name(name: str, waitlisted: bool) -> str:
    """@brief The name as the page shows it."""
    return name + constants.WAITLIST_NAME_SUFFIX if waitlisted else name
 def _expected_keys(results: Sequence[ClassResult]) -> list[_Key]:
    """@brief The entries the bot's results say must be on the page."""
    return [(r.card.name, r.card.date_text, r.outcome in _WAITLISTED_OUTCOMES) for r in results]
 def _entry_keys(entries: Sequence[BookingEntry]) -> list[_Key]:
    """@brief The identity of each entry found on the page."""
    return [(e.name, e.date_text, e.waitlisted) for e in entries]
 def _describe(key: _Key) -> str:
    """@brief Write an entry for the missing and unexpected lines."""
    name, day, waitlisted = key
    return f"{_display_name(name, waitlisted)} on {day}"
 def build_verification(
    results: Sequence[ClassResult], entries: Sequence[BookingEntry]
 ) -> VerificationResult:
    """@brief Compare the results of the booking with the target entries of the page.
    @param results What happened to each class; waitlisted when the outcome is a waitlist one.
    @param entries The Tuesday and Thursday 6pm entries found on the page.
    @return The comparison; the counts are the numbers of results and of entries.
    @exception PageFormatError An entry or a card has no valid date.
    """
    expected = _expected_keys(results)
    remaining = Counter(_entry_keys(entries))
    verified: list[str] = []
    missing: list[str] = []
    for key in expected:
        if remaining[key] > 0:
            remaining[key] -= 1
            verified.append(_display_name(key[0], key[2]))
        else:
            missing.append(_describe(key))
    unexpected = [_describe(key) for key in remaining.elements()]
    return VerificationResult(len(expected), len(entries), verified, missing, unexpected)
 def _count_text(template: str, count: int) -> str:
    """@brief Write a count with `booking` in the singular for 1."""
    noun = constants.VERIFY_NOUN_SINGULAR if count == 1 else constants.VERIFY_NOUN_PLURAL
    return template.format(count=count, noun=noun)
 def format_verification(result: VerificationResult) -> str:
    """@brief Write the verification block.
    @param result The comparison.
    @return The block, starting with `--- VERIFYING ON MY BOOKINGS PAGE ---`.
    """
    lines = [constants.VERIFY_TITLE]
    lines.extend(constants.VERIFY_LINE_VERIFIED.format(name=name) for name in result.verified)
    lines.append("")
    lines.append(constants.VERIFY_RESULT_TITLE)
    lines.append(_count_text(constants.VERIFY_EXPECTED, result.expected))
    lines.append(_count_text(constants.VERIFY_FOUND, result.found))
    if result.is_success:
        lines.append(constants.VERIFY_SUCCESS)
        return "\n".join(lines)
    lines.append(constants.VERIFY_MISMATCH.format(count=result.expected - result.found))
    lines.extend(constants.VERIFY_LINE_MISSING.format(entry=text) for text in result.missing)
    lines.extend(constants.VERIFY_LINE_UNEXPECTED.format(entry=text) for text in result.unexpected)
    return "\n".join(lines)
@@ -0,0 +1,35 @@
 """@file console_recorder.py
@brief Keeps the lines the bot logs, so they can be drawn as the lecture's console screenshot.
 """
 import logging
 class ConsoleRecorder(logging.Handler):
    """@brief A logging handler that stores the formatted message of every record."""
    def __init__(self, level: int = logging.NOTSET) -> None:
        """@brief Create an empty recorder.
        @param level The lowest level to keep.
        """
        super().__init__(level)
        self.setFormatter(logging.Formatter("%(message)s"))
        self._lines: list[str] = []
    @property
    def lines(self) -> list[str]:
        """@brief The recorded lines, oldest first (a copy)."""
        return list(self._lines)
    @property
    def text(self) -> str:
        """@brief The recorded lines joined by newlines."""
        return "\n".join(self._lines)
    def emit(self, record: logging.LogRecord) -> None:
        """@brief Store one record.
        @param record The log record.
        """
        self._lines.append(self.format(record))
@@ -3,10 +3,13 @@
 """
 import functools
 import html
 import logging
 import urllib.parse
 from collections.abc import Callable
 from pathlib import Path
-from typing import Concatenate
+from string import Template
 from typing import Concatenate, Literal
 from selenium.common.exceptions import (
    ElementClickInterceptedException,
@@ -16,11 +19,14 @@ from selenium.common.exceptions import (
 )
 from selenium.webdriver.common.by import By
 from selenium.webdriver.remote.webdriver import WebDriver
 from selenium.webdriver.remote.webelement import WebElement
 from selenium.webdriver.support import expected_conditions as ec
 from selenium.webdriver.support.ui import WebDriverWait
 from snack_and_lift import constants
 from snack_and_lift.domain.booking_entry import BookingEntry
 from snack_and_lift.domain.errors import GymError, LoginFailedError
 from snack_and_lift.domain.models import ButtonState, ClassCard
 logger = logging.getLogger(__name__)
@@ -98,6 +104,144 @@ class SeleniumGym:
        if errors:
            raise LoginFailedError(errors[0].text)
    @_translate_errors
    def list_class_cards(self) -> list[ClassCard]:
        """@brief Read every class card; the day comes from the ancestor day group.
        @return The classes in page order.
        @exception GymError The schedule could not be read.
        """
        self._wait.until(
            ec.presence_of_element_located((By.CSS_SELECTOR, constants.CLASS_CARD_CSS))
        )
        elements = self._driver.find_elements(By.CSS_SELECTOR, constants.CLASS_CARD_CSS)
        return [self._read_card(element) for element in elements]
    def _read_card(self, element: WebElement) -> ClassCard:
        """@brief Turn one card element into plain data.
        @param element The card.
        @return The class.
        """
        card_id = (element.get_attribute("id") or "").removeprefix(constants.CLASS_CARD_ID_PREFIX)
        buttons = element.find_elements(By.ID, constants.BOOK_BUTTON_ID_PREFIX + card_id)
        labels = element.find_elements(By.ID, constants.COMPLETED_LABEL_ID_PREFIX + card_id)
        control = (buttons or labels or [None])[0]
        return ClassCard(
            card_id=card_id,
            name=element.find_element(By.ID, constants.CLASS_NAME_ID_PREFIX + card_id).text,
            day_label=element.find_element(By.XPATH, constants.DAY_TITLE_XPATH).text,
            time_text=element.find_element(By.ID, constants.CLASS_TIME_ID_PREFIX + card_id).text,
            button_text=control.text if control is not None else "",
        )
    @_translate_errors
    def press_class_button(self, card_id: str) -> str:
        """@brief Scroll to the button, click it and wait for the result or the error box.
        @param card_id The id of the card without its prefix.
        @return The new text of the button.
        @exception GymError The site shows an error for the class, or nothing settled in time.
        """
        button_id = constants.BOOK_BUTTON_ID_PREFIX + card_id
        button = self._wait.until(ec.presence_of_element_located((By.ID, button_id)))
        self._driver.execute_script("arguments[0].scrollIntoView({block: 'center'});", button)
        before = button.text
        self._wait.until(ec.element_to_be_clickable((By.ID, button_id))).click()
        def settled(driver: WebDriver) -> tuple[str, str] | Literal[False]:
            errors = driver.find_elements(By.ID, constants.CLASS_ERROR_ID_PREFIX + card_id)
            text = driver.find_element(By.ID, button_id).text
            if errors:
                return text, errors[0].text or "class error"
            if text != before and ButtonState.from_text(text) is not ButtonState.BUSY:
                return text, ""
            return False
        text, error = self._wait.until(settled)
        if error:
            raise GymError(error)
        return text
    @_translate_errors
    def open_my_bookings(self) -> None:
        """@brief Click the My Bookings link and wait for the page.
        @exception GymError The page did not load.
        """
        self._wait.until(ec.element_to_be_clickable((By.ID, constants.MY_BOOKINGS_LINK_ID))).click()
        self._wait.until(ec.presence_of_element_located((By.ID, constants.MY_BOOKINGS_PAGE_ID)))
    @_translate_errors
    def list_my_bookings(self) -> list[BookingEntry]:
        """@brief Wait for the bookings to load, then read the confirmed and waitlist cards.
        @return The entries, confirmed ones first; empty when the page shows its empty state.
        @exception GymError The page shows an error box, or nothing was shown in time.
        """
        self._wait.until(
            ec.any_of(
                ec.presence_of_element_located((By.CSS_SELECTOR, constants.BOOKING_CARD_CSS)),
                ec.presence_of_element_located((By.CSS_SELECTOR, constants.WAITLIST_CARD_CSS)),
                ec.presence_of_element_located((By.ID, constants.EMPTY_BOOKINGS_STATE_ID)),
                ec.presence_of_element_located((By.ID, constants.ERROR_MESSAGE_ID)),
            )
        )
        errors = self._driver.find_elements(By.ID, constants.ERROR_MESSAGE_ID)
        if errors:
            raise GymError(errors[0].text or "My Bookings error")
        confirmed = self._driver.find_elements(By.CSS_SELECTOR, constants.BOOKING_CARD_CSS)
        waitlist = self._driver.find_elements(By.CSS_SELECTOR, constants.WAITLIST_CARD_CSS)
        return [
            self._read_entry(
                element, constants.BOOKING_CARD_ID_PREFIX, constants.BOOKING_NAME_ID_PREFIX, False
            )
            for element in confirmed
        ] + [
            self._read_entry(
                element, constants.WAITLIST_CARD_ID_PREFIX, constants.WAITLIST_NAME_ID_PREFIX, True
            )
            for element in waitlist
        ]
    @staticmethod
    def _read_entry(
        element: WebElement, card_prefix: str, name_prefix: str, waitlisted: bool
    ) -> BookingEntry:
        """@brief Turn one booking or waitlist card into plain data.
        @param element The card.
        @param card_prefix The prefix of the card id.
        @param name_prefix The prefix of the id of the card's heading.
        @param waitlisted True for a card of the waitlist section.
        @return The entry.
        """
        card_id = (element.get_attribute("id") or "").removeprefix(card_prefix)
        return BookingEntry.from_page(
            heading=element.find_element(By.ID, name_prefix + card_id).text,
            when_text=element.find_element(By.XPATH, constants.WHEN_XPATH).text,
            waitlisted=waitlisted,
        )
    @_translate_errors
    def save_text_screenshot(self, text: str, path: Path) -> None:
        """@brief Draw console text in a temporary tab and save a screenshot of it.
        A tab is used so that the schedule page keeps its state.
        @param text The lines to draw.
        @param path The PNG file to write; its folders are created.
        """
        page = Template(constants.CONSOLE_PAGE_TEMPLATE).substitute(text=html.escape(text))
        original = self._driver.current_window_handle
        self._driver.switch_to.new_window("tab")
        try:
            self._driver.get(constants.CONSOLE_PAGE_URL_PREFIX + urllib.parse.quote(page))
            self.save_screenshot(path)
        finally:
            self._driver.close()
            self._driver.switch_to.window(original)
    def save_screenshot(self, path: Path) -> None:
        """@brief Save a screenshot of the current page.
@@ -0,0 +1,47 @@
 <!DOCTYPE html>
 <html lang="en">
 <head><meta charset="utf-8"><title>Fixture gym my bookings</title></head>
 <body>
  <nav><a id="my-bookings-link" href="my_bookings.html">My Bookings</a></nav>
  <div id="my-bookings-page" data-bookings-count="0" data-waitlist-count="0" data-loading="true">
    <h1>My Bookings</h1>
    <p id="loading-placeholder">Loading your bookings...</p>
    <div id="content"></div>
  </div>
  <script>
    // Imitates the site: a loading text, then the page for the state in the query
    // (?state=empty or ?state=error; anything else shows two bookings and a waitlist entry).
    const state = new URLSearchParams(window.location.search).get("state");
    // The nav link keeps the state, so opening the page from here shows the same state again.
    document.getElementById("my-bookings-link").href = "my_bookings.html" + window.location.search;
    const page = document.getElementById("my-bookings-page");
    const content = document.getElementById("content");
    setTimeout(function () {
      document.getElementById("loading-placeholder").remove();
      page.dataset.loading = "false";
      if (state === "error") {
        content.innerHTML = '<div id="error-message">Failed to load bookings</div>';
      } else if (state === "empty") {
        content.innerHTML = '<div id="empty-bookings-state">You have no bookings yet</div>';
      } else {
        page.dataset.bookingsCount = "2";
        page.dataset.waitlistCount = "1";
        content.innerHTML =
          '<div id="confirmed-bookings-section">' +
          '<div id="booking-card-11" data-booking-status="confirmed">' +
          '<h3 id="booking-class-name-11">Spin Class</h3>' +
          '<p><strong>When:</strong> Tue, Aug 12, 6:00 PM</p></div>' +
          '<div id="booking-card-12" data-booking-status="confirmed">' +
          '<h3 id="booking-class-name-12">Yoga Class</h3>' +
          '<p><strong>When:</strong> Wed, Aug 13, 7:00 AM</p></div>' +
          '</div>' +
          '<div id="waitlist-section">' +
          '<div id="waitlist-card-21" data-booking-status="waitlisted">' +
          '<h3 id="waitlist-class-name-21">HIIT Class (Waitlist)</h3>' +
          '<p><strong>When:</strong> Thu, Aug 14, 6:00 PM</p></div>' +
          '</div>';
      }
    }, 200);
  </script>
 </body>
 </html>
@@ -2,6 +2,84 @@
 <html lang="en">
 <head><meta charset="utf-8"><title>Fixture gym schedule</title></head>
 <body>
-  <div id="schedule-page">Class schedule</div>
+  <nav><a id="my-bookings-link" href="my_bookings.html">My Bookings</a></nav>
  <div id="schedule-page">
    <h1>Class Schedule (Today: Wed, Aug 13)</h1>
    <select id="day-filter"><option>Next 7 Days</option></select>
    <div id="day-group-wed-aug-13">
      <h2 id="day-title-wed-aug-13">Today (Wed, Aug 13)</h2>
      <div id="class-card-101" data-class-type="yoga" data-user-booked="false">
        <h3 id="class-name-101">Yoga Class</h3>
        <p id="class-time-101"><strong>Time:</strong> 6:00 AM</p>
        <span id="completed-label-101">Completed</span>
      </div>
      <div id="class-card-102" data-class-type="spin" data-user-booked="false">
        <h3 id="class-name-102">Spin Class</h3>
        <p id="class-time-102"><strong>Time:</strong> 6:00 PM</p>
        <button id="book-button-102">Book Class</button>
      </div>
    </div>
    <div id="day-group-thu-aug-14">
      <h2 id="day-title-thu-aug-14">Tomorrow (Thu, Aug 14)</h2>
      <div id="class-card-201" data-class-type="hiit" data-user-booked="false">
        <h3 id="class-name-201">HIIT Class</h3>
        <p id="class-time-201"><strong>Time:</strong> 6:00 PM</p>
        <button id="book-button-201">Join Waitlist</button>
      </div>
    </div>
    <div id="day-group-fri-aug-15">
      <h2 id="day-title-fri-aug-15">Fri, Aug 15</h2>
      <div id="class-card-401" data-class-type="hiit" data-user-booked="true">
        <h3 id="class-name-401">HIIT Class</h3>
        <p id="class-time-401"><strong>Time:</strong> 5:00 PM</p>
        <button id="book-button-401" disabled>Booked</button>
      </div>
    </div>
    <div id="day-group-tue-aug-19">
      <h2 id="day-title-tue-aug-19">Tue, Aug 19</h2>
      <div id="class-card-301" data-class-type="yoga" data-user-booked="false">
        <h3 id="class-name-301">Yoga Class</h3>
        <p id="class-time-301"><strong>Time:</strong> 7:00 AM</p>
        <button id="book-button-301">Book Class</button>
      </div>
      <div id="class-card-302" data-class-type="spin" data-user-booked="false" data-fail-once="true">
        <h3 id="class-name-302">Spin Class</h3>
        <p id="class-time-302"><strong>Time:</strong> 6:00 PM</p>
        <button id="book-button-302">Book Class</button>
      </div>
    </div>
  </div>
  <script>
    // Imitates the site: a busy text, then the new state; card 302 fails on its first click.
    document.querySelectorAll("button[id^='book-button-']").forEach(function (button) {
      button.addEventListener("click", function () {
        const id = button.id.replace("book-button-", "");
        const card = document.getElementById("class-card-" + id);
        const oldText = button.textContent;
        const stale = document.getElementById("class-error-" + id);
        if (stale) { stale.remove(); }
        const waitlist = oldText === "Join Waitlist";
        button.textContent = waitlist ? "Joining..." : "Booking...";
        button.disabled = true;
        setTimeout(function () {
          if (card.dataset.failOnce === "true") {
            card.dataset.failOnce = "false";
            button.textContent = oldText;
            button.disabled = false;
            const box = document.createElement("div");
            box.id = "class-error-" + id;
            box.textContent = "Network error, please try again";
            card.appendChild(box);
            return;
          }
          button.textContent = waitlist ? "Waitlisted" : "Booked";
        }, 200);
      });
    });
  </script>
 </body>
 </html>
@@ -3,12 +3,16 @@
 """
 import os
-from collections.abc import Iterator
+from collections.abc import Callable, Iterator
 from pathlib import Path
 import pytest
-from snack_and_lift.domain.errors import LoginFailedError
+from snack_and_lift.application.booking import book_target_classes
 from snack_and_lift.application.verification import get_my_bookings
 from snack_and_lift.domain.booking_entry import BookingEntry
 from snack_and_lift.domain.errors import GymError, LoginFailedError, NoBookingsFoundError
 from snack_and_lift.domain.models import Outcome
 from snack_and_lift.infrastructure.browser import create_driver
 from snack_and_lift.infrastructure.selenium_gym import SeleniumGym
@@ -55,3 +59,132 @@ def test_save_screenshot_creates_the_folder(gym: SeleniumGym, tmp_path: Path) ->
    gym.save_screenshot(target)
    assert target.stat().st_size > 0
 FIXTURE_SCHEDULE = (Path(__file__).parent / "fixtures" / "schedule.html").as_uri()
@pytest.fixture
 def schedule_gym(tmp_path: Path) -> Iterator[SeleniumGym]:
    driver = create_driver(headless=True, profile_dir=tmp_path / "profile", keep_open=False)
    try:
        driver.get(FIXTURE_SCHEDULE)
        yield SeleniumGym(driver, base_url=FIXTURE_SCHEDULE)
    finally:
        driver.quit()
 def test_list_class_cards_reads_the_day_from_the_ancestor_group(schedule_gym: SeleniumGym) -> None:
    cards = {card.card_id: card for card in schedule_gym.list_class_cards()}
    assert list(cards) == ["101", "102", "201", "401", "301", "302"]
    assert cards["102"].day_label == "Today (Wed, Aug 13)"
    assert cards["201"].weekday == "Thu"
    assert cards["302"].weekday == "Tue"
    assert cards["302"].name == "Spin Class"
    assert cards["302"].time_text == "Time: 6:00 PM"
    assert cards["302"].button_text == "Book Class"
    assert cards["101"].button_text == "Completed"
    assert cards["401"].button_text == "Booked"
 def test_press_class_button_confirms_booking(schedule_gym: SeleniumGym) -> None:
    assert schedule_gym.press_class_button("102") == "Booked"
 def test_press_class_button_confirms_waitlist(schedule_gym: SeleniumGym) -> None:
    assert schedule_gym.press_class_button("201") == "Waitlisted"
 def test_press_class_button_raises_with_the_error_text_then_succeeds(
    schedule_gym: SeleniumGym,
 ) -> None:
    with pytest.raises(GymError, match="Network error"):
        schedule_gym.press_class_button("302")
    assert schedule_gym.press_class_button("302") == "Booked"
 def test_save_text_screenshot_writes_a_png_and_keeps_the_page(
    schedule_gym: SeleniumGym, tmp_path: Path
 ) -> None:
    target = tmp_path / "shots" / "step-4.png"
    schedule_gym.save_text_screenshot("✓ Successfully booked: <Spin Class>", target)
    assert target.read_bytes().startswith(b"\x89PNG")
    assert schedule_gym.list_class_cards()
 def test_book_target_classes_books_every_tuesday_and_thursday_class(
    schedule_gym: SeleniumGym,
 ) -> None:
    with pytest.raises(GymError, match="Network error"):
        book_target_classes(schedule_gym)
    results = book_target_classes(schedule_gym)
    assert [(r.card.card_id, r.outcome) for r in results] == [
        ("201", Outcome.ALREADY_WAITLISTED),
        ("302", Outcome.NEW_BOOKING),
    ]
 FIXTURE_MY_BOOKINGS = (Path(__file__).parent / "fixtures" / "my_bookings.html").as_uri()
@pytest.fixture
 def open_my_bookings_page(tmp_path: Path) -> Iterator[Callable[[str], SeleniumGym]]:
    """@brief Opens the My Bookings fixture in the given state (a query such as `?state=empty`)."""
    driver = create_driver(headless=True, profile_dir=tmp_path / "profile", keep_open=False)
    def open_page(query: str = "") -> SeleniumGym:
        driver.get(FIXTURE_MY_BOOKINGS + query)
        return SeleniumGym(driver, base_url=FIXTURE_MY_BOOKINGS)
    try:
        yield open_page
    finally:
        driver.quit()
 def test_open_my_bookings_follows_the_nav_link(schedule_gym: SeleniumGym) -> None:
    schedule_gym.open_my_bookings()
    assert [entry.name for entry in schedule_gym.list_my_bookings()] == [
        "Spin Class",
        "Yoga Class",
        "HIIT Class",
    ]
 def test_list_my_bookings_reads_confirmed_and_waitlist_entries(
    open_my_bookings_page: Callable[[str], SeleniumGym],
 ) -> None:
    entries = open_my_bookings_page("").list_my_bookings()
    assert entries == [
        BookingEntry("Spin Class", "Tue, Aug 12, 6:00 PM", False),
        BookingEntry("Yoga Class", "Wed, Aug 13, 7:00 AM", False),
        BookingEntry("HIIT Class", "Thu, Aug 14, 6:00 PM", True),
    ]
 def test_list_my_bookings_returns_nothing_for_the_empty_state(
    open_my_bookings_page: Callable[[str], SeleniumGym],
 ) -> None:
    assert open_my_bookings_page("?state=empty").list_my_bookings() == []
 def test_get_my_bookings_raises_for_the_empty_state(
    open_my_bookings_page: Callable[[str], SeleniumGym],
 ) -> None:
    with pytest.raises(NoBookingsFoundError):
        get_my_bookings(open_my_bookings_page("?state=empty"))
 def test_list_my_bookings_raises_with_the_text_of_the_error_box(
    open_my_bookings_page: Callable[[str], SeleniumGym],
 ) -> None:
    with pytest.raises(GymError, match="Failed to load bookings"):
        open_my_bookings_page("?state=error").list_my_bookings()
@@ -4,17 +4,61 @@
 from pathlib import Path
-from snack_and_lift.domain.errors import LoginFailedError
+from snack_and_lift import constants
 from snack_and_lift.domain.booking_entry import BookingEntry
 from snack_and_lift.domain.errors import GymError, LoginFailedError
 from snack_and_lift.domain.models import ButtonState, ClassCard
 _PRESS_RESULTS = {
    constants.BUTTON_TEXT_BOOK: constants.BUTTON_TEXT_BOOKED,
    constants.BUTTON_TEXT_JOIN_WAITLIST: constants.BUTTON_TEXT_WAITLISTED,
 }
 _WAITLISTED_BY_STATE = {
    ButtonState.BOOK: False,
    ButtonState.BOOKED: False,
    ButtonState.JOIN_WAITLIST: True,
    ButtonState.WAITLISTED: True,
 }
 def _entry_of(card: ClassCard) -> BookingEntry | None:
    """@brief The My Bookings entry that a card ends in, or None when it is not booked."""
    flag = _WAITLISTED_BY_STATE.get(card.state)
    if flag is None:
        return None
    time_text = card.time_text.removeprefix(constants.TIME_TEXT_PREFIX).strip()
    return BookingEntry(card.name, f"{card.date_text}, {time_text}", flag)
 class FakeGym:
-    """@brief Records the calls; can be told to refuse the login."""
+    """@brief Records the calls; can refuse the login, serve cards and fail a click.
-    def __init__(self, login_error: str | None = None) -> None:
+    Unless `bookings` is given, the My Bookings page shows every card that is, or by the
    click becomes, booked or waitlisted.
    """
    def __init__(
        self,
        login_error: str | None = None,
        cards: list[ClassCard] | None = None,
        press_result: str | None = None,
        press_error: str | None = None,
        bookings: list[BookingEntry] | None = None,
        bookings_error: str | None = None,
    ) -> None:
        self.login_error = login_error
        self.cards = cards or []
        self.press_result = press_result
        self.press_error = press_error
        self.bookings = bookings
        self.bookings_error = bookings_error
        self.calls: list[str] = []
        self.logins: list[tuple[str, str]] = []
        self.screenshots: list[Path] = []
        self.text_screenshots: list[tuple[str, Path]] = []
        self.pressed: list[str] = []
        self.closed = False
    def open_site(self) -> None:
@@ -26,6 +70,36 @@ class FakeGym:
        if self.login_error is not None:
            raise LoginFailedError(self.login_error)
    def list_class_cards(self) -> list[ClassCard]:
        self.calls.append("list_class_cards")
        return list(self.cards)
    def press_class_button(self, card_id: str) -> str:
        self.calls.append("press_class_button")
        self.pressed.append(card_id)
        if self.press_error is not None:
            raise GymError(self.press_error)
        if self.press_result is not None:
            return self.press_result
        card = next(card for card in self.cards if card.card_id == card_id)
        return _PRESS_RESULTS[card.button_text]
    def open_my_bookings(self) -> None:
        self.calls.append("open_my_bookings")
    def list_my_bookings(self) -> list[BookingEntry]:
        self.calls.append("list_my_bookings")
        if self.bookings_error is not None:
            raise GymError(self.bookings_error)
        if self.bookings is not None:
            return list(self.bookings)
        entries = (_entry_of(card) for card in self.cards)
        return [entry for entry in entries if entry is not None]
    def save_text_screenshot(self, text: str, path: Path) -> None:
        self.calls.append("save_text_screenshot")
        self.text_screenshots.append((text, path))
    def save_screenshot(self, path: Path) -> None:
        self.calls.append("save_screenshot")
        self.screenshots.append(path)
@@ -0,0 +1,81 @@
 """@file test_application_verification.py
@brief Reading the My Bookings page and verifying the bookings, against a fake gym.
 """
 import pytest
 from tests.unit.fakes import FakeGym
 from tests.unit.test_booking_entry import make_entry
 from tests.unit.test_models import make_card
 from snack_and_lift.application.booking import book_target_classes
 from snack_and_lift.application.verification import get_my_bookings, verify_bookings
 from snack_and_lift.domain.errors import GymError, NoBookingsFoundError
 from snack_and_lift.domain.models import ClassResult, Outcome
 def test_get_my_bookings_opens_the_page_and_returns_all_entries() -> None:
    entries = [make_entry("Wed, Aug 13, 7:00 AM"), make_entry(waitlisted=True)]
    gym = FakeGym(bookings=entries)
    assert get_my_bookings(gym) == entries
    assert gym.calls == ["open_my_bookings", "list_my_bookings"]
 def test_get_my_bookings_raises_when_the_page_has_no_entry() -> None:
    with pytest.raises(NoBookingsFoundError):
        get_my_bookings(FakeGym(bookings=[]))
 def test_get_my_bookings_propagates_the_page_error() -> None:
    with pytest.raises(GymError, match="Failed to load"):
        get_my_bookings(FakeGym(bookings_error="Failed to load bookings"))
 def test_verify_bookings_succeeds_for_the_booked_classes() -> None:
    gym = FakeGym(
        cards=[
            make_card("Tue, Aug 12", card_id="1"),
            make_card("Thu, Aug 14", card_id="2", button_text="Join Waitlist"),
        ]
    )
    results = book_target_classes(gym)
    verification = verify_bookings(gym, results)
    assert verification.is_success
    assert verification.verified == ["Spin Class", "Spin Class (Waitlist)"]
 def test_verify_bookings_ignores_entries_that_are_not_target_classes() -> None:
    gym = FakeGym(bookings=[make_entry(), make_entry("Wed, Aug 13, 6:00 PM")])
    results = [ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)]
    assert verify_bookings(gym, results).is_success
 def test_verify_bookings_reports_a_missing_booking() -> None:
    gym = FakeGym(bookings=[make_entry("Wed, Aug 13, 7:00 AM")])
    results = [ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)]
    verification = verify_bookings(gym, results)
    assert not verification.is_success
    assert verification.missing == ["Spin Class on Tue, Aug 12"]
 def test_verify_bookings_raises_when_classes_were_booked_but_the_page_is_empty() -> None:
    gym = FakeGym(bookings=[])
    results = [ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)]
    with pytest.raises(NoBookingsFoundError):
        verify_bookings(gym, results)
 def test_verify_bookings_skips_the_page_when_nothing_is_expected() -> None:
    gym = FakeGym()
    verification = verify_bookings(gym, [])
    assert verification.is_success
    assert verification.expected == 0
    assert gym.calls == []
@@ -0,0 +1,150 @@
 """@file test_booking.py
@brief Booking a class and booking the next Tuesday class, against a fake gym.
 """
 import logging
 import pytest
 from tests.unit.fakes import FakeGym
 from tests.unit.test_models import make_card
 from snack_and_lift.application.booking import (
    book_class,
    book_next_tuesday,
    book_target_classes,
 )
 from snack_and_lift.domain.errors import GymError, UnknownButtonError
 from snack_and_lift.domain.models import Outcome
@pytest.mark.parametrize(
    ("button_text", "outcome", "message"),
    [
        ("Book Class", Outcome.NEW_BOOKING, "✓ Successfully booked: Spin Class on"),
        ("Join Waitlist", Outcome.NEW_WAITLIST, "✓ Joined waitlist for: Spin Class on"),
    ],
 )
 def test_book_class_clicks_and_confirms(
    button_text: str, outcome: Outcome, message: str, caplog: pytest.LogCaptureFixture
 ) -> None:
    card = make_card(button_text=button_text)
    gym = FakeGym(cards=[card])
    with caplog.at_level(logging.INFO):
        result = book_class(gym, card)
    assert result.outcome is outcome
    assert gym.pressed == ["123"]
    assert message in caplog.text
@pytest.mark.parametrize(
    ("button_text", "outcome"),
    [("Booked", Outcome.ALREADY_BOOKED), ("Waitlisted", Outcome.ALREADY_WAITLISTED)],
 )
 def test_book_class_does_not_click_when_already_done(button_text: str, outcome: Outcome) -> None:
    gym = FakeGym()
    result = book_class(gym, make_card(button_text=button_text))
    assert result.outcome is outcome
    assert gym.pressed == []
 def test_book_class_raises_when_click_is_not_confirmed() -> None:
    card = make_card()
    gym = FakeGym(cards=[card], press_result="Book Class")
    with pytest.raises(GymError, match="click not confirmed"):
        book_class(gym, card)
 def test_book_class_raises_when_waitlist_click_gives_booked() -> None:
    card = make_card(button_text="Join Waitlist")
    with pytest.raises(GymError, match="click not confirmed"):
        book_class(FakeGym(cards=[card], press_result="Booked"), card)
 def test_book_class_propagates_a_site_error() -> None:
    with pytest.raises(GymError, match="Network down"):
        book_class(FakeGym(cards=[make_card()], press_error="Network down"), make_card())
 def test_book_class_raises_for_a_busy_button() -> None:
    with pytest.raises(UnknownButtonError):
        book_class(FakeGym(), make_card(button_text="Booking..."))
 def test_book_next_tuesday_books_the_first_tuesday_class() -> None:
    cards = [
        make_card("Today (Wed, Aug 13)", card_id="1"),
        make_card("Tue, Aug 19", card_id="2"),
        make_card("Tue, Aug 26", card_id="3"),
    ]
    gym = FakeGym(cards=cards)
    result = book_next_tuesday(gym)
    assert result is not None
    assert result.card.card_id == "2"
    assert gym.pressed == ["2"]
 def test_book_next_tuesday_logs_when_there_is_no_class(caplog: pytest.LogCaptureFixture) -> None:
    gym = FakeGym(cards=[make_card("Wed, Aug 13")])
    with caplog.at_level(logging.INFO):
        assert book_next_tuesday(gym) is None
    assert "No Tue class at 18:00 found" in caplog.text
    assert gym.pressed == []
 def test_book_target_classes_handles_every_target_class_in_order() -> None:
    cards = [
        make_card("Today (Wed, Aug 13)", card_id="1"),
        make_card("Tomorrow (Thu, Aug 14)", card_id="2"),
        make_card("Tue, Aug 19", card_id="3", button_text="Join Waitlist"),
        make_card("Thu, Aug 21", card_id="4", button_text="Booked"),
        make_card("Tue, Aug 26", card_id="5", button_text="Waitlisted"),
    ]
    gym = FakeGym(cards=cards)
    results = book_target_classes(gym)
    assert [result.outcome for result in results] == [
        Outcome.NEW_BOOKING,
        Outcome.NEW_WAITLIST,
        Outcome.ALREADY_BOOKED,
        Outcome.ALREADY_WAITLISTED,
    ]
    assert gym.pressed == ["2", "3"]
    assert gym.calls.count("list_class_cards") == 1
 def test_book_target_classes_calls_back_after_each_class() -> None:
    gym = FakeGym(
        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")]
    )
    seen: list[str] = []
    book_target_classes(gym, lambda result: seen.append(result.card.card_id))
    assert seen == ["1", "2"]
 def test_book_target_classes_logs_when_there_is_none(caplog: pytest.LogCaptureFixture) -> None:
    gym = FakeGym(cards=[make_card("Wed, Aug 13")])
    with caplog.at_level(logging.INFO):
        assert book_target_classes(gym) == []
    assert "No Tuesday or Thursday class at 18:00 found" in caplog.text
 def test_book_target_classes_propagates_a_failing_class() -> None:
    gym = FakeGym(cards=[make_card("Thu, Aug 14")], press_error="Network down")
    with pytest.raises(GymError, match="Network down"):
        book_target_classes(gym)
@@ -0,0 +1,65 @@
 """@file test_booking_entry.py
@brief The entries of the My Bookings page: parsing and the target test.
 """
 import dataclasses
 import pytest
 from snack_and_lift.domain.booking_entry import BookingEntry, is_target_entry
 from snack_and_lift.domain.errors import GymError, NoBookingsFoundError, PageFormatError
 def make_entry(
    when_text: str = "Tue, Aug 12, 6:00 PM", name: str = "Spin Class", waitlisted: bool = False
 ) -> BookingEntry:
    return BookingEntry(name, when_text, waitlisted)
 def test_entry_derives_weekday_date_and_time() -> None:
    entry = make_entry("Thu, Aug 14, 6:00 PM")
    assert entry.weekday == "Thu"
    assert entry.date_text == "Thu, Aug 14"
    assert entry.time == (18, 0)
@pytest.mark.parametrize(
    "when_text", ["", "Someday", "Tue, Aug 12", "Tue, Aug 12, noon", "6:00 PM"]
 )
 def test_entry_with_bad_when_text_raises(when_text: str) -> None:
    with pytest.raises(PageFormatError):
        is_target_entry(make_entry(when_text))
 def test_from_page_removes_the_waitlist_suffix_and_the_when_prefix() -> None:
    entry = BookingEntry.from_page("Spin Class (Waitlist)", "When: Tue, Aug 12, 6:00 PM", True)
    assert entry == BookingEntry("Spin Class", "Tue, Aug 12, 6:00 PM", True)
 def test_from_page_keeps_a_plain_name() -> None:
    assert BookingEntry.from_page("Spin Class", "Tue, Aug 12, 6:00 PM", False).name == "Spin Class"
@pytest.mark.parametrize(
    ("when_text", "expected"),
    [
        ("Tue, Aug 12, 6:00 PM", True),
        ("Thu, Aug 14, 6:00 PM", True),
        ("Wed, Aug 13, 6:00 PM", False),
        ("Tue, Aug 12, 6:00 AM", False),
        ("Thu, Aug 14, 6:30 PM", False),
    ],
 )
 def test_is_target_entry(when_text: str, expected: bool) -> None:
    assert is_target_entry(make_entry(when_text)) is expected
 def test_entry_is_immutable() -> None:
    with pytest.raises(dataclasses.FrozenInstanceError):
        make_entry().name = "Other"  # type: ignore[misc]
 def test_no_bookings_found_is_a_gym_error() -> None:
    assert issubclass(NoBookingsFoundError, GymError)
@@ -2,10 +2,13 @@
@brief The command line accepts its options and the entry point wires the use case.
 """
 import logging
 from pathlib import Path
 import pytest
 from tests.unit.fakes import FakeGym
 from tests.unit.test_booking_entry import make_entry
 from tests.unit.test_models import make_card
 from snack_and_lift import constants
 from snack_and_lift.cli import main, parse_args
@@ -61,8 +64,183 @@ def test_main_saves_both_screenshots_on_success(tmp_path: Path) -> None:
    assert code == 0
    assert gym.logins == [(DUMMY_EMAIL, DUMMY_PASSWORD)]
-    assert gym.screenshots == [tmp_path / "step-1.png", tmp_path / "step-2.png"]
+    assert gym.screenshots == [
-    assert gym.calls == ["open_site", "save_screenshot", "log_in", "save_screenshot"]
+        tmp_path / "step-1.png",
        tmp_path / "step-2.png",
        tmp_path / "step-3.png",
        tmp_path / "step-7.png",
    ]
    assert [path for _, path in gym.text_screenshots] == [
        tmp_path / "step-4.png",
        tmp_path / "step-5.png",
        tmp_path / "step-6.png",
        tmp_path / "step-8.png",
    ]
    assert gym.calls == [
        "open_site",
        "save_screenshot",
        "log_in",
        "save_screenshot",
        "list_class_cards",
        "save_screenshot",
        "save_text_screenshot",
        "save_text_screenshot",
        "save_text_screenshot",
        "save_screenshot",
        "save_text_screenshot",
    ]
@pytest.mark.usefixtures("credentials_env")
 def test_main_books_the_class_and_draws_the_console_text(tmp_path: Path) -> None:
    gym = FakeGym(cards=[make_card("Tue, Aug 19")])
    assert main(["--screenshot-dir", str(tmp_path)], lambda *_: gym) == 0
    assert gym.pressed == ["123"]
    text, _ = gym.text_screenshots[0]
    assert "✓ Logged in" in text
    assert "✓ Successfully booked: Spin Class on Tue, Aug 19" in text
@pytest.mark.usefixtures("credentials_env")
 def test_main_books_every_target_class_and_logs_the_report(
    caplog: pytest.LogCaptureFixture,
 ) -> None:
    gym = FakeGym(
        cards=[
            make_card("Tomorrow (Thu, Aug 14)", card_id="1"),
            make_card("Fri, Aug 15", card_id="2"),
            make_card("Tue, Aug 19", card_id="3", button_text="Join Waitlist"),
        ]
    )
    with caplog.at_level(logging.INFO):
        assert main([], lambda *_: gym) == 0
    assert gym.pressed == ["1", "3"]
    assert "New bookings: 1\nNew waitlist entries: 1\nAlready booked/waitlisted: 0" in caplog.text
    assert "Total Tuesday & Thursday 6pm classes: 2" in caplog.text
    assert "  • [New Booking] Spin Class on Tomorrow (Thu, Aug 14)" in caplog.text
    assert "  • [New Waitlist] Spin Class on Tue, Aug 19" in caplog.text
@pytest.mark.usefixtures("credentials_env")
 def test_main_saves_step_3_after_the_first_class_and_the_report_images(tmp_path: Path) -> None:
    gym = FakeGym(
        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")]
    )
    assert main(["--screenshot-dir", str(tmp_path)], lambda *_: gym) == 0
    assert gym.calls == [
        "open_site",
        "save_screenshot",
        "log_in",
        "save_screenshot",
        "list_class_cards",
        "press_class_button",
        "save_screenshot",
        "press_class_button",
        "save_text_screenshot",
        "save_text_screenshot",
        "save_text_screenshot",
        "open_my_bookings",
        "list_my_bookings",
        "save_screenshot",
        "save_text_screenshot",
    ]
    assert gym.screenshots[-2:] == [tmp_path / "step-3.png", tmp_path / "step-7.png"]
    (_, _), (step_5, _), (step_6, _), (step_8, step_8_path) = gym.text_screenshots
    assert step_8_path == tmp_path / "step-8.png"
    assert step_8.startswith("--- VERIFYING ON MY BOOKINGS PAGE ---")
    assert step_8.endswith("✅ SUCCESS: All bookings verified!")
    assert step_5.startswith("--- BOOKING SUMMARY ---\nNew bookings: 2")
    assert "--- DETAILED CLASS LIST ---" not in step_5
    assert step_6.startswith(step_5)
    assert "--- DETAILED CLASS LIST ---\n  • [New Booking] Spin Class on Thu, Aug 14" in step_6
@pytest.mark.usefixtures("credentials_env")
 def test_main_logs_the_verification_and_returns_0_on_success(
    caplog: pytest.LogCaptureFixture,
 ) -> None:
    gym = FakeGym(cards=[make_card("Tue, Aug 19")])
    with caplog.at_level(logging.INFO):
        assert main([], lambda *_: gym) == 0
    assert "--- VERIFYING ON MY BOOKINGS PAGE ---\n  ✓ Verified: Spin Class" in caplog.text
    assert "Expected: 1 booking\nFound: 1 booking\n✅ SUCCESS" in caplog.text
@pytest.mark.usefixtures("credentials_env")
 def test_main_returns_3_on_a_mismatch(tmp_path: Path, caplog: pytest.LogCaptureFixture) -> None:
    gym = FakeGym(cards=[make_card("Tue, Aug 19")], bookings=[make_entry("Wed, Aug 20, 7:00 AM")])
    with caplog.at_level(logging.INFO):
        code = main(["--headless", "--screenshot-dir", str(tmp_path)], lambda *_: gym)
    assert code == 3
    assert "❌ MISMATCH: Missing 1 bookings" in caplog.text
    assert "  ✗ Missing: Spin Class on Tue, Aug 19" in caplog.text
    assert gym.screenshots[-1] == tmp_path / "step-7.png"
    assert gym.text_screenshots[-1][1] == tmp_path / "step-8.png"
    assert gym.closed is True
@pytest.mark.usefixtures("credentials_env")
 def test_main_returns_1_when_the_bookings_page_is_empty() -> None:
    gym = FakeGym(cards=[make_card("Tue, Aug 19")], bookings=[])
    assert main([], lambda *_: gym) == 1
@pytest.mark.usefixtures("credentials_env")
 def test_main_logs_an_empty_report_without_target_classes(
    caplog: pytest.LogCaptureFixture,
 ) -> None:
    gym = FakeGym(cards=[make_card("Wed, Aug 13")])
    with caplog.at_level(logging.INFO):
        assert main([], lambda *_: gym) == 0
    assert "Total Tuesday & Thursday 6pm classes: 0" in caplog.text
    assert "No matching class found" in caplog.text
@pytest.mark.usefixtures("credentials_env")
 def test_main_first_tuesday_only_books_one_class_and_no_report(
    tmp_path: Path, caplog: pytest.LogCaptureFixture
 ) -> None:
    gym = FakeGym(
        cards=[make_card("Thu, Aug 14", card_id="1"), make_card("Tue, Aug 19", card_id="2")]
    )
    with caplog.at_level(logging.INFO):
        code = main(["--first-tuesday-only", "--screenshot-dir", str(tmp_path)], lambda *_: gym)
    assert code == 0
    assert gym.pressed == ["2"]
    assert "BOOKING SUMMARY" not in caplog.text
    assert "VERIFYING" not in caplog.text
    assert "open_my_bookings" not in gym.calls
    assert [path.name for path in gym.screenshots] == ["step-1.png", "step-2.png", "step-3.png"]
    assert [path.name for _, path in gym.text_screenshots] == ["step-4.png"]
@pytest.mark.usefixtures("credentials_env")
 def test_first_tuesday_only_flag_is_read() -> None:
    assert parse_args(["--first-tuesday-only"]).first_tuesday_only is True
    assert parse_args([]).first_tuesday_only is False
@pytest.mark.usefixtures("credentials_env")
 def test_main_returns_1_when_the_booking_fails() -> None:
    gym = FakeGym(cards=[make_card("Tue, Aug 19")], press_error="Network down")
    assert main(["--headless"], lambda *_: gym) == 1
    assert gym.closed is True
@pytest.mark.usefixtures("credentials_env")
@@ -0,0 +1,30 @@
 """@file test_console_recorder.py
@brief The recorder keeps the formatted lines of the log.
 """
 import logging
 from snack_and_lift.infrastructure.console_recorder import ConsoleRecorder
 def test_recorder_keeps_formatted_messages() -> None:
    logger = logging.getLogger("test_console_recorder")
    logger.setLevel(logging.INFO)
    recorder = ConsoleRecorder()
    logger.addHandler(recorder)
    try:
        logger.info("✓ Logged %s", "in")
        logger.warning("careful")
    finally:
        logger.removeHandler(recorder)
    assert recorder.lines == ["✓ Logged in", "careful"]
    assert recorder.text == "✓ Logged in\ncareful"
 def test_recorder_lines_are_a_copy() -> None:
    recorder = ConsoleRecorder()
    recorder.lines.append("x")
    assert recorder.lines == []
@@ -0,0 +1,87 @@
 """@file test_date_independence.py
@brief The bot picks classes by weekday and time only, whatever the first visible day is.
 """
 from datetime import date, timedelta
 import pytest
 from tests.unit.fakes import FakeGym
 from snack_and_lift.application.booking import book_target_classes
 from snack_and_lift.application.verification import verify_bookings
 from snack_and_lift.domain.models import ClassCard
 from snack_and_lift.domain.rules import find_target_classes
 ## A Monday; the schedules below start on this day plus an offset, so every weekday occurs.
 _A_MONDAY = date(2025, 8, 11)
 _DAYS_SHOWN = 8
 _TUESDAY, _THURSDAY = 1, 3
 _TIMES = (
    ("Time: 6:00 AM", "Book Class"),
    ("Time: 6:00 PM", "Book Class"),
    ("Time: 7:00 PM", "Book Class"),
 )
 def _day_text(day: date) -> str:
    return f"{day:%a}, {day:%b} {day.day}"
 def _label(index: int, day: date) -> str:
    if index == 0:
        return f"Today ({_day_text(day)})"
    if index == 1:
        return f"Tomorrow ({_day_text(day)})"
    return _day_text(day)
 def make_schedule(start_offset: int) -> tuple[list[ClassCard], set[str]]:
    """@brief Cards of 8 days from a start weekday, and the ids of the Tue/Thu 6pm ones."""
    cards: list[ClassCard] = []
    wanted: set[str] = set()
    for index in range(_DAYS_SHOWN):
        day = _A_MONDAY + timedelta(days=start_offset + index)
        for slot, (time_text, button) in enumerate(_TIMES):
            card_id = f"{index}{slot}"
            cards.append(ClassCard(card_id, "Spin Class", _label(index, day), time_text, button))
            if day.weekday() in (_TUESDAY, _THURSDAY) and slot == 1:
                wanted.add(card_id)
    return cards, wanted
@pytest.mark.parametrize("start_offset", range(7))
 def test_find_target_classes_for_every_starting_weekday(start_offset: int) -> None:
    cards, wanted = make_schedule(start_offset)
    assert {card.card_id for card in find_target_classes(cards)} == wanted
    assert wanted
@pytest.mark.parametrize("start_offset", range(7))
 def test_booking_and_verification_for_every_starting_weekday(start_offset: int) -> None:
    cards, wanted = make_schedule(start_offset)
    gym = FakeGym(cards=cards)
    results = book_target_classes(gym)
    assert set(gym.pressed) == wanted
    assert len(gym.pressed) == len(wanted)
    assert verify_bookings(gym, results).is_success
 def test_schedule_whose_first_visible_day_is_a_thursday_includes_today() -> None:
    cards, _ = make_schedule(3)
    assert cards[0].day_label.startswith("Today (Thu,")
    chosen = find_target_classes(cards)
    assert [card.weekday for card in chosen] == ["Thu", "Tue", "Thu"]
    assert chosen[0].card_id == "01"
 def test_card_order_does_not_change_which_classes_are_chosen() -> None:
    cards, wanted = make_schedule(2)
    chosen = find_target_classes(list(reversed(cards)))
    assert {card.card_id for card in chosen} == wanted
@@ -0,0 +1,57 @@
 """@file test_models.py
@brief Button states and the values derived from a class card.
 """
 import dataclasses
 import pytest
 from snack_and_lift.domain.errors import PageFormatError
 from snack_and_lift.domain.models import ButtonState, ClassCard
 def make_card(
    day_label: str = "Tomorrow (Thu, Aug 14)",
    time_text: str = "Time: 6:00 PM",
    button_text: str = "Book Class",
    card_id: str = "123",
    name: str = "Spin Class",
 ) -> ClassCard:
    return ClassCard(card_id, name, day_label, time_text, button_text)
@pytest.mark.parametrize(
    ("text", "state"),
    [
        ("Book Class", ButtonState.BOOK),
        ("Join Waitlist", ButtonState.JOIN_WAITLIST),
        ("Booked", ButtonState.BOOKED),
        ("Waitlisted", ButtonState.WAITLISTED),
        ("Booking...", ButtonState.BUSY),
        ("Joining...", ButtonState.BUSY),
        ("Completed", ButtonState.COMPLETED),
        (" Booked ", ButtonState.BOOKED),
        ("", ButtonState.UNKNOWN),
        ("Cancel", ButtonState.UNKNOWN),
    ],
 )
 def test_button_state_is_read_from_text(text: str, state: ButtonState) -> None:
    assert ButtonState.from_text(text) is state
 def test_card_derives_state_weekday_and_date() -> None:
    card = make_card()
    assert card.state is ButtonState.BOOK
    assert card.weekday == "Thu"
    assert card.date_text == "Thu, Aug 14"
 def test_card_with_bad_day_label_raises() -> None:
    with pytest.raises(PageFormatError):
        _ = make_card(day_label="Someday").weekday
 def test_card_is_immutable() -> None:
    with pytest.raises(dataclasses.FrozenInstanceError):
        make_card().name = "Other"  # type: ignore[misc]
@@ -0,0 +1,86 @@
 """@file test_report.py
@brief The counters, the booking summary and the detailed class list.
 """
 from tests.unit.test_models import make_card
 from snack_and_lift.domain.models import ClassResult, Outcome
 from snack_and_lift.domain.report import (
    Counters,
    count_results,
    format_detail_list,
    format_summary,
 )
 def make_result(outcome: Outcome, day_label: str = "Tue, Aug 19") -> ClassResult:
    return ClassResult(make_card(day_label), outcome)
 def test_count_results_groups_the_outcomes() -> None:
    results = [
        make_result(Outcome.NEW_BOOKING),
        make_result(Outcome.NEW_BOOKING),
        make_result(Outcome.NEW_WAITLIST),
        make_result(Outcome.ALREADY_BOOKED),
        make_result(Outcome.ALREADY_WAITLISTED),
    ]
    counters = count_results(results)
    assert counters == Counters(new_bookings=2, new_waitlist=1, already_done=2)
    assert counters.total == 5
 def test_count_results_is_zero_for_no_results() -> None:
    assert count_results([]).total == 0
 def test_format_summary_matches_the_lecture() -> None:
    results = [
        make_result(Outcome.NEW_BOOKING, "Tomorrow (Thu, Aug 14)"),
        make_result(Outcome.NEW_WAITLIST),
    ]
    assert format_summary(results) == (
        "--- BOOKING SUMMARY ---\n"
        "New bookings: 1\n"
        "New waitlist entries: 1\n"
        "Already booked/waitlisted: 0\n"
        "Total Tuesday & Thursday 6pm classes: 2"
    )
 def test_format_summary_for_no_results() -> None:
    assert format_summary([]).endswith("Total Tuesday & Thursday 6pm classes: 0")
 def test_format_detail_list_matches_the_lecture() -> None:
    results = [
        make_result(Outcome.NEW_BOOKING, "Tomorrow (Thu, Aug 14)"),
        make_result(Outcome.NEW_WAITLIST),
    ]
    assert format_detail_list(results) == (
        "--- DETAILED CLASS LIST ---\n"
        "  • [New Booking] Spin Class on Tomorrow (Thu, Aug 14)\n"
        "  • [New Waitlist] Spin Class on Tue, Aug 19"
    )
 def test_format_detail_list_tags_every_outcome() -> None:
    results = [
        make_result(Outcome.ALREADY_BOOKED),
        make_result(Outcome.ALREADY_WAITLISTED),
    ]
    lines = format_detail_list(results).splitlines()
    assert lines[1:] == [
        "  • [Already Booked] Spin Class on Tue, Aug 19",
        "  • [Already Waitlisted] Spin Class on Tue, Aug 19",
    ]
 def test_format_detail_list_says_when_no_class_was_found() -> None:
    assert format_detail_list([]) == "--- DETAILED CLASS LIST ---\n  No matching class found"
@@ -0,0 +1,164 @@
 """@file test_rules.py
@brief Day and time parsing, finding the target class, the decision and the messages.
 """
 import pytest
 from tests.unit.test_models import make_card
 from snack_and_lift.domain.errors import PageFormatError, UnknownButtonError
 from snack_and_lift.domain.models import Outcome
 from snack_and_lift.domain.rules import (
    Action,
    decide_outcome_action,
    find_next_class,
    find_target_classes,
    format_outcome,
    is_target_time,
    parse_day_label,
    parse_time,
 )
@pytest.mark.parametrize(
    ("label", "expected"),
    [
        ("Today (Tue, Aug 12)", ("Tue", "Tue, Aug 12")),
        ("Tomorrow (Wed, Aug 13)", ("Wed", "Wed, Aug 13")),
        ("Thu, Aug 14", ("Thu", "Thu, Aug 14")),
        ("  Fri, Sep 5 ", ("Fri", "Fri, Sep 5")),
    ],
 )
 def test_day_label_is_split(label: str, expected: tuple[str, str]) -> None:
    assert parse_day_label(label) == expected
@pytest.mark.parametrize("label", ["", "Tuesday", "Today Tue, Aug 12", "Today (Tue, Aug 12", "x"])
 def test_day_label_junk_raises(label: str) -> None:
    with pytest.raises(PageFormatError):
        parse_day_label(label)
@pytest.mark.parametrize(
    ("text", "expected"),
    [
        ("6:00 PM", (18, 0)),
        ("Time: 6:00 PM", (18, 0)),
        ("12:00 AM", (0, 0)),
        ("12:30 AM", (0, 30)),
        ("12:00 PM", (12, 0)),
        ("11:59 PM", (23, 59)),
        ("1:05 am", (1, 5)),
    ],
 )
 def test_time_is_read(text: str, expected: tuple[int, int]) -> None:
    assert parse_time(text) == expected
@pytest.mark.parametrize("text", ["", "noon", "6 PM", "0:00 AM", "13:00 PM", "6:60 PM", "18:00"])
 def test_time_junk_raises(text: str) -> None:
    with pytest.raises(PageFormatError):
        parse_time(text)
 def test_target_time_is_six_pm() -> None:
    assert is_target_time(make_card(time_text="Time: 6:00 PM"))
    assert not is_target_time(make_card(time_text="Time: 6:00 AM"))
    assert not is_target_time(make_card(time_text="Time: 6:30 PM"))
 def test_next_class_is_found_when_the_schedule_starts_on_a_wednesday() -> None:
    cards = [
        make_card("Today (Wed, Aug 13)", card_id="1"),
        make_card("Thu, Aug 14", card_id="2"),
        make_card("Tue, Aug 19", time_text="Time: 7:00 AM", card_id="3"),
        make_card("Tue, Aug 19", card_id="4"),
        make_card("Tue, Aug 26", card_id="5"),
    ]
    found = find_next_class(cards, "Tue")
    assert found is not None
    assert found.card_id == "4"
 def test_next_class_accepts_a_today_label() -> None:
    cards = [make_card("Today (Tue, Aug 12)", card_id="9")]
    found = find_next_class(cards, "Tue")
    assert found is not None
    assert found.card_id == "9"
 def test_next_class_skips_completed_classes() -> None:
    cards = [
        make_card("Today (Tue, Aug 12)", button_text="Completed", card_id="1"),
        make_card("Tue, Aug 19", card_id="2"),
    ]
    found = find_next_class(cards, "Tue")
    assert found is not None
    assert found.card_id == "2"
 def test_next_class_is_none_without_a_match() -> None:
    assert find_next_class([make_card("Thu, Aug 14")], "Tue") is None
    assert find_next_class([], "Tue") is None
@pytest.mark.parametrize(
    ("button_text", "action"),
    [
        ("Book Class", Action.CLICK_BOOK),
        ("Join Waitlist", Action.CLICK_WAITLIST),
        ("Booked", Action.ALREADY_BOOKED),
        ("Waitlisted", Action.ALREADY_WAITLISTED),
    ],
 )
 def test_action_follows_the_button_state(button_text: str, action: Action) -> None:
    assert decide_outcome_action(make_card(button_text=button_text)) is action
@pytest.mark.parametrize("button_text", ["Booking...", "Joining...", "Completed", "???"])
 def test_action_for_busy_or_unknown_button_raises(button_text: str) -> None:
    with pytest.raises(UnknownButtonError):
        decide_outcome_action(make_card(button_text=button_text))
@pytest.mark.parametrize(
    ("outcome", "message"),
    [
        (Outcome.NEW_BOOKING, "✓ Successfully booked: Spin Class on Tomorrow (Thu, Aug 14)"),
        (Outcome.NEW_WAITLIST, "✓ Joined waitlist for: Spin Class on Tomorrow (Thu, Aug 14)"),
        (Outcome.ALREADY_BOOKED, "✓ Already booked: Spin Class on Tomorrow (Thu, Aug 14)"),
        (Outcome.ALREADY_WAITLISTED, "✓ Already on waitlist: Spin Class on Tomorrow (Thu, Aug 14)"),
    ],
 )
 def test_outcome_message(outcome: Outcome, message: str) -> None:
    assert format_outcome(outcome, make_card()) == message
 def test_find_target_classes_returns_tuesdays_and_thursdays_in_page_order() -> None:
    cards = [
        make_card("Today (Wed, Aug 13)", card_id="1"),
        make_card("Tomorrow (Thu, Aug 14)", card_id="2"),
        make_card("Fri, Aug 15", card_id="3"),
        make_card("Tue, Aug 19", card_id="4"),
    ]
    assert [card.card_id for card in find_target_classes(cards)] == ["2", "4"]
 def test_find_target_classes_ignores_other_times_and_completed_cards() -> None:
    cards = [
        make_card("Thu, Aug 14", time_text="Time: 7:00 AM", card_id="1"),
        make_card("Thu, Aug 14", button_text="Completed", card_id="2"),
        make_card("Tue, Aug 19", time_text="Time: 6:00 PM", card_id="3"),
    ]
    assert [card.card_id for card in find_target_classes(cards)] == ["3"]
 def test_find_target_classes_is_empty_when_none_match() -> None:
    assert find_target_classes([make_card("Wed, Aug 13")]) == []
@@ -0,0 +1,106 @@
 """@file test_verification.py
@brief The comparison of the bot's results with the My Bookings page, and its text.
 """
 from tests.unit.test_booking_entry import make_entry
 from tests.unit.test_models import make_card
 from snack_and_lift.domain.models import ClassResult, Outcome
 from snack_and_lift.domain.verification import build_verification, format_verification
 BOOKED = ClassResult(make_card("Tue, Aug 12"), Outcome.NEW_BOOKING)
 WAITLISTED = ClassResult(make_card("Thu, Aug 14", card_id="2"), Outcome.NEW_WAITLIST)
 def test_everything_found_is_a_success() -> None:
    result = build_verification(
        [BOOKED, WAITLISTED],
        [make_entry("Tue, Aug 12, 6:00 PM"), make_entry("Thu, Aug 14, 6:00 PM", waitlisted=True)],
    )
    assert result.is_success
    assert result.verified == ["Spin Class", "Spin Class (Waitlist)"]
    assert (result.expected, result.found) == (2, 2)
 def test_success_text_is_exact() -> None:
    result = build_verification(
        [BOOKED, WAITLISTED],
        [make_entry("Tue, Aug 12, 6:00 PM"), make_entry("Thu, Aug 14, 6:00 PM", waitlisted=True)],
    )
    assert format_verification(result) == (
        "--- VERIFYING ON MY BOOKINGS PAGE ---\n"
        "  ✓ Verified: Spin Class\n"
        "  ✓ Verified: Spin Class (Waitlist)\n"
        "\n"
        "--- VERIFICATION RESULT ---\n"
        "Expected: 2 bookings\n"
        "Found: 2 bookings\n"
        "✅ SUCCESS: All bookings verified!"
    )
 def test_one_booking_is_singular() -> None:
    text = format_verification(build_verification([BOOKED], [make_entry("Tue, Aug 12, 6:00 PM")]))
    assert "Expected: 1 booking\nFound: 1 booking\n" in text
 def test_missing_entry_is_a_mismatch_with_a_line() -> None:
    result = build_verification([BOOKED, WAITLISTED], [make_entry("Tue, Aug 12, 6:00 PM")])
    text = format_verification(result)
    assert not result.is_success
    assert result.missing == ["Spin Class (Waitlist) on Thu, Aug 14"]
    assert "Expected: 2 bookings\nFound: 1 booking\n❌ MISMATCH: Missing 1 bookings" in text
    assert text.endswith("  ✗ Missing: Spin Class (Waitlist) on Thu, Aug 14")
 def test_unexpected_entry_gives_a_negative_missing_count() -> None:
    result = build_verification(
        [BOOKED], [make_entry("Tue, Aug 12, 6:00 PM"), make_entry("Thu, Aug 14, 6:00 PM")]
    )
    text = format_verification(result)
    assert result.unexpected == ["Spin Class on Thu, Aug 14"]
    assert "❌ MISMATCH: Missing -1 bookings" in text
    assert text.endswith("  ? Unexpected: Spin Class on Thu, Aug 14")
 def test_waitlist_flag_must_match() -> None:
    result = build_verification([BOOKED], [make_entry("Tue, Aug 12, 6:00 PM", waitlisted=True)])
    assert result.missing == ["Spin Class on Tue, Aug 12"]
    assert result.unexpected == ["Spin Class (Waitlist) on Tue, Aug 12"]
    assert "Missing 0 bookings" in format_verification(result)
 def test_date_must_match() -> None:
    result = build_verification([BOOKED], [make_entry("Tue, Aug 19, 6:00 PM")])
    assert not result.is_success
 def test_already_waitlisted_is_expected_as_waitlist() -> None:
    results = [ClassResult(make_card("Thu, Aug 14"), Outcome.ALREADY_WAITLISTED)]
    assert build_verification(
        results, [make_entry("Thu, Aug 14, 6:00 PM", waitlisted=True)]
    ).is_success
 def test_nothing_expected_and_nothing_found_is_a_success() -> None:
    result = build_verification([], [])
    assert result.is_success
    assert "Expected: 0 bookings\nFound: 0 bookings\n✅ SUCCESS" in format_verification(result)
 def test_same_class_twice_is_matched_one_to_one() -> None:
    result = build_verification([BOOKED, BOOKED], [make_entry("Tue, Aug 12, 6:00 PM")])
    assert result.verified == ["Spin Class"]
    assert result.missing == ["Spin Class on Tue, Aug 12"]
Author	SHA1	Message	Date
Tirsvad	944ba204cf	Resolve pending commit links	2026-10-28 18:02:52 +08:00
Tirsvad	f57040e136	Add review record RC-020 for MIL-006	2026-10-28 18:02:50 +08:00
Tirsvad	8c6cc148f5	Add My Bookings verification and date-independent booking (steps 7 and 8) Booking entries parsed from the My Bookings page, comparison of expected and found bookings with the lecture's output, NoBookingsFoundError as the counterpart of NoSuchElementException, exit code 3 on a mismatch, tests for every starting weekday of the 8-day window, container tests against local fixtures. Task: MIL-006#1 Task: MIL-006#2 Task: MIL-006#3 Task: MIL-006#4	2026-10-28 18:02:44 +08:00
Tirsvad	0a665ee9ac	Merge pull request 'MIL-005: counters and every Tuesday and Thursday class' (#44 ) from mil-005-counters-and-both-days into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 6s Details	2026-10-28 10:54:26 +01:00
Tirsvad	1088a88e59	Resolve pending commit links	2026-10-28 17:54:19 +08:00
Tirsvad	45e6fc72df	Add review record RC-019 for MIL-005	2026-10-28 17:54:17 +08:00
Tirsvad	2ce7e3d8dc	Add counters, summary and every Tuesday and Thursday class (steps 5 and 6) Target class lookup for Tuesday and Thursday 6pm, counters, booking summary and detailed class list, --first-tuesday-only for the earlier step, screenshot names for steps 5 and 6, unit and container tests. Task: MIL-005#1 Task: MIL-005#2 Task: MIL-005#3 Task: MIL-005#4	2026-10-28 17:54:11 +08:00
Tirsvad	e0b6abb662	Merge pull request 'MIL-004: book a class and check its state' (#43 ) from mil-004-book-class into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 6s Details	2026-10-28 10:49:17 +01:00
Tirsvad	41b0dace11	Add review record RC-018 and resolve pending commit links for MIL-004	2026-10-28 17:49:10 +08:00
Tirsvad	08ba464ec9	Add class card parsing, booking and state checks (steps 3 and 4) Day label and time parsing, next Tuesday 6pm lookup without list-position tricks, decision on Book Class / Join Waitlist / Booked / Waitlisted, confirmed clicks, console recorder and text screenshots, unit tests and container tests against local fixtures. Task: MIL-004#1 Task: MIL-004#2 Task: MIL-004#3 Task: MIL-004#4	2026-10-28 17:49:06 +08:00
Tirsvad	735cb73cde	Merge pull request 'MIL-003: profile, navigation and automated login' (#42 ) from mil-003-login into main TirSystem/git-workflows: Sync GitHub mirror metadata / sync-metadata (push) Successful in 7s Details	2026-10-28 10:42:08 +01:00