Merge pull request #10 from invertase/params-list-manifest

fix: user params should now show on manifest params list

Author: taeold

example/functions/main.py

@@ -1,14 +1,15 @@
 """
 Example Firebase Functions written in Python
 """
-from firebase_functions import db, options, https
+from firebase_functions import db, options, https, params
 from firebase_admin import initialize_app
 
 initialize_app()
 
 options.set_global_options(
     region=options.SupportedRegion.EUROPE_WEST1,
     memory=options.MemoryOption.MB_128,
+    min_instances=params.IntParam("MIN", default=3),
 )
 
 

src/firebase_functions/params.py

@@ -47,6 +47,9 @@ def _quote_if_string(literal: _T) -> _T:
     return literal if not isinstance(literal, str) else f'"{literal}"'
 
 
+_params: dict[str, Expression] = {}
+
+
 @_dataclasses.dataclass(frozen=True)
 class TernaryExpression(Expression[_T], _typing.Generic[_T]):
     test: Expression[bool]
@@ -210,6 +213,11 @@ def __post_init__(self):
             raise ValueError(
                 "Parameter names must only use uppercase letters, numbers and "
                 "underscores, e.g. 'UPPER_SNAKE_CASE'.")
+        if self.name in _params:
+            raise ValueError(
+                f"Duplicate Parameter Error: The parameter '{self.name}' has already been declared."
+            )
+        _params[self.name] = self
 
 
 @_dataclasses.dataclass(frozen=True)
@@ -247,6 +255,11 @@ def __post_init__(self):
             raise ValueError(
                 "Parameter names must only use uppercase letters, numbers and "
                 "underscores, e.g. 'UPPER_SNAKE_CASE'.")
+        if self.name in _params:
+            raise ValueError(
+                f"Duplicate Parameter Error: The parameter '{self.name}' has already been declared."
+            )
+        _params[self.name] = self
 
     def value(self) -> str:
         """Current value of this parameter."""

src/firebase_functions/private/manifest.py

@@ -11,8 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
-
 """Specs for the served functions.yaml of the user's functions"""
 
 # We're ignoring pylint's warning about names since we want
@@ -130,10 +128,8 @@ class ManifestRequiredApi(_typing.TypedDict):
 class ManifestStack:
     endpoints: dict[str, ManifestEndpoint]
     specVersion: str = "v1alpha1"
-    params: _typing.Optional[list[_params.Param |
-                                  _params.SecretParam]] = _dataclasses.field(
-                                      default_factory=list[_params.Param |
-                                                           _params.SecretParam])
+    params: list[_typing.Any] | None = _dataclasses.field(
+        default_factory=list[_typing.Any])
     requiredAPIs: list[ManifestRequiredApi] = _dataclasses.field(
         default_factory=list[ManifestRequiredApi])
 

src/firebase_functions/private/serving.py

@@ -11,8 +11,6 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
-
 """
 Module used to serve Firebase functions locally and remotely.
 """
@@ -29,6 +27,7 @@
 from flask import Response
 
 from firebase_functions.private import manifest as _manifest
+from firebase_functions import params as _params
 from firebase_functions.private import util as _util
 
 
@@ -72,8 +71,9 @@ def functions_as_yaml(functions: dict) -> str:
         endpoint = function.__firebase_endpoint__
         # v2 function name(s) can only contain lower case letters, numbers, hyphens
         endpoints[name.replace("_", "-").lower()] = endpoint
-
-    manifest_stack = _manifest.ManifestStack(endpoints=endpoints)
+    manifest_stack = _manifest.ManifestStack(endpoints=endpoints,
+                                             params=list(
+                                                 _params._params.values()))
     manifest_spec = _manifest.manifest_to_spec_dict(manifest_stack)
     manifest_spec_with_sentinels = to_spec(manifest_spec)
 

tests/test_manifest.py

@@ -132,21 +132,22 @@ def test_endpoint_to_dict(self):
 
     def test_endpoint_expressions(self):
         """Check Expression values convert to CEL strings."""
