tests: add test coverage for type error path

Author: IzaakGough

tests/test_manifest.py

@@ -13,9 +13,33 @@
 # limitations under the License.
 """Manifest unit tests."""
 
+from collections.abc import Mapping as _Mapping
+from zoneinfo import ZoneInfo
+
+from pytest import raises
+
 import firebase_functions.params as _params
 import firebase_functions.private.manifest as _manifest
 
+
+class _CustomMapping(_Mapping):
+    def __init__(self, data):
+        self._data = data
+
+    def __getitem__(self, key):
+        return self._data[key]
+
+    def __iter__(self):
+        return iter(self._data)
+
+    def __len__(self):
+        return len(self._data)
+
+
+class _UnsupportedManifestValue:
+    pass
+
+
 full_endpoint = _manifest.ManifestEndpoint(
     platform="gcfv2",
     region=["us-west1"],
@@ -160,3 +184,23 @@ def test_endpoint_nones(self):
         assert expressions_actual_dict == expressions_expected_dict, (
             "Generated endpoint spec dict does not match expected dict."
         )
+
+    def test_object_to_spec_converts_tuple_to_list(self):
+        """Check tuple values are converted to manifest lists."""
+        actual = _manifest._object_to_spec(("hello", 1, True))
+        assert actual == ["hello", 1, True]
+
+    def test_object_to_spec_converts_custom_mapping_to_dict(self):
+        """Check Mapping implementations are converted via dict serialization."""
+        actual = _manifest._object_to_spec(_CustomMapping({"hello": "world"}))
+        assert actual == {"hello": "world"}
+
+    def test_object_to_spec_converts_zoneinfo_to_key(self):
+        """Check ZoneInfo values serialize to their key."""
+        actual = _manifest._object_to_spec(ZoneInfo("America/Los_Angeles"))
+        assert actual == "America/Los_Angeles"
+
+    def test_object_to_spec_raises_for_unsupported_value(self):
+        """Check unsupported values fail fast."""
+        with raises(TypeError, match="Unsupported manifest spec value"):
+            _manifest._object_to_spec(_UnsupportedManifestValue())

tests/test_options.py

@@ -15,9 +15,10 @@
 Options unit tests.
 """
 
-from pytest import raises
+from pytest import mark, raises
 
 from firebase_functions import alerts_fn, https_fn, options, params
+import firebase_functions.private.manifest as _manifest
 from firebase_functions.alerts import (
     app_distribution_fn,
     billing_fn,
@@ -31,6 +32,30 @@
 ALERT_SECRET = params.SecretParam("GITLAB_PERSONAL_ACCESS_TOKEN")
 
 
+class _UnsupportedManifestValue:
+    pass
+
+
+class _FakePattern:
+    def __init__(self, value, has_wildcards=False):
+        self.value = value
+        self.has_wildcards = has_wildcards
+
+
+def _assert_endpoint_manifest_type_error(endpoint):
+    with raises(TypeError, match="Unsupported manifest spec value"):
+        _manifest.manifest_to_spec_dict(_manifest.ManifestStack(endpoints={"test": endpoint}))
+
+
+def _assert_option_builder_type_error(builder):
+    try:
+        endpoint = builder()
+    except TypeError as exc:
+        assert "Unsupported manifest spec value" in str(exc)
+    else:
+        _assert_endpoint_manifest_type_error(endpoint)
+
+
 @https_fn.on_call()
 def asamplefunction(_):
     return "hello world"
@@ -305,3 +330,104 @@ def sample(_event):
         "crashlytics.newFatalIssue",
         expect_app_id="app-123",
     )
+
+
+@mark.parametrize(
+    ("builder"),
+    [
+        lambda: options.RuntimeOptions(region=_UnsupportedManifestValue())._endpoint(
+            func_name="test"
+        ),
+        lambda: options.EventHandlerOptions(retry=_UnsupportedManifestValue())._endpoint(
+            func_name="test",
+            event_filters={},
+            event_type="google.cloud.pubsub.topic.v1.messagePublished",
+        ),
+        lambda: options.TaskQueueOptions(
+            retry_config=options.RetryConfig(max_attempts=_UnsupportedManifestValue())
+        )._endpoint(func_name="test"),
+        lambda: options.PubSubOptions(topic=_UnsupportedManifestValue())._endpoint(
+            func_name="test"
+        ),
+        lambda: options.FirebaseAlertOptions(alert_type=_UnsupportedManifestValue())._endpoint(
+            func_name="test"
+        ),
+        lambda: options.AppDistributionOptions(app_id=_UnsupportedManifestValue())._endpoint(
+            func_name="test",
+            alert_type=options.AlertType.APP_DISTRIBUTION_NEW_TESTER_IOS_DEVICE,
+        ),
+        lambda: options.PerformanceOptions(app_id=_UnsupportedManifestValue())._endpoint(
+            func_name="test",
+            alert_type=options.AlertType.PERFORMANCE_THRESHOLD,
+        ),
+        lambda: options.CrashlyticsOptions(app_id=_UnsupportedManifestValue())._endpoint(
+            func_name="test",
+            alert_type=options.AlertType.CRASHLYTICS_NEW_FATAL_ISSUE,
+        ),
+        lambda: options.BillingOptions()._endpoint(
+            func_name="test",
+            alert_type=_UnsupportedManifestValue(),
+        ),
+        lambda: options.EventarcTriggerOptions(
+            event_type="firebase.extensions.storage-resize-images.v1.complete",
+            filters={"subject": _UnsupportedManifestValue()},
+        )._endpoint(func_name="test"),
+        lambda: options.ScheduleOptions(schedule=_UnsupportedManifestValue())._endpoint(
+            func_name="test"
+        ),
+        lambda: options.StorageOptions(bucket=_UnsupportedManifestValue())._endpoint(
+            func_name="test",
+            event_type="google.cloud.storage.object.v1.finalized",
+        ),
+        lambda: options.DatabaseOptions(reference="/foo/{bar}")._endpoint(
+            func_name="test",
+            event_type="google.firebase.database.ref.v1.written",
+            instance_pattern=_FakePattern(_UnsupportedManifestValue()),
+        ),
+        lambda: options.BlockingOptions(id_token=_UnsupportedManifestValue())._endpoint(
+            func_name="test",
+            event_type="providers/cloud.auth/eventTypes/user.beforeSignIn",
+        ),
+        lambda: options.FirestoreOptions(document="foo/{bar}")._endpoint(
+            func_name="test",
+            event_type="google.cloud.firestore.document.v1.written",
+            document_pattern=_FakePattern(_UnsupportedManifestValue(), has_wildcards=True),
+        ),
+        lambda: options.HttpsOptions(invoker=[_UnsupportedManifestValue()])._endpoint(
+            func_name="test"
+        ),
+        lambda: options.HttpsOptions(labels={"broken": _UnsupportedManifestValue()})._endpoint(
+            func_name="test",
+            callable=True,
+        ),
+        lambda: options.DataConnectOptions(service="service")._endpoint(
+            func_name="test",
+            event_type="google.firebase.dataconnect.connector.v1.mutationExecuted",
+            service_pattern=_FakePattern(_UnsupportedManifestValue()),
+            connector_pattern=_FakePattern("connector"),
+            operation_pattern=_FakePattern("operation"),
+        ),
+    ],
+    ids=[
+        "runtime",
+        "event_handler",
+        "task_queue",
+        "pubsub",
+        "firebase_alert",
+        "app_distribution",
+        "performance",
+        "crashlytics",
+        "billing",
+        "eventarc",
+        "schedule",
+        "storage",
+        "database",
+        "blocking",
+        "firestore",
+        "https",
+        "callable_https",
+        "dataconnect",
+    ],
+)
+def test_manifest_to_spec_rejects_unsupported_values_across_option_types(builder):
+    _assert_option_builder_type_error(builder)