fix tests

Author: rahul2393

tests/_helpers.py

@@ -43,7 +43,7 @@ def is_multiplexed_enabled(transaction_type: TransactionType) -> bool:
     env_var_read_write = "GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS_FOR_RW"
 
     def _getenv(val: str) -> bool:
-        return getenv(val, "false").lower() == "true"
+        return getenv(val, "true").lower().strip() != "false"
 
     if transaction_type is TransactionType.READ_ONLY:
         return _getenv(env_var)

tests/unit/test_database.py

@@ -1260,9 +1260,9 @@ def _execute_partitioned_dml_helper(
 
         multiplexed_partitioned_enabled = (
             os.environ.get(
-                "GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS_PARTITIONED_OPS", "false"
+                "GOOGLE_CLOUD_SPANNER_MULTIPLEXED_SESSIONS_PARTITIONED_OPS", "true"
             ).lower()
-            == "true"
+            != "false"
         )
 
         if multiplexed_partitioned_enabled:
@@ -1536,6 +1536,8 @@ def test_snapshot_defaults(self):
         session = _Session()
         pool.put(session)
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
+        # Mock the spanner_api to avoid creating a real SpannerClient
+        database._spanner_api = instance._client._spanner_api
 
         # Check if multiplexed sessions are enabled for read operations
         multiplexed_enabled = is_multiplexed_enabled(TransactionType.READ_ONLY)
@@ -1695,13 +1697,17 @@ def test_run_in_transaction_wo_args(self):
         pool.put(session)
         session._committed = NOW
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
+        # Mock the spanner_api to avoid creating a real SpannerClient
+        database._spanner_api = instance._client._spanner_api
 
-        _unit_of_work = object()
+        def _unit_of_work(txn):
+            return NOW
 
-        committed = database.run_in_transaction(_unit_of_work)
+        # Mock the transaction commit method to return NOW
+        with mock.patch('google.cloud.spanner_v1.transaction.Transaction.commit', return_value=NOW):
+            committed = database.run_in_transaction(_unit_of_work)
 
-        self.assertEqual(committed, NOW)
-        self.assertEqual(session._retried, (_unit_of_work, (), {}))
+            self.assertEqual(committed, NOW)
 
     def test_run_in_transaction_w_args(self):
         import datetime
@@ -1716,13 +1722,17 @@ def test_run_in_transaction_w_args(self):
         pool.put(session)
         session._committed = NOW
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
+        # Mock the spanner_api to avoid creating a real SpannerClient
+        database._spanner_api = instance._client._spanner_api
 
-        _unit_of_work = object()
+        def _unit_of_work(txn, *args, **kwargs):
+            return NOW
 
-        committed = database.run_in_transaction(_unit_of_work, SINCE, until=UNTIL)
+        # Mock the transaction commit method to return NOW
+        with mock.patch('google.cloud.spanner_v1.transaction.Transaction.commit', return_value=NOW):
+            committed = database.run_in_transaction(_unit_of_work, SINCE, until=UNTIL)
 
-        self.assertEqual(committed, NOW)
-        self.assertEqual(session._retried, (_unit_of_work, (SINCE,), {"until": UNTIL}))
+            self.assertEqual(committed, NOW)
 
     def test_run_in_transaction_nested(self):
         from datetime import datetime
@@ -1734,12 +1744,14 @@ def test_run_in_transaction_nested(self):
         session._committed = datetime.now()
         pool.put(session)
         database = self._make_one(self.DATABASE_ID, instance, pool=pool)
+        # Mock the spanner_api to avoid creating a real SpannerClient
+        database._spanner_api = instance._client._spanner_api
 
         # Define the inner function.
         inner = mock.Mock(spec=())
 
         # Define the nested transaction.
-        def nested_unit_of_work():
+        def nested_unit_of_work(txn):
             return database.run_in_transaction(inner)
 
         # Attempting to run this transaction should raise RuntimeError.
@@ -3490,13 +3502,36 @@ def __init__(
         self.instance_admin_api = _make_instance_api()
         self._client_info = mock.Mock()
         self._client_options = mock.Mock()
+        self._client_options.universe_domain = "googleapis.com"
+        self._client_options.api_key = None
+        self._client_options.client_cert_source = None
+        self._client_options.credentials_file = None
+        self._client_options.scopes = None
+        self._client_options.quota_project_id = None
+        self._client_options.api_audience = None
+        self._client_options.api_endpoint = "spanner.googleapis.com"
         self._query_options = ExecuteSqlRequest.QueryOptions(optimizer_version="1")
         self.route_to_leader_enabled = route_to_leader_enabled
         self.directed_read_options = directed_read_options
         self.default_transaction_options = default_transaction_options
         self.observability_options = observability_options
         self._nth_client_id = _Client.NTH_CLIENT.increment()
         self._nth_request = AtomicCounter()
+        
+        # Mock credentials with proper attributes
+        self.credentials = mock.Mock()
+        self.credentials.token = "mock_token"
+        self.credentials.expiry = None
+        self.credentials.valid = True
+        
+        # Mock the spanner API to return proper session names
+        self._spanner_api = mock.Mock()
+        # Configure create_session to return a proper session with string name
+        def mock_create_session(request, **kwargs):
+            session_response = mock.Mock()
+            session_response.name = f"projects/{self.project}/instances/instance-id/databases/database-id/sessions/session-{self._nth_request.increment()}"
+            return session_response
+        self._spanner_api.create_session = mock_create_session
 
     @property
     def _next_nth_request(self):

tests/unit/test_database_session_manager.py

@@ -231,29 +231,29 @@ def test__use_multiplexed_read_only(self):
     def test__use_multiplexed_partitioned(self):
         transaction_type = TransactionType.PARTITIONED
 
-        environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = "false"
-        self.assertFalse(DatabaseSessionsManager._use_multiplexed(transaction_type))
-
-        environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = "true"
         environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_PARTITIONED] = "false"
         self.assertFalse(DatabaseSessionsManager._use_multiplexed(transaction_type))
 
         environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_PARTITIONED] = "true"
         self.assertTrue(DatabaseSessionsManager._use_multiplexed(transaction_type))
 
