Merge branch 'feat/gapic-centralization-api-core-mtls' into feat/gapic-generator-centralization-mtls

Author: hebaalazzeh

packages/google-api-core/tests/unit/gapic/test_client_cert.py

@@ -18,62 +18,90 @@
 
 import pytest
 
-
+from google.auth.transport import mtls
 from google.api_core.gapic_v1.client_cert import (
     get_client_cert_source,
     use_client_cert_effective,
 )
 
 
-@mock.patch("google.auth.transport.mtls.should_use_client_cert", create=True)
-def test_use_client_cert_effective_with_google_auth(mock_method):
-    # Test when google-auth supports the method
-    mock_method.return_value = True
-    assert use_client_cert_effective() is True
-
-    mock_method.return_value = False
-    assert use_client_cert_effective() is False
-
-
-@mock.patch.dict(os.environ, {}, clear=True)
-def test_use_client_cert_effective_fallback():
-    # We must patch hasattr to simulate google-auth lacking the method
-    with mock.patch("google.api_core.gapic_v1.client_cert.hasattr", return_value=False):
-        # Default is false
-        assert use_client_cert_effective() is False
-
-        env_true = {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "true"}
-        with mock.patch.dict(os.environ, env_true):
-            assert use_client_cert_effective() is True
-
-        with mock.patch.dict(
-            os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "false"}
-        ):
-            assert use_client_cert_effective() is False
-
-        with mock.patch.dict(
-            os.environ, {"GOOGLE_API_USE_CLIENT_CERTIFICATE": "invalid"}
-        ):
-            match_str = "must be either `true` or `false`"
-            with pytest.raises(ValueError, match=match_str):
-                use_client_cert_effective()
-
-
-@mock.patch(
-    "google.auth.transport.mtls.has_default_client_cert_source", create=True
-)  # noqa: E501
-@mock.patch(
-    "google.auth.transport.mtls.default_client_cert_source", create=True
-)  # noqa: E501
-def test_get_client_cert_source(mock_default, mock_has_default):
-    mock_default.return_value = b"default_cert"
-    mock_has_default.return_value = True
-
-    # When use_cert_flag is False, return None
-    assert get_client_cert_source(b"provided", False) is None
-
-    # When provided_cert_source is given, return provided
-    assert get_client_cert_source(b"provided", True) == b"provided"  # noqa: E501
-
-    # When no provided cert but default is available
-    assert get_client_cert_source(None, True) == b"default_cert"
+@pytest.mark.parametrize(
+    "has_method, method_val, env_val, expected",
+    [
+        # should_use_client_cert is available cases
+        (True, True, None, "true"),
+        (True, False, None, "false"),
+        (True, False, "unsupported", "false"),
+        # should_use_client_cert is unavailable cases
+        (False, None, "true", "true"),
+        (False, None, "false", "false"),
+        (False, None, "True", "true"),
+        (False, None, "False", "false"),
+        (False, None, "TRUE", "true"),
+        (False, None, "FALSE", "false"),
+        (False, None, None, "false"),
+        (False, None, "unsupported", "value_error"),
+    ],
+    ids=[
+        "google_auth_true",
+        "google_auth_false",
+        "google_auth_false_env_unsupported",
+        "fallback_env_true_lowercase",
+        "fallback_env_false_lowercase",
+        "fallback_env_true_titlecase",
+        "fallback_env_false_titlecase",
+        "fallback_env_true_uppercase",
+        "fallback_env_false_uppercase",
+        "fallback_env_unset",
+        "fallback_env_unsupported",
+    ]
+)
+def test_use_client_cert_effective(has_method, method_val, env_val, expected):
+    # Mock hasattr to control whether should_use_client_cert exists
+    original_hasattr = hasattr
+    def custom_hasattr(obj, name):
+        if obj is mtls and name == "should_use_client_cert":
+            return has_method
+        return original_hasattr(obj, name)
+
+    with mock.patch("google.api_core.gapic_v1.client_cert.hasattr", custom_hasattr):
+        with mock.patch("google.auth.transport.mtls.should_use_client_cert", create=True, return_value=method_val):
+            env = {}
+            if env_val is not None:
+                env["GOOGLE_API_USE_CLIENT_CERTIFICATE"] = env_val
+            with mock.patch.dict(os.environ, env, clear=True):
+                if expected == "value_error":
+                    with pytest.raises(ValueError, match="must be either `true` or `false`"):
+                        use_client_cert_effective()
+                else:
+                    assert use_client_cert_effective() is (expected == "true")
+
+
+@pytest.mark.parametrize(
+    "provided, use_cert, has_default_avail, default_val, expected",
+    [
+        (None, False, True, b"default", None),
+        (b"provided", False, True, b"default", None),
+        (b"provided", True, True, b"default", b"provided"),
+        (None, True, True, b"default", b"default"),
+        (None, True, False, b"default", None),
+    ],
+    ids=[
+        "use_cert_false_no_provided",
+        "use_cert_false_with_provided",
+        "use_cert_true_with_provided",
+        "use_cert_true_no_provided_default_avail",
+        "use_cert_true_no_provided_default_unavail",
+    ]
+)
+def test_get_client_cert_source(provided, use_cert, has_default_avail, default_val, expected):
+    original_hasattr = hasattr
+    def custom_hasattr(obj, name):
+        if obj is mtls and name == "has_default_client_cert_source":
+            return has_default_avail
+        return original_hasattr(obj, name)
+
+    with mock.patch("google.api_core.gapic_v1.client_cert.hasattr", custom_hasattr):
+        with mock.patch("google.auth.transport.mtls.has_default_client_cert_source", create=True, return_value=has_default_avail):
+            with mock.patch("google.auth.transport.mtls.default_client_cert_source", create=True, return_value=default_val):
+                assert get_client_cert_source(provided, use_cert) == expected

