Tests correctly reset config object.

Author: purple4reina

datadog_lambda/config.py

@@ -17,7 +17,7 @@ def _getter(self):
             setattr(self, prop_key, val)
         return getattr(self, prop_key)
 
-    prop_key = f"_{key}"
+    prop_key = f"_config_{key}"
     return _getter
 
 
@@ -42,12 +42,17 @@ class Config:
 
     @property
     def fips_mode_enabled(self):
-        if not hasattr(self, "_fips_mode_enabled"):
-            self._fips_mode_enabled = os.environ.get(
+        if not hasattr(self, "_config_fips_mode_enabled"):
+            self._config_fips_mode_enabled = os.environ.get(
                 "DD_LAMBDA_FIPS_MODE",
                 "true" if self.is_gov_region else "false",
             ).lower() == "true"
-        return self._fips_mode_enabled
+        return self._config_fips_mode_enabled
+
+    def reset(self):
+        for attr in dir(self):
+            if attr.startswith("_config_"):
+                delattr(self, attr)
 
 
 config = Config()

tests/conftest.py

@@ -0,0 +1,7 @@
+import pytest
+
+from datadog_lambda.config import config
+
+@pytest.fixture(autouse=True)
+def reset_config():
+    config.reset()

tests/test_api.py

@@ -22,7 +22,10 @@ def setUp(self):
         )
         self.env_patcher.start()
 
-    @patch("datadog_lambda.api.fips_mode_enabled", True)
+    def tearDown(self):
+        del os.environ["AWS_REGION"]
+
+    @patch("datadog_lambda.config.Config.fips_mode_enabled", True)
     @patch("botocore.session.Session.create_client")
     def test_secrets_manager_fips_endpoint(self, mock_boto3_client):
         mock_client = MagicMock()
@@ -63,7 +66,7 @@ def test_secrets_manager_different_region(self, mock_boto3_client):
         )
         self.assertEqual(api_key, "test-api-key")
 
-    @patch("datadog_lambda.api.fips_mode_enabled", True)
+    @patch("datadog_lambda.config.Config.fips_mode_enabled", True)
     @patch("botocore.session.Session.create_client")
     def test_secrets_manager_different_region_but_still_fips(self, mock_boto3_client):
         mock_client = MagicMock()
@@ -84,7 +87,7 @@ def test_secrets_manager_different_region_but_still_fips(self, mock_boto3_client
         )
         self.assertEqual(api_key, "test-api-key")
 
-    @patch("datadog_lambda.api.fips_mode_enabled", True)
+    @patch("datadog_lambda.config.Config.fips_mode_enabled", True)
     @patch("botocore.session.Session.create_client")
     def test_ssm_fips_endpoint(self, mock_boto3_client):
         mock_client = MagicMock()
@@ -103,7 +106,7 @@ def test_ssm_fips_endpoint(self, mock_boto3_client):
         )
         self.assertEqual(api_key, "test-api-key")
 
-    @patch("datadog_lambda.api.fips_mode_enabled", True)
+    @patch("datadog_lambda.config.Config.fips_mode_enabled", True)
     @patch("botocore.session.Session.create_client")
     @patch("datadog_lambda.api.decrypt_kms_api_key")
     def test_kms_fips_endpoint(self, mock_decrypt_kms, mock_boto3_client):

tests/test_cold_start.py

@@ -247,7 +247,7 @@ def finish(span):
 
     monkeypatch.setattr(wrapper.tracer, "_on_span_finish", finish)
     monkeypatch.setattr(wrapper, "is_new_sandbox", lambda: True)
-    monkeypatch.setattr("datadog_lambda.wrapper.dd_tracing_enabled", True)
+    monkeypatch.setattr("datadog_lambda.config.Config.trace_enabled", True)
     monkeypatch.setenv(
         "DD_COLD_START_TRACE_SKIP_LIB", "ddtrace.contrib.logging,datadog_lambda.wrapper"
     )

tests/test_config.py

@@ -1,6 +1,16 @@
 import pytest
 
