lint fixes

Author: Karthikeyannhs

tests/docker-compose.yml

@@ -1,6 +1,7 @@
 services:
   moto-server:
     #used for s3, dynamodb, kinesis, secret manager
+    # lambda cannot be used, because its 3.11 (older)
     image: motoserver/moto:latest
     container_name: moto-server
     ports:

tests/integration/conftest.py

@@ -3,7 +3,7 @@
 import logging
 import os
 from collections.abc import Callable, Generator
-from typing import TYPE_CHECKING, Any
+from typing import Any
 
 import httpx
 import pytest
@@ -37,9 +37,6 @@
 from tests.fixtures.builders.model.rule import RulesMapperFactory
 from tests.fixtures.builders.repos.person import person_rows_builder
 
-if TYPE_CHECKING:
-    pass
-
 logger = logging.getLogger(__name__)
 
 AWS_REGION = "eu-west-1"
@@ -52,6 +49,8 @@
 
 MOTO_PORT = 5000
 
+HTTP_SERVER_ERROR = 500
+
 
 @pytest.fixture(scope="session")
 def docker_compose_project_name():
@@ -62,9 +61,9 @@ def docker_compose_project_name():
 def aws_credentials():
     """Mocked AWS Credentials for moto."""
     os.environ["AWS_ACCESS_KEY_ID"] = "dummy_key"
-    os.environ["AWS_SECRET_ACCESS_KEY"] = "dummy_secret"
-    os.environ["AWS_SECURITY_TOKEN"] = "dummy_token"
-    os.environ["AWS_SESSION_TOKEN"] = "dummy_session_token"
+    os.environ["AWS_SECRET_ACCESS_KEY"] = "dummy_secret"  # noqa: S105
+    os.environ["AWS_SECURITY_TOKEN"] = "dummy_token"  # noqa: S105
+    os.environ["AWS_SESSION_TOKEN"] = "dummy_session_token"  # noqa: S105
     os.environ["AWS_DEFAULT_REGION"] = AWS_REGION
 
 
@@ -84,24 +83,30 @@ def moto_server(request: pytest.FixtureRequest) -> URL:
 def is_responsive(url: URL) -> bool:
     try:
         response = httpx.get(str(url), timeout=2.0)
-        return response.status_code < 500
     except (httpx.ConnectError, httpx.RemoteProtocolError, httpx.TimeoutException):
         return False
+    else:
+        # Use the constant instead of the raw number
+        return response.status_code < HTTP_SERVER_ERROR
 
 
 @pytest.fixture(scope="session")
 def boto3_session() -> Session:
-    return Session(aws_access_key_id="fake", aws_secret_access_key="fake", aws_session_token="fake", region_name=AWS_REGION)
+    return Session(
+        aws_access_key_id="fake", aws_secret_access_key="fake", aws_session_token="fake", region_name=AWS_REGION
+    )
 
 
 @pytest.fixture(scope="session")
 def dynamodb_client(boto3_session: Session, moto_server: URL) -> BaseClient:
     return boto3_session.client("dynamodb", endpoint_url=str(moto_server))
 
+
 @pytest.fixture(scope="session")
 def dynamodb_resource(boto3_session: Session, moto_server: URL) -> ServiceResource:
     return boto3_session.resource("dynamodb", endpoint_url=str(moto_server))
 
+
 def get_log_messages(flask_function: str, logs_client: BaseClient) -> list[str]:
     for attempt in stamina.retry_context(on=ClientError, attempts=20, timeout=120):
         with attempt:
@@ -115,10 +120,6 @@ def get_log_messages(flask_function: str, logs_client: BaseClient) -> list[str]:
     )
     return [e["message"] for e in log_events["events"]]
 
-@pytest.fixture(scope="session")
-def logs_client(boto3_session: Session, moto_server: URL) -> BaseClient:
-    return boto3_session.client("logs", endpoint_url=str(moto_server))
-
 
 @pytest.fixture(scope="session")
 def iam_client(boto3_session: Session, moto_server: URL) -> BaseClient:

