linting

Author: Karthikeyannhs

tests/integration/conftest.py

@@ -991,7 +991,7 @@ def campaign_config_with_invalid_tokens(s3_client: BaseClient, rules_bucket: Buc
     s3_client.delete_object(Bucket=rules_bucket, Key=f"{campaign.name}.json")
 
 
-@pytest.fixture(scope="function")
+@pytest.fixture
 def multiple_campaign_configs(s3_client: BaseClient, rules_bucket: BucketName) -> Generator[list[CampaignConfig]]:
     """Create and upload multiple campaign configs to S3, then clean up after tests."""
     campaigns, campaign_data_keys = [], []
@@ -1014,7 +1014,6 @@ def multiple_campaign_configs(s3_client: BaseClient, rules_bucket: BucketName) -
     for i in range(3):
         campaign = rule.CampaignConfigFactory.build(
             name=f"campaign_{i}",
-            id=f"{targets[i]}_campaign_id",
             target=targets[i],
             type="V",
             iterations=[
@@ -1111,71 +1110,8 @@ def campaign_config_with_missing_descriptions_missing_rule_text(
     yield campaign
     s3_client.delete_object(Bucket=rules_bucket, Key=f"{campaign.name}.json")
 
-@pytest.fixture(scope="function")
-def multiple_campaign_configs(request, s3_client: BaseClient, rules_bucket: BucketName) -> Generator[list[CampaignConfig]]:
-    """Create and upload multiple campaign configs to S3, then clean up after tests."""
-    campaigns, campaign_data_keys = [], []
-
-    targets = getattr(request, "param", ["RSV", "COVID", "FLU"])
-    target_rules_map = {
-        targets[0]: [
-            rule.PersonAgeSuppressionRuleFactory.build(type=RuleType.filter, description="TOO YOUNG"),
-            rule.PostcodeSuppressionRuleFactory.build(type=RuleType.filter, priority=8, cohort_label="cohort_label4"),
-        ],
-        targets[1]: [
-            rule.PersonAgeSuppressionRuleFactory.build(description="TOO YOUNG, your icb is: [[PERSON.ICB]]"),
-            rule.PostcodeSuppressionRuleFactory.build(
-                priority=12, cohort_label="cohort_label2", description="Your postcode is: [[PERSON.POSTCODE]]"
-            ),
-        ],
-        targets[2]: [rule.ICBRedirectRuleFactory.build()],
-    }
-
-    for i in range(3):
-        campaign = rule.CampaignConfigFactory.build(
-            name=f"campaign_{i}",
-            id=f"{targets[i]}_campaign_id",
-            target=targets[i],
-            type="V",
-            iterations=[
-                rule.IterationFactory.build(
-                    iteration_rules=target_rules_map.get(targets[i]),
-                    iteration_cohorts=[
-                        rule.IterationCohortFactory.build(
-                            cohort_label=f"cohort_label{i + 1}",
-                            cohort_group=f"cohort_group{i + 1}",
-                            positive_description=f"positive_desc_{i + 1}",
-                            negative_description=f"negative_desc_{i + 1}",
-                        ),
-                        rule.IterationCohortFactory.build(
-                            cohort_label="cohort_label4",
-                            cohort_group="cohort_group4",
-                            positive_description="positive_desc_4",
-                            negative_description="negative_desc_4",
-                        ),
-                    ],
-                    status_text=StatusText(
-                        NotEligible=f"You are not eligible to take {targets[i]} vaccines.",
-                        NotActionable=f"You have taken {targets[i]} vaccine in the last 90 days",
-                        Actionable=f"You can take {targets[i]} vaccine.",
-                    ),
-                )
-            ],
-        )
-        campaign_data = {"CampaignConfig": campaign.model_dump(by_alias=True)}
-        key = f"{campaign.name}.json"
-        s3_client.put_object(
-            Bucket=rules_bucket, Key=key, Body=json.dumps(campaign_data), ContentType="application/json"
-        )
-        campaigns.append(campaign)
-        campaign_data_keys.append(key)
-
-    yield campaigns
 
-    for key in campaign_data_keys:
-        s3_client.delete_object(Bucket=rules_bucket, Key=key)
-
-@pytest.fixture(scope="function")
+@pytest.fixture
 def campaign_configs(request, s3_client: BaseClient, rules_bucket: BucketName) -> Generator[list[CampaignConfig]]:
     """Create and upload multiple campaign configs to S3, then clean up after tests."""
     campaigns, campaign_data_keys = [], []
@@ -1220,6 +1156,7 @@ def campaign_configs(request, s3_client: BaseClient, rules_bucket: BucketName) -
     for key in campaign_data_keys:
         s3_client.delete_object(Bucket=rules_bucket, Key=key)
 
+
 @pytest.fixture(scope="class")
 def consumer_mapping(s3_client: BaseClient, consumer_mapping_bucket: BucketName) -> Generator[ConsumerMapping]:
     consumer_mapping = ConsumerMapping.model_validate({})
@@ -1235,11 +1172,16 @@ def consumer_mapping(s3_client: BaseClient, consumer_mapping_bucket: BucketName)
     yield consumer_mapping
     s3_client.delete_object(Bucket=consumer_mapping_bucket, Key="consumer_mapping.json")
 
+
 @pytest.fixture(scope="class")
-def consumer_mapping_for_rsv_and_covid(s3_client: BaseClient, consumer_mapping_bucket: BucketName) -> Generator[ConsumerMapping]:
+def consumer_mapping_for_rsv_and_covid(
+    s3_client: BaseClient, consumer_mapping_bucket: BucketName
+) -> Generator[ConsumerMapping]:
     consumer_mapping = ConsumerMapping.model_validate({})
-    consumer_mapping.root[ConsumerId("consumer-id-mapped-to-rsv-and-covid")] = [CampaignID("RSV_campaign_id"),
-                                                                CampaignID("COVID_campaign_id")]
+    consumer_mapping.root[ConsumerId("consumer-id-mapped-to-rsv-and-covid")] = [
+        CampaignID("RSV_campaign_id"),
+        CampaignID("COVID_campaign_id"),
+    ]
 
     consumer_mapping_data = consumer_mapping.model_dump(by_alias=True)
     s3_client.put_object(
@@ -1251,6 +1193,7 @@ def consumer_mapping_for_rsv_and_covid(s3_client: BaseClient, consumer_mapping_b
     yield consumer_mapping
     s3_client.delete_object(Bucket=consumer_mapping_bucket, Key="consumer_mapping.json")
 
+
 @pytest.fixture(scope="class")
 def consumer_mapping_with_various_targets(
     s3_client: BaseClient, consumer_mapping_bucket: BucketName

tests/integration/in_process/test_eligibility_endpoint.py

@@ -8,10 +8,11 @@
 from hamcrest import (
     assert_that,
     contains_exactly,
+    contains_inanyorder,
     equal_to,
     has_entries,
     has_entry,
-    has_key, has_item, all_of, has_length, contains, has_items, contains_inanyorder,
+    has_key,
 )
 
 from eligibility_signposting_api.config.constants import CONSUMER_ID
@@ -825,78 +826,83 @@ def test_not_actionable_and_check_response_when_rule_mapper_is_given(
             ),
         )
 
-
     @pytest.mark.parametrize(
-        "campaign_configs, consumer_mapping_for_rsv_and_covid, consumer_id, requested_conditions, expected_targets",
+        (
+            "campaign_configs",
+            "consumer_mapping_for_rsv_and_covid",
+            "consumer_id",
+            "requested_conditions",
+            "expected_targets",
+        ),
         [
             # Scenario 1: Intersection of mapped targets, requested targets, and active campaigns (Success)
             (
-                    ["RSV", "COVID", "FLU"],
-                    "consumer_mapping_for_rsv_and_covid",
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "ALL",
-                    ["RSV", "COVID"],
+                ["RSV", "COVID", "FLU"],
+                "consumer_mapping_for_rsv_and_covid",
+                "consumer-id-mapped-to-rsv-and-covid",
+                "ALL",
+                ["RSV", "COVID"],
             ),
             # Scenario 2: Explicit request for a single mapped target with an active campaign
             (
-                    ["RSV", "COVID", "FLU"],
-                    "consumer_mapping_for_rsv_and_covid",
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "RSV",
-                    ["RSV"],
+                ["RSV", "COVID", "FLU"],
+                "consumer_mapping_for_rsv_and_covid",
+                "consumer-id-mapped-to-rsv-and-covid",
+                "RSV",
+                ["RSV"],
             ),
             # Scenario 3: Request for an active campaign (FLU) that the consumer is NOT mapped to
             (
-                    ["RSV", "COVID", "FLU"],
-                    "consumer_mapping_for_rsv_and_covid",
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "FLU",
-                    [],
+                ["RSV", "COVID", "FLU"],
+                "consumer_mapping_for_rsv_and_covid",
+                "consumer-id-mapped-to-rsv-and-covid",
+                "FLU",
+                [],
             ),
             # Scenario 4: Request for a target that neither exists in system nor is mapped to consumer
             (
-                    ["RSV", "COVID", "FLU"],
-                    "consumer_mapping_for_rsv_and_covid",
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "HPV",
-                    [],
+                ["RSV", "COVID", "FLU"],
+                "consumer_mapping_for_rsv_and_covid",
+                "consumer-id-mapped-to-rsv-and-covid",
+                "HPV",
+                [],
             ),
             # Scenario 5: Consumer has no target mappings; requesting ALL should return empty
             (
-                    ["RSV", "COVID", "FLU"],
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "consumer-id-with-no-mapping",
-                    "ALL",
-                    [],
+                ["RSV", "COVID", "FLU"],
+                "consumer-id-mapped-to-rsv-and-covid",
+                "consumer-id-with-no-mapping",
+                "ALL",
+                [],
             ),
             # Scenario 6: Consumer has no target mappings; requesting specific target should return empty
             (
-                    ["RSV", "COVID", "FLU"],
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "consumer-id-with-no-mapping",
-                    "RSV",
-                    [],
+                ["RSV", "COVID", "FLU"],
+                "consumer-id-mapped-to-rsv-and-covid",
+                "consumer-id-with-no-mapping",
+                "RSV",
+                [],
             ),
             # Scenario 7: Consumer is mapped to targets (RSV/COVID), but those campaigns aren't active/present
             (
-                    ["MMR"],
-                    "consumer_mapping_for_rsv_and_covid",
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "ALL",
-                    [],
+                ["MMR"],
+                "consumer_mapping_for_rsv_and_covid",
+                "consumer-id-mapped-to-rsv-and-covid",
+                "ALL",
+                [],
             ),
             # Scenario 8: Request for specific mapped target (RSV), but those campaigns aren't active/present
             (
-                    ["MMR"],
-                    "consumer_mapping_for_rsv_and_covid",
-                    "consumer-id-mapped-to-rsv-and-covid",
-                    "RSV",
-                    [],
+                ["MMR"],
+                "consumer_mapping_for_rsv_and_covid",
+                "consumer-id-mapped-to-rsv-and-covid",
+                "RSV",
+                [],
             ),
         ],
-        indirect=["campaign_configs", "consumer_mapping_for_rsv_and_covid"]
+        indirect=["campaign_configs", "consumer_mapping_for_rsv_and_covid"],
     )
-    def test_valid_response_when_consumer_has_a_valid_campaign_config_mapping(
+    def test_valid_response_when_consumer_has_a_valid_campaign_config_mapping(  # noqa: PLR0913
         self,
         client: FlaskClient,
         persisted_person: NHSNumber,
@@ -911,7 +917,9 @@ def test_valid_response_when_consumer_has_a_valid_campaign_config_mapping(
         headers = {"nhs-login-nhs-number": str(persisted_person), CONSUMER_ID: consumer_id}
 
         # When
-        response = client.get(f"/patient-check/{persisted_person}?includeActions=Y&conditions={requested_conditions}", headers=headers)
+        response = client.get(
+            f"/patient-check/{persisted_person}?includeActions=Y&conditions={requested_conditions}", headers=headers
+        )
 
         assert_that(
             response,
@@ -922,10 +930,8 @@ def test_valid_response_when_consumer_has_a_valid_campaign_config_mapping(
                     has_entry(
                         "processedSuggestions",
                         # This ensures ONLY these items exist, no extras like FLU
-                        contains_inanyorder(
-                            *[has_entry("condition", i) for i in expected_targets]
-                        )
+                        contains_inanyorder(*[has_entry("condition", i) for i in expected_targets]),
                     )
                 )
-            )
+            ),
         )

tests/integration/lambda/test_app_running_as_lambda.py

@@ -424,6 +424,7 @@ def test_given_person_has_unique_status_for_different_conditions_with_audit(  #
     s3_client: BaseClient,
     audit_bucket: BucketName,
     api_gateway_endpoint: URL,
+    secretsmanager_client: BaseClient,  # noqa: ARG001
 ):
     invoke_url = f"{api_gateway_endpoint}/patient-check/{persisted_person_all_cohorts}"
     response = httpx.get(

tests/unit/services/test_eligibility_services.py

@@ -66,32 +66,33 @@ def test_eligibility_service_for_nonexistent_nhs_number():
 
 
 def test_get_eligibility_status_filters_permitted_campaigns(service, mock_repos):
-        """Tests that ONLY permitted campaigns reach the calculator factory."""
-        # Given
-        nhs_number = NHSNumber("1234567890")
-        person_data = {"age": 65, "vulnerable": True}
-        mock_repos["person"].get_eligibility_data.return_value = person_data
-
-        # Available campaigns in system
-        camp_a = MagicMock(spec=CampaignConfig, id=CampaignID("CAMP_A"))
-        camp_b = MagicMock(spec=CampaignConfig, id=CampaignID("CAMP_B"))
-        mock_repos["campaign"].get_campaign_configs.return_value = [camp_a, camp_b]
-
-        # Consumer is only permitted to see CAMP_B
-        mock_repos["consumer"].get_permitted_campaign_ids.return_value = [CampaignID("CAMP_B")]
-
-        # Mock calculator behavior
-        mock_calc = MagicMock()
-        mock_repos["factory"].get.return_value = mock_calc
-        mock_calc.get_eligibility_status.return_value = "eligible_result"
-
-        # When
-        result = service.get_eligibility_status(nhs_number, "Y", ["FLU"], "G1", "consumer_xyz")
-
-        # Then
-        # Verify the factory was called ONLY with camp_b
-        mock_repos["factory"].get.assert_called_once_with(person_data, [camp_b])
-        assert result == "eligible_result"
+    """Tests that ONLY permitted campaigns reach the calculator factory."""
+    # Given
+    nhs_number = NHSNumber("1234567890")
+    person_data = {"age": 65, "vulnerable": True}
+    mock_repos["person"].get_eligibility_data.return_value = person_data
+
+    # Available campaigns in system
+    camp_a = MagicMock(spec=CampaignConfig, id=CampaignID("CAMP_A"))
+    camp_b = MagicMock(spec=CampaignConfig, id=CampaignID("CAMP_B"))
+    mock_repos["campaign"].get_campaign_configs.return_value = [camp_a, camp_b]
+
+    # Consumer is only permitted to see CAMP_B
+    mock_repos["consumer"].get_permitted_campaign_ids.return_value = [CampaignID("CAMP_B")]
+
+    # Mock calculator behavior
+    mock_calc = MagicMock()
+    mock_repos["factory"].get.return_value = mock_calc
+    mock_calc.get_eligibility_status.return_value = "eligible_result"
+
+    # When
+    result = service.get_eligibility_status(nhs_number, "Y", ["FLU"], "G1", "consumer_xyz")
+
+    # Then
+    # Verify the factory was called ONLY with camp_b
+    mock_repos["factory"].get.assert_called_once_with(person_data, [camp_b])
+    assert result == "eligible_result"
+
 
 def test_raises_unknown_person_error_on_repo_not_found(service, mock_repos):
     """Tests that NotFoundError from repo is translated to UnknownPersonError."""

tests/unit/views/test_eligibility.py

@@ -606,7 +606,7 @@ def test_consumer_id_is_passed_to_service(app: Flask, client: FlaskClient):
         # Then
         # Verify the 5th positional argument or the keyword argument 'consumer_id'
         mock_service.get_eligibility_status.assert_called_once()
-        args, kwargs = mock_service.get_eligibility_status.call_args
+        args, _kwargs = mock_service.get_eligibility_status.call_args
 
         # Check that 'specific_consumer_123' was the consumer_id passed
         assert args[4] == "specific_consumer_123"