packages/google-api-core/tests/unit/gapic/test_config_helpers.py

@@ -19,29 +19,35 @@
 import pytest
 
 from google.auth.exceptions import MutualTLSChannelError
-
 from google.api_core.gapic_v1.config_helpers import read_environment_variables
 
 
-@mock.patch(
-    "google.api_core.gapic_v1.config_helpers.use_client_cert_effective"
-)  # noqa: E501
-@mock.patch.dict(os.environ, clear=True)
-def test_read_environment_variables(mock_effective):
-    mock_effective.return_value = True
-    os.environ["GOOGLE_API_USE_MTLS_ENDPOINT"] = "always"
-    os.environ["GOOGLE_CLOUD_UNIVERSE_DOMAIN"] = "custom.com"
-
-    cert, mtls, domain = read_environment_variables()
-    assert cert is True
-    assert mtls == "always"
-    assert domain == "custom.com"
-
-
-@mock.patch.dict(os.environ, clear=True)
-def test_read_environment_variables_invalid_mtls():
-    os.environ["GOOGLE_API_USE_MTLS_ENDPOINT"] = "invalid"
-    with pytest.raises(
-        MutualTLSChannelError, match="must be `never`, `auto` or `always`"
-    ):
-        read_environment_variables()
+@pytest.mark.parametrize(
+    "env, mock_cert_val, expected",
+    [
+        ({}, False, (False, "auto", None)),
+        ({}, True, (True, "auto", None)),
+        ({"GOOGLE_API_USE_MTLS_ENDPOINT": "never"}, False, (False, "never", None)),
+        ({"GOOGLE_API_USE_MTLS_ENDPOINT": "always"}, False, (False, "always", None)),
+        ({"GOOGLE_API_USE_MTLS_ENDPOINT": "auto"}, False, (False, "auto", None)),
+        ({"GOOGLE_API_USE_MTLS_ENDPOINT": "invalid"}, False, "mutual_tls_error"),
+        ({"GOOGLE_CLOUD_UNIVERSE_DOMAIN": "foo.com"}, False, (False, "auto", "foo.com")),
+    ],
+    ids=[
+        "default_env",
+        "client_cert_true",
+        "mtls_never",
+        "mtls_always",
+        "mtls_auto",
+        "mtls_invalid",
+        "universe_domain",
+    ]
+)
+def test_read_environment_variables(env, mock_cert_val, expected):
+    with mock.patch("google.api_core.gapic_v1.config_helpers.use_client_cert_effective", return_value=mock_cert_val):
+        with mock.patch.dict(os.environ, env, clear=True):
+            if expected == "mutual_tls_error":
+                with pytest.raises(MutualTLSChannelError, match="must be `never`, `auto` or `always`"):
+                    read_environment_variables()
+            else:
+                assert read_environment_variables() == expected