tests/integration/lambda/conftest.py

@@ -1,7 +1,8 @@
 import os
+import shutil
 import subprocess
+from collections.abc import Callable
 from pathlib import Path
-from typing import Callable
 
 import pytest
 from boto3 import Session
@@ -12,19 +13,25 @@
 
 
 def get_project_root() -> Path:
-    """Finds the project root by looking for the 'dist' directory or a git folder."""
+    """Find the project root by locating 'dist' or '.git'."""
     current = Path(__file__).resolve()
     for parent in current.parents:
         if (parent / "dist").exists() or (parent / ".git").exists():
             return parent
     return Path(__file__).resolve().parents[3]
 
+
 @pytest.fixture(scope="session")
 def lambda_zip() -> Path:
+    """Build the lambda.zip artifact using `make build`."""
     project_root = get_project_root()
 
-    build_result = subprocess.run(
-        ["make", "build"],
+    make_path = shutil.which("make")
+    if not make_path:
+        pytest.fail("The 'make' executable was not found in the system PATH.")
+
+    build_result = subprocess.run(  # noqa: S603
+        [make_path, "build"],
         cwd=project_root,
         capture_output=True,
         text=True,
@@ -34,61 +41,81 @@ def lambda_zip() -> Path:
     if build_result.returncode != 0:
         pytest.fail(
             f"'make build' failed with code {build_result.returncode}.\n"
-            f"STDOUT: {build_result.stdout}\n"
-            f"STDERR: {build_result.stderr}"
+            f"STDOUT:\n{build_result.stdout}\n"
+            f"STDERR:\n{build_result.stderr}"
         )
 
-    zip_path = project_root / "dist/lambda.zip"
+    zip_path = project_root / "dist" / "lambda.zip"
     if not zip_path.exists():
         pytest.fail(f"Build succeeded but {zip_path} was not created.")
 
     return zip_path
 
+
 @pytest.fixture(scope="session")
-def lambda_runtime_url(request, lambda_zip):
+def lambda_runtime_url(request, lambda_zip):  # noqa: ARG001
     """
-    kick-starts the lambda simulation
+    Start the lambda simulation using docker compose.
     """
     docker_services = request.getfixturevalue("docker_services")
     docker_ip = request.getfixturevalue("docker_ip")
     project_root = get_project_root()
     compose_file = project_root / "tests/docker-compose.yml"
 
+    # Activate the profile without using the --profile flag
     env = os.environ.copy()
     env["COMPOSE_PROFILES"] = "lambda-test"
 
-    subprocess.run(
+    docker_path = shutil.which("docker")
+    if not docker_path:
+        pytest.fail("Docker executable not found in PATH")
+
+    result = subprocess.run(  # noqa: S603
         [
-            "docker", "compose",
-            "-f", str(compose_file),
-            "up", "-d", "--build", "--force-recreate",
-            "lambda-api", "api-gateway-mock",
+            docker_path,
+            "compose",
+            "-f",
+            str(compose_file),
+            "up",
+            "-d",
+            "--build",
+            "--force-recreate",
+            "lambda-api",
+            "api-gateway-mock",
         ],
         env=env,
-        check=True,
         capture_output=True,
         text=True,
+        check=False,
     )
 
+    if result.returncode != 0:
+        pytest.fail(
+            f"Docker compose failed with code {result.returncode}.\nSTDOUT:\n{result.stdout}\nSTDERR:\n{result.stderr}"
+        )
+
     port = docker_services.port_for("lambda-api", 8080)
     base_url = URL(f"http://{docker_ip}:{port}")
 
     docker_services.wait_until_responsive(
-        timeout=30.0, pause=0.5, check=lambda: is_responsive(base_url)
+        timeout=30.0,
+        pause=0.5,
+        check=lambda: is_responsive(base_url),
     )
 
     return base_url
 
 
-
 @pytest.fixture(scope="session")
 def lambda_client(boto3_session: Session, lambda_runtime_url: URL) -> BaseClient:
+    """Return a boto3 Lambda client pointing at the simulated lambda runtime."""
     return boto3_session.client("lambda", endpoint_url=str(lambda_runtime_url))
 
+
 @pytest.fixture(scope="session")
-def api_gateway_endpoint(request: pytest.FixtureRequest, lambda_runtime_url) -> URL:
+def api_gateway_endpoint(request: pytest.FixtureRequest, lambda_runtime_url):  # noqa: ARG001
     """
-        kick-starts the api-gateway lambda simulation
+    Start and validate the API Gateway mock.
     """
     docker_services = request.getfixturevalue("docker_services")
     docker_ip = request.getfixturevalue("docker_ip")
@@ -101,26 +128,45 @@ def api_gateway_endpoint(request: pytest.FixtureRequest, lambda_runtime_url) ->
     docker_services.wait_until_responsive(
         timeout=30.0,
         pause=1.0,
-        check=lambda: is_responsive(health_url)
+        check=lambda: is_responsive(health_url),
     )
+
     return base_url
 
 
 @pytest.fixture
 def lambda_logs(docker_services) -> Callable[[], list[str]]:
-    """Returns a callable that fetches the latest lambda-api logs,
-    allowing tests to inspect runtime output on demand."""
+    """Return a callable that fetches the latest lambda-api logs."""
 
     def _get_messages() -> list[str]:
         return get_lambda_logs(docker_services)
 
     return _get_messages
 
 
-def get_lambda_logs(docker_services) -> list[str]:
-    """returns logs from lambda-api container"""
+def get_lambda_logs(docker_services) -> list[str]:  # noqa :ARG001
+    """Fetch logs from the lambda-api container."""
+    raw_docker = shutil.which("docker")
+    if not raw_docker:
+        return ["Error: Docker not found"]
 
-    result: bytes = docker_services._docker_compose.execute("logs --no-color lambda-api")
-    raw_lines = result.decode("utf-8").splitlines()
-    return [line.partition("|")[-1].strip() for line in raw_lines]
+    docker_path = Path(raw_docker).resolve()
+    project_root = get_project_root()
+    compose_file = (project_root / "tests" / "docker-compose.yml").resolve()
+
+    result = subprocess.run(  # noqa: S603
+        [
+            str(docker_path),
+            "compose",
+            "-f",
+            str(compose_file),
+            "logs",
+            "--no-color",
+            "lambda-api",
+        ],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
 
+    return [line.partition("|")[-1].strip() for line in result.stdout.splitlines()]

tests/integration/lambda/test_app_running_as_lambda.py

@@ -1,13 +1,10 @@
-import base64
 import json
 import logging
+from collections.abc import Callable
 from http import HTTPStatus
-from typing import Callable, List
 
 import httpx
-import stamina
 from botocore.client import BaseClient
-from botocore.exceptions import ClientError
 from brunns.matchers.data import json_matching as is_json_that
 from brunns.matchers.response import is_response
 from freezegun import freeze_time
@@ -38,7 +35,7 @@ def test_install_and_call_lambda_flask(
     persisted_person: NHSNumber,
     consumer_to_active_rsv_campaign_mapping: ConsumerMapping,  # noqa: ARG001
     consumer_id: ConsumerId,
-    secretsmanager_client: BaseClient,
+    secretsmanager_client: BaseClient,  # noqa :ARG001
 ):
     """Given lambda installed into localstack, run it via boto3 lambda client"""
     # Given
@@ -92,7 +89,7 @@ def test_install_and_call_flask_lambda_over_http(
     persisted_person: NHSNumber,
     consumer_to_active_rsv_campaign_mapping: ConsumerMapping,  # noqa: ARG001
     consumer_id: ConsumerId,
-    secretsmanager_client: BaseClient,
+    secretsmanager_client: BaseClient,  # noqa:ARG001
     api_gateway_endpoint: URL,
 ):
     """Given api-gateway and lambda installed into localstack, run it via http"""
@@ -116,10 +113,9 @@ def test_install_and_call_flask_lambda_with_unknown_nhs_number(  # noqa: PLR0913
     persisted_person: NHSNumber,
     consumer_to_active_rsv_campaign_mapping: ConsumerMapping,  # noqa: ARG001
     consumer_id: ConsumerId,
-    logs_client: BaseClient,
     api_gateway_endpoint: URL,
     secretsmanager_client: BaseClient,  # noqa: ARG001
-    lambda_logs: Callable[[], List[str]]
+    lambda_logs: Callable[[], list[str]],
 ):
     """Given lambda installed into localstack, run it via http, with a nonexistent NHS number specified"""
     # Given
@@ -147,15 +143,15 @@ def test_install_and_call_flask_lambda_with_unknown_nhs_number(  # noqa: PLR0913
                             severity="error",
                             code="processing",
                             diagnostics=f"NHS Number '{nhs_number!s}' was not "
-                                        f"recognised by the Eligibility Signposting API",
+                            f"recognised by the Eligibility Signposting API",
                             details={
                                 "coding": [
                                     {
                                         "system": "https://fhir.nhs.uk/STU3/ValueSet/Spine-ErrorOrWarningCode-1",
                                         "code": "REFERENCE_NOT_FOUND",
                                         "display": "The given NHS number was not found in our datasets. "
-                                                   "This could be because the number is incorrect or "
-                                                   "some other reason we cannot process that number.",
+                                        "This could be because the number is incorrect or "
+                                        "some other reason we cannot process that number.",
                                     }
                                 ]
                             },
@@ -182,8 +178,8 @@ def test_given_nhs_number_in_path_matches_with_nhs_number_in_headers_and_check_i
     s3_client: BaseClient,
     audit_bucket: BucketName,
     api_gateway_endpoint: URL,
-    lambda_logs: Callable[[], List[str]],
-    secretsmanager_client: BaseClient,
+    lambda_logs: Callable[[], list[str]],
+    secretsmanager_client: BaseClient,  # noqa:ARG001
 ):
     # Given
     # When
@@ -320,10 +316,10 @@ def test_given_nhs_number_in_path_does_not_match_with_nhs_number_in_headers_resu
 
 
 def test_given_nhs_number_not_present_in_headers_results_in_valid_for_application_restricted_users(
-    lambda_client: BaseClient,
-    secretsmanager_client: BaseClient, # noqa:ARG001
+    lambda_client: BaseClient,  # noqa:ARG001
+    secretsmanager_client: BaseClient,  # noqa:ARG001
     persisted_person: NHSNumber,
-    consumer_to_active_rsv_campaign_mapping: ConsumerMapping,
+    consumer_to_active_rsv_campaign_mapping: ConsumerMapping,  # noqa:ARG001
     api_gateway_endpoint: URL,
 ):
     # Given
@@ -622,8 +618,6 @@ def test_token_formatting_in_eligibility_response_and_audit(  # noqa: PLR0913
     s3_client: BaseClient,
     audit_bucket: BucketName,
     api_gateway_endpoint: URL,
-    # noqa:ARG001
-    logs_client: BaseClient,  # noqa:ARG001
 ):
     invoke_url = f"{api_gateway_endpoint}/patient-check/{person_with_all_data}"
     response = httpx.get(
@@ -673,7 +667,7 @@ def test_incorrect_token_causes_internal_server_error(  # noqa: PLR0913
     s3_client: BaseClient,
     audit_bucket: BucketName,
     api_gateway_endpoint: URL,
-lambda_logs: Callable[[], List[str]]
+    lambda_logs: Callable[[], list[str]],
 ):
     invoke_url = f"{api_gateway_endpoint}/patient-check/{person_with_all_data}"
     response = httpx.get(