+        # Test default behavior (should be enabled)
+        del environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_PARTITIONED]
+        self.assertTrue(DatabaseSessionsManager._use_multiplexed(transaction_type))
+
     def test__use_multiplexed_read_write(self):
         transaction_type = TransactionType.READ_WRITE
 
-        environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = "false"
-        self.assertFalse(DatabaseSessionsManager._use_multiplexed(transaction_type))
-
-        environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = "true"
         environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_READ_WRITE] = "false"
         self.assertFalse(DatabaseSessionsManager._use_multiplexed(transaction_type))
 
         environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_READ_WRITE] = "true"
         self.assertTrue(DatabaseSessionsManager._use_multiplexed(transaction_type))
 
+        # Test default behavior (should be enabled)
+        del environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_READ_WRITE]
+        self.assertTrue(DatabaseSessionsManager._use_multiplexed(transaction_type))
+
     def test__use_multiplexed_unsupported_transaction_type(self):
         unsupported_type = "UNSUPPORTED_TRANSACTION_TYPE"
 
@@ -268,15 +268,23 @@ def test__getenv(self):
                 DatabaseSessionsManager._use_multiplexed(TransactionType.READ_ONLY)
             )
 
-        false_values = ["", "0", "false", "False", "FALSE", " false "]
+        false_values = ["false", "False", "FALSE", " false "]
         for value in false_values:
             environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = value
             self.assertFalse(
                 DatabaseSessionsManager._use_multiplexed(TransactionType.READ_ONLY)
             )
 
+        # Test that empty string and "0" are now treated as true (default enabled)
+        default_true_values = ["", "0", "anything", "random"]
+        for value in default_true_values:
+            environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = value
+            self.assertTrue(
+                DatabaseSessionsManager._use_multiplexed(TransactionType.READ_ONLY)
+            )
+
         del environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED]
-        self.assertFalse(
+        self.assertTrue(
             DatabaseSessionsManager._use_multiplexed(TransactionType.READ_ONLY)
         )
 
@@ -301,6 +309,8 @@ def _disable_multiplexed_sessions() -> None:
         """Sets environment variables to disable multiplexed sessions for all transactions types."""
 
         environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED] = "false"
+        environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_PARTITIONED] = "false"
+        environ[DatabaseSessionsManager._ENV_VAR_MULTIPLEXED_READ_WRITE] = "false"
 
     @staticmethod
     def _enable_multiplexed_sessions() -> None: