Merge branch 'feature/PI-582-modify_readdevice_endpoint_for_mhs' into release/2024-11-27

Author: jaklinger

src/api/createDeviceMessageHandlingSystem/tests/test_index.py

@@ -81,7 +81,7 @@ def mock_epr_product_with_message_set_drd() -> (
         )
         product_repo.write(entity=product)
 
-        # set up questionnaire response
+        # set up questionnaire responses
         mhs_message_set_questionnaire = QuestionnaireRepository().read(
             QuestionnaireInstance.SPINE_MHS_MESSAGE_SETS
         )
@@ -92,7 +92,6 @@ def mock_epr_product_with_message_set_drd() -> (
                 "MHS IN": "baz",
             }
         )
-
         questionnaire_response_2 = mhs_message_set_questionnaire.validate(
             data={
                 "Interaction ID": "urn:foo2",
@@ -375,4 +374,42 @@ def test_no_existing_message_set_drd():
         assert expected_message_code in response["body"]
 
 
-# add test for already existing mhs device?
+def test_mhs_already_exists() -> None:
+    with mock_epr_product_with_message_set_drd() as (index, product):
+        # Execute the lambda
+        response = index.handler(
+            event={
+                "headers": {"version": VERSION},
+                "body": json.dumps(
+                    {"questionnaire_responses": {"spine_mhs": [QUESTIONNAIRE_DATA]}}
+                ),
+                "pathParameters": {
+                    "product_team_id": str(product.product_team_id),
+                    "product_id": str(product.id),
+                },
+            }
+        )
+
+        assert response["statusCode"] == 201
+
+        # Execute the lambda again
+        response = index.handler(
+            event={
+                "headers": {"version": VERSION},
+                "body": json.dumps(
+                    {"questionnaire_responses": {"spine_mhs": [QUESTIONNAIRE_DATA]}}
+                ),
+                "pathParameters": {
+                    "product_team_id": str(product.product_team_id),
+                    "product_id": str(product.id),
+                },
+            }
+        )
+
+        assert response["statusCode"] == 400
+        expected_error_code = "VALIDATION_ERROR"
+        expected_message_code = (
+            "There is already an existing MHS Device for this Product"
+        )
+        assert expected_error_code in response["body"]
+        assert expected_message_code in response["body"]

src/api/readDevice/src/v1/steps.py

@@ -3,8 +3,12 @@
 from aws_lambda_powertools.utilities.data_classes import APIGatewayProxyEvent
 from domain.core.cpm_product import CpmProduct
 from domain.core.device import Device
+from domain.core.device_reference_data import DeviceReferenceData
 from domain.core.product_team import ProductTeam
 from domain.repository.cpm_product_repository import CpmProductRepository
+from domain.repository.device_reference_data_repository import (
+    DeviceReferenceDataRepository,
+)
 from domain.repository.device_repository import DeviceRepository
 from domain.repository.product_team_repository import ProductTeamRepository
 from domain.request_models import DevicePathParams
@@ -54,6 +58,39 @@ def read_device(data, cache) -> Device:
     )
 
 
+def read_device_reference_data(data, cache) -> list[DeviceReferenceData]:
+    product_team: ProductTeam = data[read_product_team]
+    product: CpmProduct = data[read_product]
+    device: Device = data[read_device]
+
+    device_reference_datas = []
+    device_reference_data_repo = DeviceReferenceDataRepository(
+        table_name=cache["DYNAMODB_TABLE"], dynamodb_client=cache["DYNAMODB_CLIENT"]
+    )
+    for id in device.device_reference_data:
+        drd = device_reference_data_repo.read(
+            product_team_id=product_team.id,
+            product_id=product.id,
+            id=id,
+        )
+        device_reference_datas.append(drd)
+
+    return device_reference_datas
+
+
+def update_device_with_device_reference_data(data, cache) -> Device:
+    device: Device = data[read_device]
+    device_reference_datas = data[read_device_reference_data]
+
+    [
+        device.questionnaire_responses.setdefault(key, []).extend(responses)
+        for drd in device_reference_datas
+        for key, responses in drd.questionnaire_responses.items()
+    ]
+
+    return device
+
+
 def device_to_dict(data, cache) -> tuple[str, dict]:
     device: Device = data[read_device]
     return HTTPStatus.OK, device.state()
@@ -64,5 +101,7 @@ def device_to_dict(data, cache) -> tuple[str, dict]:
     read_product_team,
     read_product,
     read_device,
+    read_device_reference_data,
+    update_device_with_device_reference_data,
     device_to_dict,
 ]

