Feature/bcss 21304 selenium0to playwright fobtregressiontests scenario 1 (#126)

<!-- markdownlint-disable-next-line first-line-heading -->
## Description

<!-- Describe your changes in detail. -->
Adding scenario 1 from FOBTRegressionTests.featuire along with any
relevant classes/utils

## Context

<!-- Why is this change required? What problem does it solve? -->
Adding scenario 1 from FOBTRegressionTests.featuire along with any
relevant classes/utils

## Type of changes

<!-- What types of changes does your code introduce? Put an `x` in all
the boxes that apply. -->

- [x] Refactoring (non-breaking change)
- [x] New feature (non-breaking change which adds functionality)
- [ ] Breaking change (fix or feature that would change existing
functionality)
- [ ] Bug fix (non-breaking change which fixes an issue)

## Checklist

<!-- Go over all the following points, and put an `x` in all the boxes
that apply. -->

- [x] I am familiar with the [contributing
guidelines](https://github.com/nhs-england-tools/playwright-python-blueprint/blob/main/CONTRIBUTING.md)
- [x] I have followed the code style of the project
- [x] I have added tests to cover my changes (where appropriate)
- [x] I have updated the documentation accordingly
- [x] This PR is a result of pair or mob programming

---

## Sensitive Information Declaration

To ensure the utmost confidentiality and protect your and others
privacy, we kindly ask you to NOT including [PII (Personal Identifiable
Information) / PID (Personal Identifiable
Data)](https://digital.nhs.uk/data-and-information/keeping-data-safe-and-benefitting-the-public)
or any other sensitive data in this PR (Pull Request) and the codebase
changes. We will remove any PR that do contain any sensitive
information. We really appreciate your cooperation in this matter.

- [x] I confirm that neither PII/PID nor sensitive data are included in
this PR and the codebase changes.

---------

Co-authored-by: AndyG <[email protected]>

Author: adrianoaru-nhs

classes/address.py

@@ -26,7 +26,7 @@ def set_address_line(self, line_number: int, address_line: str) -> None:
         Raises:
             ValueError: If line_number is not between 1 and 5.
         """
-        logging.info(
+        logging.debug(
             f"start: set_address_line(line_number={line_number}, address_line={address_line})"
         )
         if line_number == 1:
@@ -43,7 +43,7 @@ def set_address_line(self, line_number: int, address_line: str) -> None:
             raise ValueError(
                 f"Invalid line number {line_number}, must be between 1 and 5"
             )
-        logging.info(
+        logging.debug(
             f"end: set_address_line(line_number={line_number}, address_line={address_line})"
         )
 

classes/analyser.py

@@ -0,0 +1,61 @@
+from dataclasses import dataclass
+from typing import Optional
+import pandas as pd
+
+
+@dataclass
+class Analyser:
+    """
+    This data class is used to store information about a specific analyser device.
+    The attributes correspond to the columns in the analyser query results.
+    Attributes:
+        analyser_id (Optional[int]): The ID of the analyser.
+        analyser_code (Optional[str]): The code of the analyser.
+        hub_id (Optional[int]): The ID of the hub the analyser is connected to.
+        analyser_type_id (Optional[int]): The type ID of the analyser.
+        spoil_result_code (Optional[int]): The result code for spoilage.
+        tech_fail_result_code (Optional[int]): The result code for technical failure.
+        below_range_result_code (Optional[int]): The result code for below range.
+        above_range_result_code (Optional[int]): The result code for above range.
+    """
+
+    analyser_id: Optional[int] = None
+    analyser_code: Optional[str] = None
+    hub_id: Optional[int] = None
+    analyser_type_id: Optional[int] = None
+    spoil_result_code: Optional[int] = None
+    tech_fail_result_code: Optional[int] = None
+    below_range_result_code: Optional[int] = None
+    above_range_result_code: Optional[int] = None
+
+    def __str__(self) -> str:
+        return (
+            f"Analyser [analyser_id={self.analyser_id}, analyser_code={self.analyser_code}, "
+            f"hub_id={self.hub_id}, spoil_result_code={self.spoil_result_code}, "
+            f"tech_fail_result_code={self.tech_fail_result_code}, "
+            f"below_range_result_code={self.below_range_result_code}, "
+            f"above_range_result_code={self.above_range_result_code}]"
+        )
+
+    @staticmethod
+    def from_dataframe_row(row: pd.Series) -> "Analyser":
+        """
+        Creates an Analyser object from a pandas DataFrame row containing analyser query results.
+
+        Args:
+            row (pd.Series): A row from a pandas DataFrame with columns:
+                - tk_analyser_id
+                - analyser_code
+                - hub_id
+                - tk_analyser_type_id
+            The other columns are obtained from the SQL query as so are not present in this method.
+
+        Returns:
+            Analyser: The constructed Analyser object.
+        """
+        return Analyser(
+            analyser_id=row.get("tk_analyser_id"),
+            analyser_code=row.get("analyser_code"),
+            hub_id=row.get("hub_id"),
+            analyser_type_id=row.get("tk_analyser_type_id"),
+        )

classes/analyser_result_code_type.py

@@ -0,0 +1,66 @@
+from enum import Enum
+from typing import Optional
+
+
+class AnalyserResultCodeType(Enum):
+    """
+    Enum for analyser result code types, mapped to valid value IDs and descriptions.
+    """
+
+    ABOVE_DILUTION_RANGE = (309030, "Above dilution range")
+    BELOW_MEASURING_RANGE = (309028, "Below measuring range")
+    SPOILT = (309026, "Spoilt")
+    TECHNICAL_FAIL = (309027, "Technical Fail")
+
+    def __init__(self, valid_value_id: int, description: str) -> None:
+        self._valid_value_id = valid_value_id
+        self._description = description
+
+    @property
+    def valid_value_id(self) -> int:
+        """
+        Returns the valid value ID for the analyser result code type.
+        """
+        return self._valid_value_id
+
+    @property
+    def description(self) -> str:
+        """
+        Returns the description for the analyser result code type.
+        """
+        return self._description
+
+    @classmethod
+    def by_description(cls, description: str) -> Optional["AnalyserResultCodeType"]:
+        """
+        Returns the enum member matching the given description (case-sensitive).
+        """
+        for member in cls:
+            if member.description == description:
+                return member
+        return None
+
+    @classmethod
+    def by_description_case_insensitive(
+        cls, description: str
+    ) -> Optional["AnalyserResultCodeType"]:
+        """
+        Returns the enum member matching the given description (case-insensitive).
+        """
+        desc_lower = description.lower()
+        for member in cls:
+            if member.description.lower() == desc_lower:
+                return member
+        return None
+
+    @classmethod
+    def by_valid_value_id(
+        cls, valid_value_id: int
+    ) -> Optional["AnalyserResultCodeType"]:
+        """
+        Returns the enum member matching the given valid value ID.
+        """
+        for member in cls:
+            if member.valid_value_id == valid_value_id:
+                return member
+        return None

classes/data/data_creation.py

@@ -107,7 +107,7 @@ def generate_random_subject(
         Returns:
             PISubject: A randomly generated PI Subject.
         """
-        logging.info(
+        logging.debug(
             f"generateRandomSubject: {random_words_list}, {pi_reference}, {region}"
         )
         pi_subject = PISubject()
@@ -138,15 +138,15 @@ def generate_random_subject(
         pi_subject.gnc_code = self.generate_random_registration_code()
         gp_surgery = self.generate_random_gp_surgery(region)
         if gp_surgery is not None:
-            pi_subject.gp_practice_code = gp_surgery.get_code()
+            pi_subject.gp_practice_code = gp_surgery.code
         pi_subject.nhais_deduction_reason = None
         pi_subject.nhais_deduction_date = None
         pi_subject.exeter_system = "ATO"
         pi_subject.removed_to = None
         pi_subject.pi_reference = pi_reference
         pi_subject.superseded_by_nhs_number = None
         pi_subject.replaced_nhs_number = None
-        logging.info("generateRandomSubject: end")
+        logging.debug("generateRandomSubject: end")
         return pi_subject
 
     def generate_random_registration_code(self) -> str:
@@ -155,9 +155,9 @@ def generate_random_registration_code(self) -> str:
         Returns:
             str: The generated registration code
         """
-        logging.info("generateRandomRegistrationCode: start")
+        logging.debug("generateRandomRegistrationCode: start")
         code = random.choice(self.registration_code_list)
-        logging.info("generateRandomRegistrationCode: end")
+        logging.debug("generateRandomRegistrationCode: end")
         return code
 
     def generate_random_gp_surgery(self, region: RegionType) -> Organisation | None:
@@ -168,7 +168,7 @@ def generate_random_gp_surgery(self, region: RegionType) -> Organisation | None:
         Returns:
             Organisation: The generated gp surgery or None if the region type cannot be found
         """
-        logging.info(f"generateRandomGPSurgery: {region}")
+        logging.debug(f"generateRandomGPSurgery: {region}")
         if region == RegionType.ENGLAND:
             return random.choice(self.org_list_england)
         elif region == RegionType.ISLE_OF_MAN:
@@ -184,7 +184,7 @@ def generate_random_address(self, random_words_list: Dict[str, str]) -> Address:
         Returns:
             Address: The generated address
         """
-        logging.info(f"generateRandomAddress: {random_words_list}")
+        logging.debug(f"generateRandomAddress: {random_words_list}")
         address = Address()
         house_number = self.rand.randint(0, 100)
         road_prefix = random_words_list.get("roadPrefix", "")
@@ -204,7 +204,7 @@ def generate_random_address(self, random_words_list: Dict[str, str]) -> Address:
             address.set_address_line(line_number, random_words_list.get("county", ""))
 
         address.set_post_code(self.generate_random_postcode())
-        logging.info("generateRandomAddress: end")
+        logging.debug("generateRandomAddress: end")
         return address
 
     def generate_random_person(
@@ -218,7 +218,7 @@ def generate_random_person(
         Returns:
             Person: The generated person
         """
-        logging.info("generateRandomPerson: start")
+        logging.debug("generateRandomPerson: start")
         if gender not in [GenderType.MALE, GenderType.FEMALE]:
             gender = (
                 GenderType.MALE if self.rand.randint(0, 100) < 50 else GenderType.FEMALE
@@ -235,7 +235,7 @@ def generate_random_person(
         if self.rand.randint(0, 100) < 5:
             person.set_previous_surname(random_words_list.get("surname2", ""))
 
-        logging.info("generateRandomPerson: end")
+        logging.debug("generateRandomPerson: end")
         return person
 
     def generate_random_postcode(self) -> str:
@@ -244,7 +244,7 @@ def generate_random_postcode(self) -> str:
         Returns:
             str: The generated postcode
         """
-        logging.info("generateRandomPostcode: start")
+        logging.debug("generateRandomPostcode: start")
         unused_first_characters = ["V", "Q", "X"]
         inward_letters = [
             "A",
@@ -276,7 +276,7 @@ def generate_random_postcode(self) -> str:
         random_inward_letter1 = random.choice(inward_letters)
         random_inward_letter2 = random.choice(inward_letters)
         postcode = f"{random_outward_letters}{random_outward_digits} {random_inward_digit}{random_inward_letter1}{random_inward_letter2}"
-        logging.info("generateRandomPostcode: end")
+        logging.debug("generateRandomPostcode: end")
         return postcode
 
     def generate_random_title(self, gender: GenderType) -> str:
@@ -287,7 +287,7 @@ def generate_random_title(self, gender: GenderType) -> str:
         Returns:
             str: The generated title
         """
-        logging.info("generateRandomTitle: start")
+        logging.debug("generateRandomTitle: start")
         weighting = self.rand.randint(0, 9)
         if gender == GenderType.FEMALE:
             if weighting > 7:

classes/entities/kit_service_management_entity.py

@@ -0,0 +1,83 @@
+from dataclasses import dataclass
+from typing import Optional
+from decimal import Decimal
+from datetime import datetime
+from classes.kit_service_management_record import KitServiceManagementRecord
+
+
+@dataclass
+class KitServiceManagementEntity:
+    """
+    Data class representing a kit service management entity (KIT_QUEUE table).
+    """
+
+    device_id: Optional[str] = None
+    test_kit_type: Optional[str] = None
+    test_kit_name: Optional[str] = None
+    test_kit_status: Optional[str] = None
+    logged_by_hub: Optional[str] = None
+    date_time_logged: Optional[datetime] = None
+    test_result: Optional[Decimal] = None
+    calculated_result: Optional[str] = None
+    error_code: Optional[int] = None
+    analyser_code: Optional[str] = None
+    date_time_authorised: Optional[datetime] = None
+    authoriser_user_code: Optional[str] = None
+    datestamp: Optional[datetime] = None
+    bcss_error_id: Optional[int] = None
+    post_response: Optional[int] = None
+    post_attempts: Optional[int] = None
+    put_response: Optional[int] = None
+    put_attempts: Optional[int] = None
+    date_time_error_archived: Optional[datetime] = None
+    error_archived_user_code: Optional[str] = None
+    issue_date: Optional[datetime] = None
+    issued_by_hub: Optional[str] = None
+    nhs_number: Optional[str] = None
+    analyser_error_description: Optional[str] = None
+    error_type: Optional[str] = None
+    screening_test_result: Optional[str] = None
+
+    @staticmethod
+    def from_record(
+        record: "KitServiceManagementRecord",
+    ) -> "KitServiceManagementEntity":
+        """
+        Converts a KitServiceManagementRecord object into a KitServiceManagementEntity object.
+
+        Args:
+            record (KitServiceManagementRecord): The record to convert.
+
+        Returns:
+            KitServiceManagementEntity: The converted entity.
+        """
+        return KitServiceManagementEntity(
+            device_id=record.device_id,
+            test_kit_type=(
+                str(record.test_kit_type) if record.test_kit_type is not None else None
+            ),  # test_kit_type is converted to a string as this is what is required in the database
+            test_kit_name=record.test_kit_name,
+            test_kit_status=record.test_kit_status,
+            logged_by_hub=record.logged_by_hub,
+            date_time_logged=record.date_time_logged,
+            test_result=record.test_result,
+            calculated_result=record.calculated_result,
+            error_code=record.error_code,
+            analyser_code=record.analyser_code,
+            date_time_authorised=record.date_time_authorised,
+            authoriser_user_code=record.authoriser_user_code,
+            datestamp=record.datestamp,
+            bcss_error_id=record.bcss_error_id,
+            post_response=record.post_response,
+            post_attempts=record.post_attempts,
+            put_response=record.put_response,
+            put_attempts=record.put_attempts,
+            date_time_error_archived=record.date_time_error_archived,
+            error_archived_user_code=record.error_archived_user_code,
+            issue_date=record.date_time_issued,
+            issued_by_hub=record.issued_by_hub,
+            nhs_number=record.nhs_number,
+            analyser_error_description=record.analyser_error_description,
+            error_type=record.error_type,
+            screening_test_result=record.screening_test_result,
+        )