Feature/bcss 20062 compartment 3 (#12)

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

<!-- Describe your changes in detail. -->

## Context
Adding compartment 3 and any relevant utils (fit_kit_logged.py and
oracle_specific_function.py)
Altered bcss_smokescreen_tests.properties to ass values for compartment
3
Altered existing tests to fix issues with broken imports. Some import
statements did not contain the folder of the POMs.
E.g. in test_fit_test_kits_page.py `from
pages.fit_test_kits.log_devices_page import LogDevices` was originally
set to from `pages.log_devices_page import LogDevices`

<!-- Why is this change required? What problem does it solve? -->

## Type of changes
Adding a new compartment for the smokescreen tests and fixing import
statements in existing tests.

<!-- 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
- [ ] 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.

---------

Signed-off-by: adrianoaru-nhs <[email protected]>
Co-authored-by: Dave Harding <[email protected]>

Author: 2 people

tests/smokescreen/bcss_smokescreen_tests.properties

@@ -14,9 +14,9 @@
 # ----------------------------------
 #   compartment 3
 # ----------------------------------
-#    c3_fit_kit_results_test_org_id=23159
-#    c3_fit_kit_normal_result=75
-#    c3_fit_kit_abnormal_result=150
+    c3_fit_kit_results_test_org_id=23159
+    c3_fit_kit_normal_result=75
+    c3_fit_kit_abnormal_result=150
 #    c3_fit_kit_authorised_user=AUTO1
 #    c3_fit_kit_analyser_code=HMJackalt1
 
@@ -66,8 +66,8 @@
 #    c3_eng_number_of_abnormal_gfobt_kits_to_log=0
 #    c3_eng_number_of_normal_gfobt_kits_to_log=0
 #    c3_eng_number_of_weak_positive_gfobt_kits_to_log=0
-#    c3_eng_number_of_abnormal_fit_kits=7
-#    c3_eng_number_of_normal_fit_kits=1
+    c3_eng_number_of_abnormal_fit_kits=9
+    c3_eng_number_of_normal_fit_kits=1
 
 # ----------------------------------
 #   compartment 4

tests/smokescreen/test_compartment_3.py

@@ -0,0 +1,114 @@
+import logging
+import pytest
+from playwright.sync_api import Page
+from pages.logout.log_out_page import Logout
+from utils.batch_processing import batch_processing
+from utils.fit_kit_logged import process_kit_data
+from utils.screening_subject_page_searcher import verify_subject_event_status_by_nhs_no
+from utils.oracle.oracle_specific_functions import (
+    update_kit_service_management_entity,
+    execute_fit_kit_stored_procedures,
+)
+from utils.user_tools import UserTools
+from jproperties import Properties
+from sys import platform
+
+
+@pytest.fixture
+def smokescreen_properties() -> dict:
+    """
+    Reads the 'bcss_smokescreen_tests.properties' file and populates a 'Properties' object.
+    Returns a dictionary of properties for use in tests.
+
+    Returns:
+        dict: A dictionary containing the values loaded from the 'bcss_smokescreen_tests.properties' file.
+    """
+    configs = Properties()
+    if platform == "win32":  # File path from content root is required on Windows OS
+        with open(
+            "tests/smokescreen/bcss_smokescreen_tests.properties", "rb"
+        ) as read_prop:
+            configs.load(read_prop)
+    elif platform == "darwin":  # Only the filename is required on macOS
+        with open("bcss_smokescreen_tests.properties", "rb") as read_prop:
+            configs.load(read_prop)
+    return configs.properties
+
+
+@pytest.mark.smokescreen
+@pytest.mark.compartment3
+def test_compartment_3(page: Page, smokescreen_properties: dict) -> None:
+    """
+    This is the main compartment 3 method
+    First it finds any relevant test data from the DB and stores it in a pandas dataframe
+    Then it separates it out into normal and abnormal results
+    Once that is done it updates a table on the DB and runs two stored procedures so that these subjects will not have normal/abnormal results on BCSS
+    It then checks that the status of the subject is as expected using the subject screening summary page
+    Then it process two batches performing checks on the subjects to ensure they always have the correct event status
+    """
+    UserTools.user_login(page, "Hub Manager State Registered")
+
+    # Find data , separate it into normal and abnormal, Add results to the test records in the KIT_QUEUE table (i.e. mimic receiving results from the middleware)
+    # and get device IDs and their flags
+    device_ids = process_kit_data(smokescreen_properties)
+    # Retrieve NHS numbers for each device_id and determine normal/abnormal status
+    nhs_numbers = []
+    normal_flags = []
+
+    for device_id, is_normal in device_ids:
+        nhs_number = update_kit_service_management_entity(
+            device_id, is_normal, smokescreen_properties
+        )
+        nhs_numbers.append(nhs_number)
+        normal_flags.append(
+            is_normal
+        )  # Store the flag (True for normal, False for abnormal)
+
+    # Run two stored procedures to process any kit queue records at status BCSS_READY
+    try:
+        execute_fit_kit_stored_procedures()
+        logging.info("Stored procedures executed successfully.")
+    except Exception as e:
+        logging.error(f"Error executing stored procedures: {str(e)}")
+        raise
+
+    # Check the results of the processed FIT kits have correctly updated the status of the associated subjects
+    # Verify subject event status based on normal or abnormal classification
+    for nhs_number, is_normal in zip(nhs_numbers, normal_flags):
+        expected_status = (
+            "S2 - Normal" if is_normal else "A8 - Abnormal"
+        )  # S2 for normal, A8 for abnormal
+        logging.info(
+            f"Verifying NHS number: {nhs_number} with expected status: {expected_status}"
+        )
+
+        try:
+            verify_subject_event_status_by_nhs_no(page, nhs_number, expected_status)
+            logging.info(
+                f"Successfully verified NHS number {nhs_number} with status {expected_status}"
+            )
+        except Exception as e:
+            logging.error(
+                f"Verification failed for NHS number {nhs_number} with status {expected_status}: {str(e)}"
+            )
+            raise
+
+    # Process S2 batch
+    batch_processing(
+        page,
+        "S2",
+        "Subject Result (Normal)",
+        "S158 - Subject Discharge Sent (Normal)",
+        True,
+    )
+
+    # Process S158 batch
+    batch_processing(
+        page,
+        "S158",
+        "GP Result (Normal)",
+        "S159 - GP Discharge Sent (Normal)",
+    )
+
+    # Log out
+    Logout(page).log_out()

tests/test_fit_test_kits_page.py

@@ -3,17 +3,17 @@
 from pages.base_page import BasePage
 from pages.fit_test_kits.fit_test_kits_page import FITTestKits
 from pages.fit_test_kits.fit_rollout_summary_page import FITRolloutSummary
-from pages.log_devices_page import LogDevices
+from pages.fit_test_kits.log_devices_page import LogDevices
 from pages.fit_test_kits.view_fit_kit_result_page import ViewFITKitResult
 from pages.fit_test_kits.kit_service_management_page import KitServiceManagement
 from pages.fit_test_kits.kit_result_audit_page import KitResultAudit
-from pages.view_algorithms_page import ViewAlgorithms
-from pages.view_screening_centre_fit_configuration_page import (
+from pages.fit_test_kits.view_algorithms_page import ViewAlgorithms
+from pages.fit_test_kits.view_screening_centre_fit_configuration_page import (
     ViewScreeningCentreFITConfiguration,
 )
-from pages.screening_incidents_list_page import ScreeningIncidentsList
-from pages.manage_qc_products_page import ManageQCProducts
-from pages.maintain_analysers_page import MaintainAnalysers
+from pages.fit_test_kits.screening_incidents_list_page import ScreeningIncidentsList
+from pages.fit_test_kits.manage_qc_products_page import ManageQCProducts
+from pages.fit_test_kits.maintain_analysers_page import MaintainAnalysers
 from utils.user_tools import UserTools
 
 

utils/fit_kit_logged.py

@@ -0,0 +1,65 @@
+from oracle.oracle import OracleDB
+from oracle.oracle_specific_functions import get_kit_id_logged_from_db
+import pandas as pd
+import logging
+import pytest
+
+
+def process_kit_data(smokescreen_properties: dict) -> list:
+    """
+    This method retrieved the test data needed for compartment 3 and then splits it into two data frames:
+    - 1 normal
+    - 1 abnormal
+    Once the dataframe is split in two it then creates two lists, one for normal and one for abnormal
+    Each list will either have true or false appended depending on if it is normal or abnormal
+    """
+    # Get test data for compartment 3
+    kit_id_df = get_kit_id_logged_from_db(smokescreen_properties)
+
+    # Split dataframe into two different dataframes, normal and abnormal
+    normal_fit_kit_df, abnormal_fit_kit_df = split_fit_kits(
+        kit_id_df, smokescreen_properties
+    )
+
+    # Prepare a list to store device IDs and their respective flags
+    device_ids = []
+
+    # Process normal kits (only 1)
+    if not normal_fit_kit_df.empty:
+        device_id = normal_fit_kit_df["device_id"].iloc[0]
+        logging.info(
+            f"Processing normal kit with Device ID: {device_id}"
+        )  # Logging normal device_id
+        device_ids.append((device_id, True))  # Add to the list with normal flag
+    else:
+        pytest.fail("No normal kits found for processing.")
+
+        # Process abnormal kits (multiple, loop through)
+    if not abnormal_fit_kit_df.empty:
+        for index, row in abnormal_fit_kit_df.iterrows():
+            device_id = row["device_id"]
+            logging.info(
+                f"Processing abnormal kit with Device ID: {device_id}"
+            )  # Logging abnormal device_id
+            device_ids.append((device_id, False))  # Add to the list with abnormal flag
+    else:
+        pytest.fail("No abnormal kits found for processing.")
+
+    return device_ids
+
+
+def split_fit_kits(kit_id_df: pd.DataFrame, smokescreen_properties: dict) -> pd.DataFrame:
+    """
+    This method splits the dataframe into two, 1 normal and 1 abnormal
+    """
+    number_of_normal = int(smokescreen_properties["c3_eng_number_of_normal_fit_kits"])
+    number_of_abnormal = int(
+        smokescreen_properties["c3_eng_number_of_abnormal_fit_kits"]
+    )
+
+    # Split dataframe into two dataframes
+    normal_fit_kit_df = kit_id_df.iloc[:number_of_normal]
+    abnormal_fit_kit_df = kit_id_df.iloc[
+        number_of_normal : number_of_normal + number_of_abnormal
+    ]
+    return normal_fit_kit_df, abnormal_fit_kit_df

utils/oracle/oracle.py

@@ -126,7 +126,7 @@ def delete_all_users_from_approved_users_table(
                 self.disconnect_from_db(conn)
 
     def execute_query(
-        self, query: str
+        self, query: str, parameters: list | None = None
     ) -> pd.DataFrame:  # To use when "select xxxx" (stored procedures)
         """
         This is used to execute any sql queries.
@@ -135,9 +135,7 @@ def execute_query(
         conn = self.connect_to_db()
         engine = create_engine("oracle+oracledb://", creator=lambda: conn)
         try:
-            logging.info("Attempting to execute query")
-            df = pd.read_sql(query, engine)
-            logging.info("Query execution successful!")
+            df = pd.read_sql(query, engine) if parameters == None else pd.read_sql(query, engine, params = parameters)
         except Exception as executionError:
             logging.error(
                 f"Failed to execute query with execution error {executionError}"