diff --git a/aws_lambda_powertools/utilities/parameters/ssm.py b/aws_lambda_powertools/utilities/parameters/ssm.py index 35b56d4c089..e8dd6941629 100644 --- a/aws_lambda_powertools/utilities/parameters/ssm.py +++ b/aws_lambda_powertools/utilities/parameters/ssm.py @@ -5,7 +5,6 @@ from __future__ import annotations import logging -import os import warnings from typing import TYPE_CHECKING, Any, Literal, overload @@ -13,7 +12,7 @@ from aws_lambda_powertools.shared import constants from aws_lambda_powertools.shared.functions import ( - resolve_truthy_env_var_choice, + resolve_bool_env_var, slice_dictionary, ) from aws_lambda_powertools.utilities.parameters.base import ( @@ -183,10 +182,8 @@ def get_multiple( # type: ignore[override] # ty: ignore[invalid-method-overrid max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) sdk_options["decrypt"] = decrypt sdk_options["recursive"] = recursive @@ -237,10 +234,8 @@ def get( # type: ignore[override] # ty: ignore[invalid-method-override] max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) # Add to `decrypt` sdk_options to we can have an explicit option for this sdk_options["decrypt"] = decrypt @@ -492,10 +487,8 @@ def get_parameters_by_name( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) # Init potential batch/decrypt batch responses and errors batch_ret: dict[str, Any] = {} @@ -883,10 +876,8 @@ def get_parameter( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) return DEFAULT_PROVIDERS["ssm"].get( name=name, @@ -1021,10 +1012,8 @@ def get_parameters( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) return DEFAULT_PROVIDERS["ssm"].get_multiple( path=path, @@ -1217,10 +1206,8 @@ def get_parameters_by_name( max_age = resolve_parameters_max_age(choice=max_age) # If decrypt is not set, resolve it from the environment variable, defaulting to False - decrypt = resolve_truthy_env_var_choice( - env=os.getenv(constants.PARAMETERS_SSM_DECRYPT_ENV, "false"), - choice=decrypt, - ) + if decrypt is None: + decrypt = resolve_bool_env_var(constants.PARAMETERS_SSM_DECRYPT_ENV) # Only create the provider if this function is called at least once if "ssm" not in DEFAULT_PROVIDERS: diff --git a/tests/functional/parameters/_boto3/test_utilities_parameters.py b/tests/functional/parameters/_boto3/test_utilities_parameters.py index a7482896988..14990ab180c 100644 --- a/tests/functional/parameters/_boto3/test_utilities_parameters.py +++ b/tests/functional/parameters/_boto3/test_utilities_parameters.py @@ -5,6 +5,7 @@ import random import string import uuid +import warnings from datetime import datetime, timedelta from io import BytesIO from typing import Any @@ -4817,3 +4818,122 @@ def test_secrets_provider_get_multiple_only_prefix_matches(config): provider.get_multiple(["db"]) assert not provider.store stubber.assert_no_pending_responses() + + +SSM_DECRYPT_PARAM_PATH = "/app" +SSM_DECRYPT_PARAM_NAME = "/app/param" +SSM_DECRYPT_PARAM_VALUE = "value" +SSM_DECRYPT_ENTRY_POINTS = [ + "SSMProvider.get", + "SSMProvider.get_multiple", + "SSMProvider.get_parameters_by_name", + "get_parameter", + "get_parameters", + "get_parameters_by_name", +] + + +def stub_ssm_lookup(stubber: stub.Stubber, entry_point: str, decrypt: bool) -> None: + if entry_point in ("SSMProvider.get", "get_parameter"): + response = { + "Parameter": { + "Name": SSM_DECRYPT_PARAM_NAME, + "Type": "String", + "Value": SSM_DECRYPT_PARAM_VALUE, + "Version": 1, + }, + } + stubber.add_response("get_parameter", response, {"Name": SSM_DECRYPT_PARAM_NAME, "WithDecryption": decrypt}) + elif entry_point in ("SSMProvider.get_multiple", "get_parameters"): + response = { + "Parameters": [ + {"Name": SSM_DECRYPT_PARAM_NAME, "Type": "String", "Value": SSM_DECRYPT_PARAM_VALUE, "Version": 1}, + ], + } + expected_params = {"Path": SSM_DECRYPT_PARAM_PATH, "WithDecryption": decrypt, "Recursive": stub.ANY} + stubber.add_response("get_parameters_by_path", response, expected_params) + else: + expected_params = {"Names": [SSM_DECRYPT_PARAM_NAME]} + if decrypt: + expected_params["WithDecryption"] = True + response = build_get_parameters_stub({SSM_DECRYPT_PARAM_NAME: SSM_DECRYPT_PARAM_VALUE}) + stubber.add_response("get_parameters", response, expected_params) + + +def call_ssm_lookup(monkeypatch, provider: SSMProvider, entry_point: str, **kwargs) -> Any: + monkeypatch.setitem(parameters.base.DEFAULT_PROVIDERS, "ssm", provider) + calls = { + "SSMProvider.get": lambda: provider.get(SSM_DECRYPT_PARAM_NAME, **kwargs), + "SSMProvider.get_multiple": lambda: provider.get_multiple(SSM_DECRYPT_PARAM_PATH, **kwargs), + "SSMProvider.get_parameters_by_name": lambda: provider.get_parameters_by_name( + parameters={SSM_DECRYPT_PARAM_NAME: {}}, + **kwargs, + ), + "get_parameter": lambda: parameters.get_parameter(SSM_DECRYPT_PARAM_NAME, **kwargs), + "get_parameters": lambda: parameters.get_parameters(SSM_DECRYPT_PARAM_PATH, **kwargs), + "get_parameters_by_name": lambda: parameters.get_parameters_by_name( + parameters={SSM_DECRYPT_PARAM_NAME: {}}, + **kwargs, + ), + } + return calls[entry_point]() + + +@pytest.mark.parametrize("entry_point", SSM_DECRYPT_ENTRY_POINTS) +@pytest.mark.parametrize("env_value", ["", "maybe"]) +def test_ssm_lookup_with_invalid_decrypt_env_var_warns_and_does_not_decrypt( + monkeypatch, + config, + entry_point, + env_value, +): + # GIVEN POWERTOOLS_PARAMETERS_SSM_DECRYPT is set to an empty or invalid value + monkeypatch.setenv("POWERTOOLS_PARAMETERS_SSM_DECRYPT", env_value) + provider = SSMProvider(boto_config=config) + + # WHEN a parameter is fetched without an explicit decrypt argument + with stub.Stubber(provider.client) as stubber: + stub_ssm_lookup(stubber, entry_point, decrypt=False) + with pytest.warns(PowertoolsUserWarning, match="POWERTOOLS_PARAMETERS_SSM_DECRYPT"): + value = call_ssm_lookup(monkeypatch, provider, entry_point) + + # THEN the lookup succeeds without decryption + stubber.assert_no_pending_responses() + + assert SSM_DECRYPT_PARAM_VALUE in (value if isinstance(value, str) else list(value.values())) + + +@pytest.mark.parametrize("entry_point", SSM_DECRYPT_ENTRY_POINTS) +@pytest.mark.parametrize("env_value, expected_decrypt", [("true", True), ("1", True), ("false", False), ("0", False)]) +def test_ssm_lookup_with_valid_decrypt_env_var(monkeypatch, config, entry_point, env_value, expected_decrypt): + # GIVEN POWERTOOLS_PARAMETERS_SSM_DECRYPT is set to a valid boolean value + monkeypatch.setenv("POWERTOOLS_PARAMETERS_SSM_DECRYPT", env_value) + provider = SSMProvider(boto_config=config) + + # WHEN a parameter is fetched without an explicit decrypt argument + with stub.Stubber(provider.client) as stubber: + stub_ssm_lookup(stubber, entry_point, decrypt=expected_decrypt) + with warnings.catch_warnings(): + warnings.simplefilter("error", PowertoolsUserWarning) + call_ssm_lookup(monkeypatch, provider, entry_point) + + # THEN decryption follows the environment variable, with no warning + stubber.assert_no_pending_responses() + + +@pytest.mark.parametrize("entry_point", SSM_DECRYPT_ENTRY_POINTS) +@pytest.mark.parametrize("decrypt", [True, False]) +def test_ssm_lookup_explicit_decrypt_wins_over_invalid_decrypt_env_var(monkeypatch, config, entry_point, decrypt): + # GIVEN POWERTOOLS_PARAMETERS_SSM_DECRYPT is set to an invalid value + monkeypatch.setenv("POWERTOOLS_PARAMETERS_SSM_DECRYPT", "maybe") + provider = SSMProvider(boto_config=config) + + # WHEN a parameter is fetched with an explicit decrypt argument + with stub.Stubber(provider.client) as stubber: + stub_ssm_lookup(stubber, entry_point, decrypt=decrypt) + with warnings.catch_warnings(): + warnings.simplefilter("error", PowertoolsUserWarning) + call_ssm_lookup(monkeypatch, provider, entry_point, decrypt=decrypt) + + # THEN the explicit argument is used and the environment variable is not read + stubber.assert_no_pending_responses()