firebase-functions 0.4.2__tar.gz → 0.4.3__tar.gz

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: firebase_functions
-Version: 0.4.2
+Version: 0.4.3
 Summary: Firebase Functions Python SDK
 Home-page: https://github.com/firebase/firebase-functions-python
 Author: Firebase Team

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/README.md

@@ -10,12 +10,12 @@ Learn more about the Firebase SDK for Cloud Functions in the [Firebase documenta
 
 Here are some resources to get help:
 
-- Start with the quickstart: https://firebase.google.com/docs/functions/get-started
-- Go through the guide: https://firebase.google.com/docs/functions/
-- Read the full API reference: https://firebase.google.com/docs/reference/functions/2nd-gen/python
-- Browse some examples: https://github.com/firebase/functions-samples
+- Start with the quickstart: <https://firebase.google.com/docs/functions/get-started>
+- Go through the guide: <https://firebase.google.com/docs/functions/>
+- Read the full API reference: <https://firebase.google.com/docs/reference/functions/2nd-gen/python>
+- Browse some examples: <https://github.com/firebase/functions-samples>
 
-If the official documentation doesn't help, try asking through our official support channels: https://firebase.google.com/support/
+If the official documentation doesn't help, try asking through our official support channels: <https://firebase.google.com/support/>
 
 ## Usage
 
@@ -36,4 +36,5 @@ To contribute a change, [check out the contributing guide](.github/CONTRIBUTING.
 
 ## License
 
-© Google, 2023. Licensed under [Apache License](LICENSE).
+© Google, 2025. Licensed under [Apache License](LICENSE).
+

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/setup.py

@@ -19,8 +19,8 @@ from setuptools import find_packages, setup
 
 install_requires = [
     'flask>=2.1.2', 'functions-framework>=3.0.0', 'firebase-admin>=6.0.0',
-    'pyyaml>=6.0', 'typing-extensions>=4.4.0', 'cloudevents==1.9.0',
-    'flask-cors>=3.0.10', 'pyjwt[crypto]>=2.5.0', 'google-events>=0.5.0',
+    'pyyaml>=6.0', 'typing-extensions>=4.4.0', 'cloudevents>=1.2.0,<2.0.0',
+    'flask-cors>=3.0.10', 'pyjwt[crypto]>=2.5.0', 'google-events==0.5.0',
     'google-cloud-firestore>=2.11.0'
 ]
 

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/__init__.py

@@ -1,4 +1,4 @@
-# Copyright 2022 Google Inc.
+# Copyright 2025 Google Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
@@ -15,4 +15,4 @@
 Firebase Functions for Python.
 """
 
-__version__ = "0.4.2"
+__version__ = "0.4.3"

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/firestore_fn.py

@@ -169,13 +169,18 @@ def _firestore_endpoint_handler(
             firestore_event_data.old_value.create_time,
             firestore_event_data.old_value.update_time,
         )
-    if event_type == _event_type_deleted:
+
+    if event_type in (_event_type_deleted,
+                      _event_type_deleted_with_auth_context):
         firestore_event_data = _typing.cast(_firestore.DocumentEventData,
                                             old_value_snapshot)
-    if event_type == _event_type_created:
+    if event_type in (_event_type_created,
+                      _event_type_created_with_auth_context):
         firestore_event_data = _typing.cast(_firestore.DocumentEventData,
                                             value_snapshot)
-    if event_type in (_event_type_written, _event_type_updated):
+    if event_type in (_event_type_written, _event_type_updated,
+                      _event_type_written_with_auth_context,
+                      _event_type_updated_with_auth_context):
         firestore_event_data = _typing.cast(
             _firestore.DocumentEventData,
             Change(
@@ -306,7 +311,7 @@ def on_document_written_with_auth_context(**kwargs
         _util.set_func_endpoint_attr(
             on_document_written_with_auth_context_wrapped,
             options._endpoint(
-                event_type=_event_type_written,
+                event_type=_event_type_written_with_auth_context,
                 func_name=func.__name__,
                 document_pattern=document_pattern,
             ),

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/identity_fn.py

@@ -18,6 +18,7 @@ import typing as _typing
 import functools as _functools
 import datetime as _dt
 import dataclasses as _dataclasses
+from enum import Enum
 
 import firebase_functions.options as _options
 import firebase_functions.private.util as _util
@@ -238,17 +239,23 @@ class Credential:
     """The user's sign-in method."""
 
 
+class EmailType(str, Enum):
+    EMAIL_SIGN_IN = "EMAIL_SIGN_IN"
+    PASSWORD_RESET = "PASSWORD_RESET"
+
+
+class SmsType(str, Enum):
+    SIGN_IN_OR_SIGN_UP = "SIGN_IN_OR_SIGN_UP"
+    MULTI_FACTOR_SIGN_IN = "MULTI_FACTOR_SIGN_IN"
+    MULTI_FACTOR_ENROLLMENT = "MULTI_FACTOR_ENROLLMENT"
+
+
 @_dataclasses.dataclass(frozen=True)
 class AuthBlockingEvent:
     """
     Defines an auth event for identitytoolkit v2 auth blocking events.
     """
 
-    data: AuthUserRecord
-    """
-    The UserRecord passed to auth blocking functions from the identity platform.
-    """
-
     locale: str | None
     """
     The application locale. You can set the locale using the client SDK,
@@ -262,6 +269,13 @@ class AuthBlockingEvent:
     Example: 'rWsyPtolplG2TBFoOkkgyg'
     """
 
+    event_type: str
+    """
+    The event type. This provides information on the event name, such as
+    beforeSignIn or beforeCreate, and the associated sign-in method used,
+    like Google or email/password.
+    """
+
     ip_address: str
     """
     The IP address of the device the end user is registering or signing in from.
@@ -280,10 +294,21 @@ class AuthBlockingEvent:
     credential: Credential | None
     """An object containing information about the user's credential."""
 
+    email_type: EmailType | None
+    """The type of email event."""
+
+    sms_type: SmsType | None
+    """The type of SMS event."""
+
     timestamp: _dt.datetime
     """
     The time the event was triggered."""
 
+    data: AuthUserRecord
+    """
+    The UserRecord passed to auth blocking functions from the identity platform.
+    """
+
 
 RecaptchaActionOptions = _typing.Literal["ALLOW", "BLOCK"]
 """

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/logger.py

@@ -8,6 +8,12 @@ import sys as _sys
 import typing as _typing
 import typing_extensions as _typing_extensions
 
+# If encoding is not 'utf-8', change it to 'utf-8'.
+if _sys.stdout.encoding != "utf-8":
+    _sys.stdout.reconfigure(encoding="utf-8")  # type: ignore
+if _sys.stderr.encoding != "utf-8":
+    _sys.stderr.reconfigure(encoding="utf-8")  # type: ignore
+
 
 class LogSeverity(str, _enum.Enum):
     """
@@ -69,21 +75,32 @@ def _remove_circular(obj: _typing.Any,
     if refs is None:
         refs = set()
 
+    # Check if the object is already in the current recursion stack
     if id(obj) in refs:
         return "[CIRCULAR]"
 
+    # For non-primitive objects, add the current object's id to the recursion stack
     if not isinstance(obj, (str, int, float, bool, type(None))):
         refs.add(id(obj))
 
+    # Recursively process the object based on its type
+    result: _typing.Any
     if isinstance(obj, dict):
-        return {key: _remove_circular(value, refs) for key, value in obj.items()}
+        result = {
+            key: _remove_circular(value, refs) for key, value in obj.items()
+        }
     elif isinstance(obj, list):
-        return [_remove_circular(value, refs) for _, value in enumerate(obj)]
+        result = [_remove_circular(item, refs) for item in obj]
     elif isinstance(obj, tuple):
-        return tuple(
-            _remove_circular(value, refs) for _, value in enumerate(obj))
+        result = tuple(_remove_circular(item, refs) for item in obj)
     else:
-        return obj
+        result = obj
+
+    # Remove the object's id from the recursion stack after processing
+    if not isinstance(obj, (str, int, float, bool, type(None))):
+        refs.remove(id(obj))
+
+    return result
 
 
 def _get_write_file(severity: LogSeverity) -> _typing.TextIO:

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/options.py

@@ -1134,7 +1134,7 @@ class HttpsOptions(RuntimeOptions):
                     invoker = [invoker]
                 assert len(
                     invoker
-                ) > 1, "HttpsOptions: Invalid option for invoker - must be a non-empty list."
+                ) >= 1, "HttpsOptions: Invalid option for invoker - must be a non-empty list."
                 assert "" not in invoker, (
                     "HttpsOptions: Invalid option for invoker - must be a non-empty string."
                 )

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/params.py

@@ -344,8 +344,12 @@ class IntParam(Param[int]):
 
 
 @_dataclasses.dataclass(frozen=True)
-class FloatParam(Param[float]):
-    """A parameter as a float value."""
+class _FloatParam(Param[float]):
+    """
+    A parameter as a float value.
+    Marked as private because it is not supported by firebase-tools yet.
+    Unmark when it is supported.
+    """
 
     @property
     def value(self) -> float:

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/private/_identity_fn.py

@@ -200,17 +200,21 @@ def _credential_from_token_data(token_data: dict[str, _typing.Any],
     )
 
 
-def _auth_blocking_event_from_token_data(token_data: dict[str, _typing.Any]):
+def _auth_blocking_event_from_token_data(event_type: str,
+                                         token_data: dict[str, _typing.Any]):
     from firebase_functions.identity_fn import AuthBlockingEvent
     return AuthBlockingEvent(
         data=_auth_user_record_from_token_data(token_data["user_record"]),
         locale=token_data.get("locale"),
+        event_type=event_type,
         event_id=token_data["event_id"],
         ip_address=token_data["ip_address"],
         user_agent=token_data["user_agent"],
         timestamp=_dt.datetime.fromtimestamp(token_data["iat"]),
         additional_user_info=_additional_user_info_from_token_data(token_data),
         credential=_credential_from_token_data(token_data, _time.time()),
+        email_type=token_data.get("email_type"),
+        sms_type=token_data.get("sms_type"),
     )
 
 
@@ -351,7 +355,7 @@ def before_operation_handler(
             raise HttpsError(FunctionsErrorCode.INVALID_ARGUMENT, "Bad Request")
         jwt_token = request.json["data"]["jwt"]
         decoded_token = _token_verifier.verify_auth_blocking_token(jwt_token)
-        event = _auth_blocking_event_from_token_data(decoded_token)
+        event = _auth_blocking_event_from_token_data(event_type, decoded_token)
         auth_response: BeforeCreateResponse | BeforeSignInResponse | None = _with_init(
             func)(event)
         if not auth_response:

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions/private/manifest.py

@@ -241,7 +241,7 @@ def _param_to_spec(
         spec_dict["type"] = "boolean"
     elif isinstance(param, _params.IntParam):
         spec_dict["type"] = "int"
-    elif isinstance(param, _params.FloatParam):
+    elif isinstance(param, _params._FloatParam):
         spec_dict["type"] = "float"
     elif isinstance(param, _params.SecretParam):
         spec_dict["type"] = "secret"

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: firebase-functions
-Version: 0.4.2
+Version: 0.4.3
 Summary: Firebase Functions Python SDK
 Home-page: https://github.com/firebase/firebase-functions-python
 Author: Firebase Team

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/src/firebase_functions.egg-info/requires.txt

@@ -3,10 +3,10 @@ functions-framework>=3.0.0
 firebase-admin>=6.0.0
 pyyaml>=6.0
 typing-extensions>=4.4.0
-cloudevents==1.9.0
+cloudevents<2.0.0,>=1.2.0
 flask-cors>=3.0.10
 pyjwt[crypto]>=2.5.0
-google-events>=0.5.0
+google-events==0.5.0
 google-cloud-firestore>=2.11.0
 
 [dev]

firebase_functions-0.4.3/tests/test_logger.py

@@ -0,0 +1,226 @@
+# mypy: ignore-errors
+"""
+Logger module tests.
+"""
+
+import pytest
+import json
+from firebase_functions import logger
+
+
+class TestLogger:
+    """
+    Tests for the logger module.
+    """
+
+    def test_format_should_be_valid_json(self,
+                                         capsys: pytest.CaptureFixture[str]):
+        logger.log(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        try:
+            json.loads(raw_log_output)
+        except json.JSONDecodeError:
+            pytest.fail("Log output was not valid JSON.")
+
+    def test_log_should_have_severity(self, capsys: pytest.CaptureFixture[str]):
+        logger.log(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert "severity" in log_output
+
+    def test_severity_should_be_debug(self, capsys: pytest.CaptureFixture[str]):
+        logger.debug(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert log_output["severity"] == "DEBUG"
+
+    def test_severity_should_be_notice(self,
+                                       capsys: pytest.CaptureFixture[str]):
+        logger.log(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert log_output["severity"] == "NOTICE"
+
+    def test_severity_should_be_info(self, capsys: pytest.CaptureFixture[str]):
+        logger.info(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert log_output["severity"] == "INFO"
+
+    def test_severity_should_be_warning(self,
+                                        capsys: pytest.CaptureFixture[str]):
+        logger.warn(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert log_output["severity"] == "WARNING"
+
+    def test_severity_should_be_error(self, capsys: pytest.CaptureFixture[str]):
+        logger.error(foo="bar")
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+        assert log_output["severity"] == "ERROR"
+
+    def test_log_should_have_message(self, capsys: pytest.CaptureFixture[str]):
+        logger.log("bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert "message" in log_output
+
+    def test_log_should_have_other_keys(self,
+                                        capsys: pytest.CaptureFixture[str]):
+        logger.log(foo="bar")
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert "foo" in log_output
+
+    def test_message_should_be_space_separated(
+            self, capsys: pytest.CaptureFixture[str]):
+        logger.log("bar", "qux")
+        expected_message = "bar qux"
+        raw_log_output = capsys.readouterr().out
+        log_output = json.loads(raw_log_output)
+        assert log_output["message"] == expected_message
+
+    def test_remove_circular_references(self,
+                                        capsys: pytest.CaptureFixture[str]):
+        # Create an object with a circular reference.
+        circ = {"b": "foo"}
+        circ["circ"] = circ
+
+        entry = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "circ": circ,
+        }
+        logger.write(entry)
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        expected = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "circ": {
+                "b": "foo",
+                "circ": "[CIRCULAR]"
+            },
+        }
+        assert log_output == expected
+
+    def test_remove_circular_references_in_arrays(
+            self, capsys: pytest.CaptureFixture[str]):
+        # Create an object with a circular reference inside an array.
+        circ = {"b": "foo"}
+        circ["circ"] = [circ]
+
+        entry = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "circ": circ,
+        }
+        logger.write(entry)
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        expected = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "circ": {
+                "b": "foo",
+                "circ": ["[CIRCULAR]"]
+            },
+        }
+        assert log_output == expected
+
+    def test_no_false_circular_for_duplicates(
+            self, capsys: pytest.CaptureFixture[str]):
+        # Ensure that duplicate objects (used in multiple keys) are not marked as circular.
+        obj = {"a": "foo"}
+        entry = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "a": obj,
+            "b": obj,
+        }
+        logger.write(entry)
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        expected = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "a": {
+                "a": "foo"
+            },
+            "b": {
+                "a": "foo"
+            },
+        }
+        assert log_output == expected
+
+    def test_no_false_circular_in_array_duplicates(
+            self, capsys: pytest.CaptureFixture[str]):
+        # Ensure that duplicate objects in arrays are not falsely detected as circular.
+        obj = {"a": "foo"}
+        arr = [
+            {
+                "a": obj,
+                "b": obj
+            },
+            {
+                "a": obj,
+                "b": obj
+            },
+        ]
+        entry = {
+            "severity": "ERROR",
+            "message": "testing circular",
+            "a": arr,
+            "b": arr,
+        }
+        logger.write(entry)
+        raw_log_output = capsys.readouterr().err
+        log_output = json.loads(raw_log_output)
+
+        expected = {
+            "severity":
+                "ERROR",
+            "message":
+                "testing circular",
+            "a": [
+                {
+                    "a": {
+                        "a": "foo"
+                    },
+                    "b": {
+                        "a": "foo"
+                    }
+                },
+                {
+                    "a": {
+                        "a": "foo"
+                    },
+                    "b": {
+                        "a": "foo"
+                    }
+                },
+            ],
+            "b": [
+                {
+                    "a": {
+                        "a": "foo"
+                    },
+                    "b": {
+                        "a": "foo"
+                    }
+                },
+                {
+                    "a": {
+                        "a": "foo"
+                    },
+                    "b": {
+                        "a": "foo"
+                    }
+                },
+            ],
+        }
+        assert log_output == expected

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/tests/test_manifest.py

@@ -65,7 +65,7 @@ full_stack = _manifest.ManifestStack(
     params=[
         _params.BoolParam("BOOL_TEST", default=False),
         _params.IntParam("INT_TEST", description="int_description"),
-        _params.FloatParam("FLOAT_TEST", immutable=True),
+        _params._FloatParam("FLOAT_TEST", immutable=True),
         _params.SecretParam("SECRET_TEST"),
         _params.StringParam("STRING_TEST"),
         _params.ListParam("LIST_TEST", default=["1", "2", "3"]),

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/tests/test_options.py

@@ -17,6 +17,7 @@ Options unit tests.
 from firebase_functions import options, https_fn
 from firebase_functions import params
 from firebase_functions.private.serving import functions_as_yaml, merge_required_apis
+from pytest import raises
 # pylint: disable=protected-access
 
 
@@ -44,7 +45,7 @@ def test_global_options_merged_with_provider_options():
     Testing a global option is used when no provider option is set.
     """
     options.set_global_options(max_instances=66)
-    pubsub_options = options.PubSubOptions(topic="foo")  #pylint: disable=unexpected-keyword-arg
+    pubsub_options = options.PubSubOptions(topic="foo")  # pylint: disable=unexpected-keyword-arg
     pubsub_options_dict = pubsub_options._asdict_with_global_options()
     assert (pubsub_options_dict["topic"] == "foo"
            ), "'topic' property missing from dict"
@@ -170,7 +171,7 @@ def test_merge_apis_duplicate_apis():
     This test evaluates the merge_required_apis function when the
     input list contains duplicate APIs with different reasons.
     The desired outcome for this test is a list where the duplicate
-    APIs are merged properly and reasons are combined. 
+    APIs are merged properly and reasons are combined.
     This test ensures that the function correctly merges the duplicate
     APIs and combines the reasons associated with them.
     """
@@ -217,3 +218,16 @@ def test_merge_apis_duplicate_apis():
     for actual_item in merged_apis:
         assert (actual_item in expected_output
                ), f"Unexpected item {actual_item} found in the merged list"
+
+
+def test_invoker_with_one_element_doesnt_throw():
+    options.HttpsOptions(invoker=["public"])._endpoint(func_name="test")
+
+
+def test_invoker_with_no_element_throws():
+    with raises(
+            AssertionError,
+            match=
+            "HttpsOptions: Invalid option for invoker - must be a non-empty list."
+    ):
+        options.HttpsOptions(invoker=[])._endpoint(func_name="test")

{firebase_functions-0.4.2 → firebase_functions-0.4.3}/tests/test_params.py

@@ -58,28 +58,28 @@ class TestFloatParams:
     def test_float_param_value(self):
         """Testing if float params correctly returns a value."""
         environ["FLOAT_VALUE_TEST"] = "123.456"
-        assert params.FloatParam("FLOAT_VALUE_TEST",).value == 123.456, \
+        assert params._FloatParam("FLOAT_VALUE_TEST",).value == 123.456, \
             "Failure, params value != 123.456"
 
     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_TEST1").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_TEST2",
+        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_TEST1",
-                                  default=123.456).equals(123.456).value
-                is True), "Failure, equality check returned False"
-        assert (params.FloatParam("FLOAT_TEST2",
-                                  default=456.789).equals(123.456).value
-                is False), "Failure, equality check returned False"
+        assert (params._FloatParam("FLOAT_TEST1", \
+        default=123.456).equals(123.456).value \
+            is True), "Failure, equality check returned False"
+        assert (params._FloatParam("FLOAT_TEST2", \
+        default=456.789).equals(123.456).value \
+            is False), "Failure, equality check returned False"
 
 
 class TestIntParams:

firebase_functions-0.4.2/tests/test_logger.py

@@ -1,81 +0,0 @@
-"""
-Logger module tests.
-"""
-
-import pytest
-import json
-from firebase_functions import logger
-
-
-class TestLogger:
-    """
-    Tests for the logger module.
-    """
-
-    def test_format_should_be_valid_json(self,
-                                         capsys: pytest.CaptureFixture[str]):
-        logger.log(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        try:
-            json.loads(raw_log_output)
-        except json.JSONDecodeError:
-            pytest.fail("Log output was not valid JSON.")
-
-    def test_log_should_have_severity(self, capsys: pytest.CaptureFixture[str]):
-        logger.log(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert "severity" in log_output
-
-    def test_severity_should_be_debug(self, capsys: pytest.CaptureFixture[str]):
-        logger.debug(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert log_output["severity"] == "DEBUG"
-
-    def test_severity_should_be_notice(self,
-                                       capsys: pytest.CaptureFixture[str]):
-        logger.log(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert log_output["severity"] == "NOTICE"
-
-    def test_severity_should_be_info(self, capsys: pytest.CaptureFixture[str]):
-        logger.info(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert log_output["severity"] == "INFO"
-
-    def test_severity_should_be_warning(self,
-                                        capsys: pytest.CaptureFixture[str]):
-        logger.warn(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert log_output["severity"] == "WARNING"
-
-    def test_severity_should_be_error(self, capsys: pytest.CaptureFixture[str]):
-        logger.error(foo="bar")
-        raw_log_output = capsys.readouterr().err
-        log_output = json.loads(raw_log_output)
-        assert log_output["severity"] == "ERROR"
-
-    def test_log_should_have_message(self, capsys: pytest.CaptureFixture[str]):
-        logger.log("bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert "message" in log_output
-
-    def test_log_should_have_other_keys(self,
-                                        capsys: pytest.CaptureFixture[str]):
-        logger.log(foo="bar")
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert "foo" in log_output
-
-    def test_message_should_be_space_separated(
-            self, capsys: pytest.CaptureFixture[str]):
-        logger.log("bar", "qux")
-        expected_message = "bar qux"
-        raw_log_output = capsys.readouterr().out
-        log_output = json.loads(raw_log_output)
-        assert log_output["message"] == expected_message