Initial commit - scaffolding done

Author: Andyg79

tests/bcss_tests.properties

@@ -27,3 +27,9 @@ episode_closed_date=22/09/2020
 # ----------------------------------
 daily_invitation_rate=6
 weekly_invitation_rate=130
+
+# ----------------------------------
+# CREATE SUBJECT REGRESSION TEST DATA
+# ----------------------------------
+hub_code=23159
+region=England

tests/regression/subjects/test_create_subjects.py

@@ -0,0 +1,104 @@
+import pytest
+from pages.base_page import BasePage
+from utils.user_tools import UserTools
+from datetime import timedelta
+from pages.call_and_recall.call_and_recall_page import CallAndRecallPage
+from pages.call_and_recall.create_a_plan_page import CreateAPlanPage
+from pages.call_and_recall.invitations_monitoring_page import InvitationsMonitoringPage
+from pages.call_and_recall.invitations_plans_page import InvitationsPlansPage
+from utils.subject_utils import (
+    get_active_invitation_plan,
+    calculate_subject_shortfall,
+    create_subject,
+)
+from utils.date_time_utils import DateTimeUtils
+from utils.subject_utils import get_active_invitation_plan
+
+random_offset = DateTimeUtils.random_offset
+from playwright.sync_api import Page
+
+@pytest.fixture
+def db_connection():
+    """
+    Temporary stub for the database connection fixture.
+    Replace with actual database session or connection as needed.
+    """
+    return None  # Or a mock object if needed
+
+
+@pytest.fixture(scope="function", autouse=True)
+def before_each(page: Page):
+    """
+    Before every test is executed, this fixture logs in to BCSS as a test user and navigates to the call and recall page
+    """
+    # Log in to BCSS
+    UserTools.user_login(page, "Hub Manager State Registered at BCS01")
+
+    # Go to call and recall page
+    BasePage(page).go_to_call_and_recall_page()
+
+
+@pytest.mark.wip
+@pytest.mark.regression
+@pytest.mark.call_and_recall
+def test_add_subjects_and_create_invitation_plan(
+    page: Page, db_connection, general_properties: dict
+) -> None:
+    """
+    # Feature: Create Subjects
+
+    # Narrative Description:
+    # As a system administrator,
+    # I want add new subjects into the system,
+    # so that I have enough subjects to process during the smoke screen tests
+
+    # Scenario: Add new people into the invitation plan, people who will turn 60 in the next 20 months in England
+    # screening center "Wolverhampton SC" in hub "Midlands and NW Hub" (England)
+    """
+
+    # Given there were less than "28" subjects to invite per day in the active invitation plan for screening center "23162" hub "23159" in region "England"
+    sc_code = general_properties["screening_centre_code"]
+    hub_code = general_properties["hub_code"]
+    region = general_properties["region"]
+    daily_target = int(general_properties["daily_invitation_rate"])
+
+    active_plan = get_active_invitation_plan(hub_code, sc_code, db_connection)
+    assert active_plan, "No active invitation plan found"
+    print(
+        f"Active Plan → start: {active_plan.start_date}, end: {active_plan.end_date}, "
+        f"per day: {active_plan.invitations_per_day}, due: {active_plan.invitations_due}"
+    )
+
+    # When sufficient additional subjects are created so that there are at least "28" subjects to invite per day in the active invitation plan for screening center "23162" hub "23159" in region "England"
+    if active_plan.invitations_per_day < daily_target:
+        subjects_needed = calculate_subject_shortfall(active_plan, daily_target)
+        for _ in range(subjects_needed):
+            birth_date = (
+                active_plan.start_date
+                + timedelta(
+                    DateTimeUtils.random_offset(
+                        active_plan.start_date, active_plan.end_date
+                    )
+                )
+                - timedelta(days=365 * 60)
+            )
+            create_subject(
+                birth_date=birth_date,
+                screening_centre=sc_code,
+                hub=hub_code,
+                region=region,
+            )
+
+    # And a new invitation plan is created if there are less than "28" subjects to invite per day in the active invitation plan for screening centre "23162" "BCS001" hub "23159" in region "England"
+    CallAndRecallPage(page).go_to_planning_and_monitoring_page()
+    InvitationsMonitoringPage(page).go_to_invitation_plan_page(sc_code)
+    InvitationsPlansPage(page).go_to_create_a_plan_page()
+    CreateAPlanPage(page).click_set_all_button()
+    CreateAPlanPage(page).fill_daily_invitation_rate_field(str(daily_target))
+    CreateAPlanPage(page).click_update_button()
+
+    # Then there are at least "28" subjects to invite per day in the active invitation plan for screening center "23162" hub "23159" in region "England"
+    expected_weekly_rate = str(daily_target * 5)  # Assuming 5-day weeks
+    CreateAPlanPage(page).verify_weekly_invitation_rate_for_weeks(
+        1, 50, expected_weekly_rate
+    )