-from datadog_lambda.config import Config
+from datadog_lambda.config import config
+
+
+@pytest.fixture
+def setenv(monkeypatch):
+    def set_env(key, value):
+        if value is None:
+            monkeypatch.delenv(key, raising=False)
+        else:
+            monkeypatch.setenv(key, value)
+    return set_env
 
 
 _test_config_from_environ = (
@@ -109,10 +119,8 @@
 )
 
 @pytest.mark.parametrize('env_key,conf_key,env_val,conf_val', _test_config_from_environ)
-def test_config_from_environ(env_key, conf_key, env_val, conf_val, monkeypatch):
-    if env_val is not None:
-        monkeypatch.setenv(env_key, env_val)
-    config = Config()
+def test_config_from_environ(env_key, conf_key, env_val, conf_val, setenv):
+    setenv(env_key, env_val)
     assert getattr(config, conf_key) == conf_val
 
 
@@ -160,9 +168,7 @@ def test_config_from_environ(env_key, conf_key, env_val, conf_val, monkeypatch):
 )
 
 @pytest.mark.parametrize('fips_mode,region,conf_val', _test_fips_mode_from_environ)
-def test_fips_mode_from_environ(fips_mode, region, conf_val, monkeypatch):
-    if fips_mode is not None:
-        monkeypatch.setenv("DD_LAMBDA_FIPS_MODE", fips_mode)
-    if region is not None:
-        monkeypatch.setenv("AWS_REGION", region)
-    assert Config().fips_mode_enabled == conf_val
+def test_fips_mode_from_environ(fips_mode, region, conf_val, setenv):
+    setenv("DD_LAMBDA_FIPS_MODE", fips_mode)
+    setenv("AWS_REGION", region)
+    assert config.fips_mode_enabled == conf_val

tests/test_metric.py

@@ -7,6 +7,7 @@
 from datadog.api.exceptions import ClientError
 
 from datadog_lambda.api import KMS_ENCRYPTION_CONTEXT_KEY, decrypt_kms_api_key
