feat(auth): add subclass and instance checks for lazy bases and fix tests

Author: hebaalazzeh

packages/google-auth/google/auth/_helpers.py

@@ -571,6 +571,14 @@ def __getattribute__(cls, name):
             type(cls)._resolve_bases(cls)
         return super(LazyBasesMeta, cls).__getattribute__(name)
 
+    def __instancecheck__(cls, instance):
+        type(cls)._resolve_bases(cls)
+        return super(LazyBasesMeta, cls).__instancecheck__(instance)
+
+    def __subclasscheck__(cls, subclass):
+        type(cls)._resolve_bases(cls)
+        return super(LazyBasesMeta, cls).__subclasscheck__(subclass)
+
     def _resolve_bases(cls):
         try:
             resolved = type.__getattribute__(cls, "_lazy_bases_resolved")

packages/google-auth/tests/conftest.py

@@ -16,9 +16,17 @@
 import sys
 from unittest import mock
 
+# Clear mTLS environment variables to ensure local environment settings do not leak
+# and affect import-time configurations of tested modules.
+os.environ.pop("GOOGLE_API_CERTIFICATE_CONFIG", None)
+os.environ.pop("CLOUDSDK_CONTEXT_AWARE_USE_CLIENT_CERTIFICATE", None)
+os.environ.pop("GOOGLE_API_USE_CLIENT_CERTIFICATE", None)
+os.environ.pop("GOOGLE_API_USE_MTLS_ENDPOINT", None)
+
 import pytest  # type: ignore
 
 
+
 def pytest_configure():
     """Load public certificate and private key."""
     pytest.data_dir = os.path.join(os.path.dirname(__file__), "data")

packages/google-auth/tests/test__helpers.py

@@ -697,3 +697,49 @@ def test_out_of_range(self):
         with pytest.raises((OverflowError, OSError, ValueError)):
             # Large enough to fail on most systems (Year 300,000+)
             _helpers.utcfromtimestamp(9999999999999)
+
+
+class TestLazyBasesMeta:
+    def test_subclass_and_instance_check(self):
+        class RealBase(object):
+            pass
+
+        class DummyBase(_helpers.HeapDummy):
+            pass
+
+        class LazyClass(DummyBase, metaclass=_helpers.LazyBasesMeta):
+            pass
+
+        class LazyClassMeta(_helpers.LazyBasesMeta):
+            def _perform_resolve_bases(cls):
+                cls.__bases__ = (RealBase,)
+
+        # Re-define LazyClass with the proper metaclass that resolves to RealBase
+        class LazyClassResolved(DummyBase, metaclass=LazyClassMeta):
+            pass
+
+        # Verify initial bases
+        assert type.__getattribute__(LazyClassResolved, "__bases__") == (DummyBase,)
+
+        # Trigger subclass check where lazy class is the second argument (supported)
+        # This should resolve the bases of LazyClassResolved
+        assert not issubclass(int, LazyClassResolved)
+
+        # Verify bases are resolved
+        assert type.__getattribute__(LazyClassResolved, "__bases__") == (RealBase,)
+
+        # Now the first-argument subclass check should pass
+        assert issubclass(LazyClassResolved, RealBase)
+
+        # Reset resolved state for instance check test
+        class LazyClassForInstance(DummyBase, metaclass=LazyClassMeta):
+            pass
+
+        assert type.__getattribute__(LazyClassForInstance, "__bases__") == (DummyBase,)
+
+        # Trigger instance check (supported) to resolve the bases of LazyClassForInstance
+        assert not isinstance(123, LazyClassForInstance)
+
+        # Verify bases are resolved
+        assert type.__getattribute__(LazyClassForInstance, "__bases__") == (RealBase,)
+