+        max_param = _params.IntParam("MAX")
         expressions_test = _manifest.ManifestEndpoint(
             availableMemoryMb=_params.TernaryExpression(
-                _params.BoolParam("LARGE"), 1024, 256),
-            minInstances=_params.StringParam("LARGE").equals("yes").then(6, 1),
-            maxInstances=_params.IntParam("MAX").compare(">", 6).then(
-                6, _params.IntParam("MAX")),
+                _params.BoolParam("LARGE_BOOL"), 1024, 256),
+            minInstances=_params.StringParam("LARGE_STR").equals("yes").then(
+                6, 1),
+            maxInstances=max_param.compare(">", 6).then(6, max_param),
             timeoutSeconds=_params.IntParam("WORLD"),
             concurrency=_params.IntParam("BAR"),
             vpc={"connector": _params.SecretParam("SECRET")})
         expressions_expected_dict = {
             "platform": "gcfv2",
             "region": [],
             "secretEnvironmentVariables": [],
-            "availableMemoryMb": "{{ params.LARGE ? 1024 : 256 }}",
-            "minInstances": "{{ params.LARGE == \"yes\" ? 6 : 1 }}",
+            "availableMemoryMb": "{{ params.LARGE_BOOL ? 1024 : 256 }}",
+            "minInstances": "{{ params.LARGE_STR == \"yes\" ? 6 : 1 }}",
             "maxInstances": "{{ params.MAX > 6 ? 6 : params.MAX }}",
             "timeoutSeconds": "{{ params.WORLD }}",
             "concurrency": "{{ params.BAR }}",

tests/test_params.py

@@ -23,20 +23,21 @@ class TestBoolParams:
 
     def test_bool_param_value_true_or_false(self):
         """Testing if bool params correctly returns a true or false value."""
+        bool_param = params.BoolParam("BOOL_VALUE_TEST1")
         for value_true, value_false in zip(["true", "t", "1", "y", "yes"],
                                            ["false", "f", "0", "n", "no"]):
-            environ["BOOL_VALUE_TEST"] = value_true
-            assert (params.BoolParam("BOOL_VALUE_TEST").value() is
+            environ["BOOL_VALUE_TEST1"] = value_true
+            assert (bool_param.value() is
                     True), "Failure, params returned False"
-            environ["BOOL_VALUE_TEST"] = value_false
-            assert (params.BoolParam("BOOL_VALUE_TEST").value() is
+            environ["BOOL_VALUE_TEST1"] = value_false
+            assert (bool_param.value() is
                     False), "Failure, params returned True"
 
     def test_bool_param_value_error(self):
         """Testing if bool params throws a value error if invalid value."""
         with pytest.raises(ValueError):
-            environ["BOOL_VALUE_TEST"] = "bad_value"
-            params.BoolParam("BOOL_VALUE_TEST").value()
+            environ["BOOL_VALUE_TEST2"] = "bad_value"
+            params.BoolParam("BOOL_VALUE_TEST2").value()
 
     def test_bool_param_empty_default(self):
         """Testing if bool params defaults to False if no value and no default."""
@@ -45,17 +46,19 @@ def test_bool_param_empty_default(self):
 
     def test_bool_param_default(self):
         """Testing if bool params defaults to provided default value."""
-        assert (params.BoolParam("BOOL_DEFAULT_TEST", default=False).value() is
+        assert (params.BoolParam("BOOL_DEFAULT_TEST_FALSE",
+                                 default=False).value() is
                 False), "Failure, params returned True"
-        assert (params.BoolParam("BOOL_DEFAULT_TEST", default=True).value() is
+        assert (params.BoolParam("BOOL_DEFAULT_TEST_TRUE",
+                                 default=True).value() is
                 True), "Failure, params returned False"
 
     def test_bool_param_equality(self):
         """Test bool equality."""
-        assert (params.BoolParam("BOOL_TEST",
+        assert (params.BoolParam("BOOL_TEST1",
                                  default=False).equals(False).value() is
                 True), "Failure, equality check returned False"
-        assert (params.BoolParam("BOOL_TEST",
+        assert (params.BoolParam("BOOL_TEST2",
                                  default=True).equals(False).value() is
                 False), "Failure, equality check returned False"
 
@@ -71,20 +74,21 @@ def test_float_param_value(self):
 
     def test_float_param_empty_default(self):
         """Testing if float params defaults to empty float if no value and no default."""
-        assert params.FloatParam("FLOAT_DEFAULT_TEST").value() == float(), \
+        assert params.FloatParam("FLOAT_DEFAULT_TEST1").value() == float(), \
             "Failure, params value is not float"
 
     def test_float_param_default(self):
         """Testing if float param defaults to provided default value."""
-        assert params.FloatParam("FLOAT_DEFAULT_TEST", default=float(456.789)).value() == 456.789, \
+        assert params.FloatParam("FLOAT_DEFAULT_TEST2",
+        default=float(456.789)).value() == 456.789, \
             "Failure, params default value != 456.789"
 
     def test_float_param_equality(self):
         """Test float equality."""
-        assert (params.FloatParam("FLOAT_TEST",
+        assert (params.FloatParam("FLOAT_TEST1",
                                   default=123.456).equals(123.456).value() is
                 True), "Failure, equality check returned False"
-        assert (params.FloatParam("FLOAT_TEST",
+        assert (params.FloatParam("FLOAT_TEST2",
                                   default=456.789).equals(123.456).value() is
                 False), "Failure, equality check returned False"
 
@@ -100,19 +104,19 @@ def test_int_param_value(self):
 
     def test_int_param_empty_default(self):
         """Testing if int param defaults to empty int if no value and no default."""
-        assert params.IntParam("INT_DEFAULT_TEST").value() == int(
+        assert params.IntParam("INT_DEFAULT_TEST1").value() == int(
         ), "Failure, params value is not int"
 
     def test_int_param_default(self):
         """Testing if int param defaults to provided default value."""
-        assert params.IntParam("INT_DEFAULT_TEST", default=456).value() == 456, \
+        assert params.IntParam("INT_DEFAULT_TEST2", default=456).value() == 456, \
             "Failure, params default value != 456"
 
     def test_int_param_equality(self):
         """Test int equality."""
-        assert (params.IntParam("INT_TEST", default=123).equals(123).value() is
+        assert (params.IntParam("INT_TEST1", default=123).equals(123).value() is
                 True), "Failure, equality check returned False"
-        assert (params.IntParam("INT_TEST", default=456).equals(123).value() is
+        assert (params.IntParam("INT_TEST2", default=456).equals(123).value() is
                 False), "Failure, equality check returned False"
 
 
@@ -133,21 +137,22 @@ def test_param_name_upper_snake_case(self):
 
     def test_string_param_empty_default(self):
         """Testing if string param defaults to empty string if no value and no default."""
-        assert params.StringParam("STRING_DEFAULT_TEST").value() == str(), \
+        assert params.StringParam("STRING_DEFAULT_TEST1").value() == str(), \
             "Failure, params value is not a string"
 
     def test_string_param_default(self):
         """Testing if string param defaults to provided default value."""
-        assert (params.StringParam("STRING_DEFAULT_TEST", default="string_override_default").value()
+        assert (params.StringParam("STRING_DEFAULT_TEST2",
+        default="string_override_default").value()
                 == "string_override_default"), \
             'Failure, params default value != "string_override_default"'
 
     def test_string_param_equality(self):
         """Test string equality."""
-        assert (params.StringParam("STRING_TEST",
+        assert (params.StringParam("STRING_TEST1",
                                    default="123").equals("123").value() is
                 True), "Failure, equality check returned False"
-        assert (params.StringParam("STRING_TEST",
+        assert (params.StringParam("STRING_TEST2",
                                    default="456").equals("123").value() is
                 False), "Failure, equality check returned False"
 
@@ -157,30 +162,30 @@ class TestListParams:
 
     def test_list_param_value(self):
         """Testing if list param correctly returns list values."""
-        environ["LIST_VALUE_TEST"] = "item1,item2"
-        assert params.ListParam("LIST_VALUE_TEST").value() == ["item1","item2"], \
+        environ["LIST_VALUE_TEST1"] = "item1,item2"
+        assert params.ListParam("LIST_VALUE_TEST1").value() == ["item1","item2"], \
             'Failure, params value != ["item1","item2"]'
 
     def test_list_param_filter_empty_strings(self):
         """Testing if list param correctly returns list values wth empty strings excluded."""
-        environ["LIST_VALUE_TEST"] = ",,item1,item2,,,item3,"
-        assert params.ListParam("LIST_VALUE_TEST").value() == ["item1","item2", "item3"], \
+        environ["LIST_VALUE_TEST2"] = ",,item1,item2,,,item3,"
+        assert params.ListParam("LIST_VALUE_TEST2").value() == ["item1","item2", "item3"], \
             'Failure, params value != ["item1","item2", "item3"]'
 
     def test_list_param_empty_default(self):
         """Testing if list param defaults to an empty list if no value and no default."""
-        assert params.ListParam("LIST_DEFAULT_TEST").value() == [], \
+        assert params.ListParam("LIST_DEFAULT_TEST1").value() == [], \
             "Failure, params value is not an empty list"
 
     def test_list_param_default(self):
         """Testing if list param defaults to the provided default value."""
-        assert (params.ListParam("LIST_DEFAULT_TEST", default=["1", "2"]).value()
+        assert (params.ListParam("LIST_DEFAULT_TEST2", default=["1", "2"]).value()
                 == ["1", "2"]), \
             'Failure, params default value != ["1", "2"]'
 
     def test_list_param_equality(self):
         """Test list equality."""
-        assert (params.ListParam("LIST_TEST", default=["123"]).equals(
+        assert (params.ListParam("LIST_TEST1", default=["123"]).equals(
             ["123"]).value() is True), "Failure, equality check returned False"
-        assert (params.ListParam("LIST_TEST", default=["456"]).equals(
+        assert (params.ListParam("LIST_TEST2", default=["456"]).equals(
             ["123"]).value() is False), "Failure, equality check returned False"