+from datadog_lambda.config import config
 from datadog_lambda.metric import (
     MetricsHandler,
     _select_metrics_handler,
@@ -19,6 +20,7 @@
 
 class TestLambdaMetric(unittest.TestCase):
     def setUp(self):
+        config.reset()
         lambda_stats_patcher = patch("datadog_lambda.metric.lambda_stats")
         self.mock_metric_lambda_stats = lambda_stats_patcher.start()
         self.addCleanup(lambda_stats_patcher.stop)
@@ -62,7 +64,7 @@ def test_select_metrics_handler_dd_api_fallback(self):
         self.assertEqual(MetricsHandler.DATADOG_API, _select_metrics_handler())
         del os.environ["DD_FLUSH_TO_LOG"]
 
-    @patch("datadog_lambda.metric.fips_mode_enabled", True)
+    @patch("datadog_lambda.config.Config.fips_mode_enabled", True)
     @patch("datadog_lambda.metric.should_use_extension", False)
     def test_select_metrics_handler_has_no_fallback_in_fips_mode(self):
         os.environ["DD_FLUSH_TO_LOG"] = "False"

tests/test_tracing.py

@@ -15,6 +15,7 @@
 from ddtrace._trace._span_pointer import _SpanPointerDirection
 from ddtrace._trace._span_pointer import _SpanPointerDescription
 
+from datadog_lambda.config import config
 from datadog_lambda.constants import (
     SamplingPriority,
     TraceHeader,
@@ -251,20 +252,16 @@ def test_extract_dd_trace_context(event, expect):
 
 class TestExtractAndGetDDTraceContext(unittest.TestCase):
     def setUp(self):
-        global dd_tracing_enabled
-        dd_tracing_enabled = False
         os.environ["_X_AMZN_TRACE_ID"] = fake_xray_header_value
         patcher = patch("datadog_lambda.tracing.send_segment")
         self.mock_send_segment = patcher.start()
         self.addCleanup(patcher.stop)
-        patcher = patch("datadog_lambda.tracing.is_lambda_context")
+        patcher = patch("datadog_lambda.config.Config.is_lambda_context")
         self.mock_is_lambda_context = patcher.start()
         self.mock_is_lambda_context.return_value = True
         self.addCleanup(patcher.stop)
 
     def tearDown(self):
-        global dd_tracing_enabled
-        dd_tracing_enabled = False
         del os.environ["_X_AMZN_TRACE_ID"]
 
     @with_trace_propagation_style("datadog")
@@ -975,6 +972,7 @@ def test_convert_xray_sampling(self):
 
 class TestLogsInjection(unittest.TestCase):
     def setUp(self):
+        config.reset()
         patcher = patch("datadog_lambda.tracing.get_dd_trace_context_obj")
         self.mock_get_dd_trace_context = patcher.start()
         self.mock_get_dd_trace_context.return_value = Context(
@@ -984,11 +982,12 @@ def setUp(self):
         )
         self.addCleanup(patcher.stop)
 
-        patcher = patch("datadog_lambda.tracing.is_lambda_context")
+        patcher = patch("datadog_lambda.config.Config.is_lambda_context")
         self.mock_is_lambda_context = patcher.start()
         self.mock_is_lambda_context.return_value = True
         self.addCleanup(patcher.stop)
 
+    @patch("datadog_lambda.config.Config.trace_enabled", False)
     def test_set_correlation_ids(self):
         set_correlation_ids()
         span = tracer.current_span()
@@ -1124,13 +1123,11 @@ def test_function_with_span_pointers(self):
 
 class TestSetTraceRootSpan(unittest.TestCase):
     def setUp(self):
-        global dd_tracing_enabled
-        dd_tracing_enabled = False
         os.environ["_X_AMZN_TRACE_ID"] = fake_xray_header_value
         patcher = patch("datadog_lambda.tracing.send_segment")
         self.mock_send_segment = patcher.start()
         self.addCleanup(patcher.stop)
-        patcher = patch("datadog_lambda.tracing.is_lambda_context")
+        patcher = patch("datadog_lambda.config.Config.is_lambda_context")
         self.mock_is_lambda_context = patcher.start()
         self.mock_is_lambda_context.return_value = True
         self.addCleanup(patcher.stop)
@@ -1143,8 +1140,6 @@ def setUp(self):
         self.addCleanup(patcher.stop)
 
     def tearDown(self):
-        global dd_tracing_enabled
-        dd_tracing_enabled = False
         del os.environ["_X_AMZN_TRACE_ID"]
 
     def test_mixed_parent_context_when_merging(self):
@@ -1245,6 +1240,7 @@ def test_get_service_mapping(self):
             create_service_mapping(os.environ["DD_SERVICE_MAPPING"])
         )
         self.assertEqual(self.get_service_mapping(), expected_output)
+        del os.environ["DD_SERVICE_MAPPING"]
 
     def test_set_service_mapping(self):
         new_service_mapping = {"api3": "service3", "api4": "service4"}
@@ -1285,6 +1281,8 @@ def test_determine_service_name(self):
             "default",
         )
 
+        del os.environ["DD_SERVICE_MAPPING"]
+
     def test_remaps_all_inferred_span_service_names_from_api_gateway_event(self):
         new_service_mapping = {"lambda_api_gateway": "new-name"}
         self.set_service_mapping(new_service_mapping)
@@ -2386,7 +2384,7 @@ def test_deterministic_m5_hash__always_leading_with_zero(self):
 
 
 class TestExceptionOutsideHandler(unittest.TestCase):