src/api/readDevice/tests/test_index.py

@@ -3,10 +3,20 @@
 from unittest import mock
 
 import pytest
+from domain.core.device import Device
+from domain.core.enum import Status
+from domain.core.product_key import ProductKeyType
 from domain.core.root import Root
 from domain.repository.cpm_product_repository import CpmProductRepository
+from domain.repository.device_reference_data_repository import (
+    DeviceReferenceDataRepository,
+)
 from domain.repository.device_repository import DeviceRepository
 from domain.repository.product_team_repository import ProductTeamRepository
+from domain.repository.questionnaire_repository import (
+    QuestionnaireInstance,
+    QuestionnaireRepository,
+)
 from event.json import json_loads
 
 from test_helpers.dynamodb import mock_table
@@ -102,6 +112,157 @@ def test_index(version):
         assert result["headers"][key] == value
 
 
+@pytest.mark.parametrize(
+    "version",
+    [
+        "1",
+    ],
+)
+def test_index_mhs_device(version):
+    org = Root.create_ods_organisation(ods_code=ODS_CODE)
+    product_team = org.create_product_team(
+        name=PRODUCT_TEAM_NAME, keys=PRODUCT_TEAM_KEYS
+    )
+
+    with mock_table(TABLE_NAME) as client, mock.patch.dict(
+        os.environ,
+        {
+            "DYNAMODB_TABLE": TABLE_NAME,
+            "AWS_DEFAULT_REGION": "eu-west-2",
+        },
+        clear=True,
+    ):
+        # Set up ProductTeam in DB
+        product_team_repo = ProductTeamRepository(
+            table_name=TABLE_NAME, dynamodb_client=client
+        )
+        product_team_repo.write(entity=product_team)
+
+        # Set up EPR Product in DB
+        cpm_product = product_team.create_cpm_product(
+            name=PRODUCT_NAME, product_id=PRODUCT_ID
+        )
+        cpm_product.add_key(key_type=ProductKeyType.PARTY_KEY, key_value="F5H1R-850000")
+        product_repo = CpmProductRepository(
+            table_name=TABLE_NAME, dynamodb_client=client
+        )
+        product_repo.write(cpm_product)
+
+        # set up mhs message set questionnaire responses
+        mhs_message_set_questionnaire = QuestionnaireRepository().read(
+            QuestionnaireInstance.SPINE_MHS_MESSAGE_SETS
+        )
+        questionnaire_response = mhs_message_set_questionnaire.validate(
+            data={
+                "Interaction ID": "urn:foo",
+                "MHS SN": "bar",
+                "MHS IN": "baz",
+            }
+        )
+        questionnaire_response_2 = mhs_message_set_questionnaire.validate(
+            data={
+                "Interaction ID": "urn:foo2",
+                "MHS SN": "bar2",
+                "MHS IN": "baz2",
+            },
+        )
+
+        # Set up DeviceReferenceData in DB
+        device_reference_data = cpm_product.create_device_reference_data(
+            name="ABC1234-987654 - MHS Message Set"
+        )
+        device_reference_data.add_questionnaire_response(questionnaire_response)
+        device_reference_data.add_questionnaire_response(questionnaire_response_2)
+        device_reference_data_repo = DeviceReferenceDataRepository(
+            table_name=TABLE_NAME, dynamodb_client=client
+        )
+        device_reference_data_repo.write(device_reference_data)
+
+        # Set up Device in DB
+        device: Device = cpm_product.create_device(name="Product-MHS")
+        device.add_key(key_type="interaction_id", key_value="F5H1R-850000:urn:foo")
+        device.add_key(key_type="interaction_id", key_value="F5H1R-850000:urn:foo2")
+        device.add_tag(party_key="f5h1r-850000")
+
+        # set up spine mhs questionnaire response
+        mhs_message_set_questionnaire = QuestionnaireRepository().read(
+            QuestionnaireInstance.SPINE_MHS
+        )
+        spine_mhs_questionnaire_response = mhs_message_set_questionnaire.validate(
+            data={
+                "Address": "http://example.com",
+                "Unique Identifier": "123456",
+                "Managing Organization": "Example Org",
+                "MHS Party key": "party-key-001",
+                "MHS CPA ID": "cpa-id-001",
+                "Approver URP": "approver-123",
+                "Contract Property Template Key": "contract-key-001",
+                "Date Approved": "2024-01-01",
+                "Date DNS Approved": "2024-01-02",
+                "Date Requested": "2024-01-03",
+                "DNS Approver": "dns-approver-456",
+                "Interaction Type": "FHIR",
+                "MHS FQDN": "mhs.example.com",
+                "MHS Is Authenticated": "PERSISTENT",
+                "Product Key": "product-key-001",
+                "Requestor URP": "requestor-789",
+            }
+        )
+        device.add_questionnaire_response(spine_mhs_questionnaire_response)
+
+        device.add_device_reference_data_id(
+            device_reference_data_id=str(device_reference_data.id), path_to_data=["*"]
+        )
+
+        device_repo = DeviceRepository(table_name=TABLE_NAME, dynamodb_client=client)
+        device_repo.write(device)
+
+        from api.readDevice.index import handler
+
+        result = handler(
+            event={
+                "headers": {"version": version},
+                "pathParameters": {
+                    "product_team_id": str(product_team.id),
+                    "product_id": str(cpm_product.id.id),
+                    "device_id": str(device.id),
+                },
+            }
+        )
+
+    response_body = json_loads(result["body"])
+
+    # Assertions for fields that must exactly match
+    assert response_body["id"] == str(device.id)
+    assert response_body["product_id"] == str(cpm_product.id)
+    assert response_body["product_team_id"] == str(product_team.id)
+    assert response_body["name"] == device.name
+    assert response_body["ods_code"] == device.ods_code
+    assert response_body["status"] == Status.ACTIVE
+    assert response_body["deleted_on"] is None
+    assert response_body["keys"] is not None
+    assert response_body["tags"] is not None
+    assert response_body["device_reference_data"] is not None
+
+    # Assertions for fields that only need to be included
+    assert "created_on" in response_body
+    assert "spine_mhs/1" in response_body["questionnaire_responses"]
+
+    # Assert drd questionnaire responses have been added
+    assert "spine_mhs_message_sets/1" in response_body["questionnaire_responses"]
+
+    expected_headers = {
+        "Content-Type": "application/json",
+        "Version": version,
+    }
+
+    # Check response headers
+    assert result["statusCode"] == 200
+    assert result["headers"]["Content-Length"] == str(len(result["body"]))
+    for key, value in expected_headers.items():
+        assert result["headers"][key] == value
+
+
 @pytest.mark.parametrize(
     "version",
     [

src/api/tests/feature_tests/features/createDeviceMessageHandlingSystem.failure.feature

@@ -255,9 +255,17 @@ Feature: Create MHS Device - failure scenarios
       | path | value            |
       | name | My Great Product |
     And I note the response field "$.id" as "product_id"
-    And I note the response field "$.keys.0.key_type" as "party_key_tag"
-    And I note the response field "$.keys.0.key_value" as "party_key_value"
-    And I have already made a "POST" request with "default" headers to "ProductTeam/${ note(product_team_id) }/Product/${ note(product_id) }/DeviceReferenceData/MhsMessageSet"
+    And I have already made a "POST" request with "default" headers to "ProductTeam/${ note(product_team_id) }/Product/${ note(product_id) }/DeviceReferenceData/MhsMessageSet" with body:
+      | path                                                                                        | value                                                     |
+      | questionnaire_responses.spine_mhs_message_sets.0.Interaction ID                             | urn:nhs:names:services:ers:READ_PRACTITIONER_ROLE_R4_V001 |
+      | questionnaire_responses.spine_mhs_message_sets.0.MHS SN                                     | urn:nhs:names:services:ers                                |
+      | questionnaire_responses.spine_mhs_message_sets.0.MHS IN                                     | READ_PRACTITIONER_ROLE_R4_V001                            |
+      | questionnaire_responses.spine_mhs_message_sets.1.Interaction ID                             | urn:nhs:names:services:ebs:PRSC_IN080000UK07              |
+      | questionnaire_responses.spine_mhs_message_sets.1.MHS SN                                     | urn:nhs:names:services:ebs                                |
+      | questionnaire_responses.spine_mhs_message_sets.1.MHS IN                                     | PRSC_IN080000UK07                                         |
+      | questionnaire_responses.spine_mhs_message_sets.1.Reliability Configuration Retry Interval   | PT1M                                                      |
+      | questionnaire_responses.spine_mhs_message_sets.1.Reliability Configuration Retries          | ${ integer(2) }                                           |
+      | questionnaire_responses.spine_mhs_message_sets.1.Reliability Configuration Persist Duration | PT10M                                                     |
     And I note the response field "$.id" as "message_set_drd_id"
     And I have already made a "POST" request with "default" headers to "ProductTeam/${ note(product_team_id) }/Product/${ note(product_id) }/Device/MessageHandlingSystem" with body:
       | path                                                               | value              |