utils/date_time_utils.py

@@ -152,3 +152,21 @@ def generate_unique_weekday_date(start_year: int = 2025) -> str:
             base_date += timedelta(days=1)
 
         return base_date.strftime("%d/%m/%Y")
+
+    @staticmethod
+    def random_offset(start_date: datetime, end_date: datetime) -> int:
+        """
+        Returns a random integer offset (in days) between the given start and end dates.
+
+        This can be used to shift a date within a range, e.g., when generating birthdates
+        to ensure subject age aligns with eligibility criteria.
+
+        Args:
+            start_date (datetime): The beginning of the valid date range.
+            end_date (datetime): The end of the valid date range.
+
+        Returns:
+            int: A random offset in days between start_date and end_date.
+        """
+        delta_days = (end_date - start_date).days
+        return random.randint(0, max(delta_days, 0))

utils/subject_utils.py

@@ -0,0 +1,69 @@
+from datetime import datetime, timedelta
+from dataclasses import dataclass
+from datetime import datetime
+
+
+@dataclass
+class InvitationPlan:
+    """
+    Represents a structured view of an active invitation plan returned by
+    `get_active_invitation_plan()` in the subject_utils module.
+
+    This dataclass is used primarily in the `test_add_subjects_and_create_invitation_plan`
+    test case to verify, augment, and operate on the subject pool for a
+    given screening centre and hub. It provides strongly-typed access to
+    core scheduling parameters required for dynamic test setup.
+
+    Attributes:
+        start_date (datetime): The start date of the invitation plan.
+        end_date (datetime): The end date of the invitation plan.
+        invitations_per_day (int): How many subjects are currently scheduled per day.
+        invitations_due (int): The total number of subjects planned across the duration.
+    """
+
+    start_date: datetime
+    end_date: datetime
+    invitations_per_day: int
+    invitations_due: int
+
+
+def get_active_invitation_plan(hub_code, sc_code, db_connection) -> InvitationPlan:
+    """
+    Retrieves the currently active invitation plan for a given hub and screening centre.
+    Replace with real DB logic using your ORM or SQL execution layer.
+
+    Returns:
+        InvitationPlan: Structured representation of the current active plan.
+    """
+    return InvitationPlan(
+        start_date=datetime.now(),
+        end_date=datetime.now() + timedelta(days=300),
+        invitations_per_day=20,
+        invitations_due=4000,
+    )
+
+
+def calculate_subject_shortfall(active_plan: InvitationPlan, daily_target: int) -> int:
+    """
+    Based on the active plan and the desired daily rate,
+    calculate how many new subjects should be added.
+    """
+    invitations_per_day = active_plan.invitations_per_day
+    invitations_due = active_plan.invitations_due
+    plan_duration_days = (active_plan.end_date - active_plan.start_date).days
+
+    estimated_total = int(
+        (daily_target / invitations_per_day) * invitations_due * 1.01 - invitations_due
+    )
+    return max(0, estimated_total)
+
+
+def create_subject(birth_date, screening_centre, hub, region):
+    """
+    Creates a new subject in the database.
+    You’ll likely want to use your existing data generation utilities or raw SQL here.
+    """
+    # TODO: Implement subject creation logic
+    print(
+        f"[create_subject] Created subject born {birth_date} for {screening_centre} in {region}"
+    )