-    @patch("datadog_lambda.tracing.dd_tracing_enabled", True)
+    @patch("datadog_lambda.config.Config.trace_enabled", True)
     @patch("datadog_lambda.tracing.submit_errors_metric")
     @patch("time.time_ns", return_value=42)
     def test_exception_outside_handler_tracing_enabled(
@@ -2427,7 +2425,7 @@ def test_exception_outside_handler_tracing_enabled(
         assert mock_span.error == 1
         assert mock_span.start_ns == 42
 
-    @patch("datadog_lambda.tracing.dd_tracing_enabled", False)
+    @patch("datadog_lambda.config.Config.trace_enabled", False)
     @patch("datadog_lambda.tracing.submit_errors_metric")
     @patch("time.time_ns", return_value=42)
     def test_exception_outside_handler_tracing_disabled(

tests/test_wrapper.py

@@ -8,6 +8,8 @@
 
 import datadog_lambda.wrapper as wrapper
 import datadog_lambda.xray as xray
+
+from datadog_lambda.config import config
 from datadog_lambda.metric import lambda_metric
 from datadog_lambda.thread_stats_writer import ThreadStatsWriter
 from ddtrace.trace import Span, tracer
@@ -24,7 +26,6 @@ def setUp(self):
         patch("ddtrace.internal.writer.AgentWriter.flush_queue").start()
 
         wrapper.datadog_lambda_wrapper._force_wrap = True
-        wrapper.dd_tracing_enabled = True
         patcher = patch(
             "datadog.threadstats.reporters.HttpReporter.flush_distributions"
         )
@@ -76,9 +77,8 @@ def setUp(self):
         self.mock_dd_lambda_layer_tag = patcher.start()
         self.addCleanup(patcher.stop)
 
+    @patch("datadog_lambda.config.Config.trace_enabled", False)
     def test_datadog_lambda_wrapper(self):
-        wrapper.dd_tracing_enabled = False
-
         @wrapper.datadog_lambda_wrapper
         def lambda_handler(event, context):
             lambda_metric("test.metric", 100)
@@ -88,7 +88,6 @@ def lambda_handler(event, context):
         lambda_context = get_mock_context()
 
         lambda_handler(lambda_event, lambda_context)
-        wrapper.dd_tracing_enabled = True
         self.mock_threadstats_flush_distributions.assert_has_calls(
             [
                 call(
@@ -185,17 +184,16 @@ def lambda_handler(event, context):
         metric_module.lambda_stats.stop()
         metric_module.lambda_stats = ThreadStatsWriter(False)
 
+    @patch("datadog_lambda.config.Config.trace_enabled", False)
     def test_datadog_lambda_wrapper_inject_correlation_ids(self):
         os.environ["DD_LOGS_INJECTION"] = "True"
-        wrapper.dd_tracing_enabled = False
 
         @wrapper.datadog_lambda_wrapper
         def lambda_handler(event, context):
             lambda_metric("test.metric", 100)
 
         lambda_event = {}
         lambda_handler(lambda_event, get_mock_context())
-        wrapper.dd_tracing_enabled = True
         self.mock_set_correlation_ids.assert_called()
         self.mock_inject_correlation_ids.assert_called()
 
@@ -453,11 +451,8 @@ def lambda_handler(event, context):
             ]
         )
 
+    @patch("datadog_lambda.config.Config.enhanced_metrics_enabled", False)
     def test_no_enhanced_metrics_without_env_var(self):
-        patcher = patch("datadog_lambda.metric.enhanced_metrics_enabled", False)
-        patcher.start()
-        self.addCleanup(patcher.stop)
-
         @wrapper.datadog_lambda_wrapper
         def lambda_handler(event, context):
             raise RuntimeError()
@@ -565,8 +560,9 @@ def return_type_test(event, context):
 
 
 class TestLambdaDecoratorSettings(unittest.TestCase):
+
+    @patch("datadog_lambda.config.Config.trace_enabled", False)
     def test_some_envs_should_depend_on_dd_tracing_enabled(self):
-        wrapper.dd_tracing_enabled = False
         os.environ[wrapper.DD_TRACE_MANAGED_SERVICES] = "true"
         os.environ[wrapper.DD_ENCODE_AUTHORIZER_CONTEXT] = "true"
         os.environ[wrapper.DD_DECODE_AUTHORIZER_CONTEXT] = "true"