def test_rollback(self, mock_warn):
from google.cloud.spanner_dbapi import Connection
from google.cloud.spanner_dbapi.connection import AUTOCOMMIT_MODE_WARNING
connection = Connection(INSTANCE, DATABASE)
with mock.patch(
"google.cloud.spanner_dbapi.connection.Connection._release_session"
) as mock_release:
connection.rollback()
mock_release.assert_not_called()
mock_transaction = mock.MagicMock()
connection._transaction = mock_transaction
mock_rollback = mock.MagicMock()
mock_transaction.rollback = mock_rollback
with mock.patch(
"google.cloud.spanner_dbapi.connection.Connection._release_session"
) as mock_release:
connection.rollback()
mock_rollback.assert_called_once_with()
mock_release.assert_called_once_with()
connection._autocommit = True
connection.rollback()
mock_warn.assert_called_once_with(
AUTOCOMMIT_MODE_WARNING, UserWarning, stacklevel=2
)
def test__release_session(self, mock_database):
from google.cloud.spanner_dbapi import Connection
pool = self._make_pool()
mock_database._pool = pool
connection = Connection(INSTANCE, mock_database)
connection._session = "session"
connection._release_session()
pool.put.assert_called_once_with("session")
self.assertIsNone(connection._session)
def test__release_session(self):
from google.cloud.spanner_dbapi import Connection
with mock.patch("google.cloud.spanner_v1.database.Database") as mock_database:
mock_database._pool = mock.MagicMock()
mock_database._pool.put = mock.MagicMock()
connection = Connection(self.INSTANCE, mock_database)
connection._session = "session"
connection._release_session()
mock_database._pool.put.assert_called_once_with("session")
self.assertIsNone(connection._session)
def _make_connection(self):
from google.cloud.spanner_dbapi import Connection
from google.cloud.spanner_v1.instance import Instance
# We don't need a real Client object to test the constructor
instance = Instance(self.INSTANCE, client=None)
database = instance.database(self.DATABASE)
return Connection(instance, database)
def test_context(self):
from google.cloud.spanner_dbapi import Connection
connection = Connection(self.INSTANCE, self.DATABASE)
with connection as conn:
self.assertEqual(conn, connection)
self.assertTrue(connection.is_closed)
def test_run_prior_DDL_statements(self, mock_database):
from google.cloud.spanner_dbapi import Connection, InterfaceError
connection = Connection(INSTANCE, mock_database)
connection.run_prior_DDL_statements()
mock_database.update_ddl.assert_not_called()
ddl = ["ddl"]
connection._ddl_statements = ddl
connection.run_prior_DDL_statements()
mock_database.update_ddl.assert_called_once_with(ddl)
connection.is_closed = True
with self.assertRaises(InterfaceError):
connection.run_prior_DDL_statements()
def test_property_autocommit_setter(self):
from google.cloud.spanner_dbapi import Connection
connection = Connection(self.INSTANCE, self.DATABASE)
with mock.patch(
"google.cloud.spanner_dbapi.connection.Connection.commit"
) as mock_commit:
connection.autocommit = True
mock_commit.assert_called_once_with()
self.assertEqual(connection._autocommit, True)
with mock.patch(
"google.cloud.spanner_dbapi.connection.Connection.commit"
) as mock_commit:
connection.autocommit = False
mock_commit.assert_not_called()
self.assertEqual(connection._autocommit, False)
def test_transaction_checkout(self):
from google.cloud.spanner_dbapi import Connection
connection = Connection(INSTANCE, DATABASE)
mock_checkout = mock.MagicMock(autospec=True)
connection._session_checkout = mock_checkout
connection.transaction_checkout()
mock_checkout.assert_called_once_with()
mock_transaction = mock.MagicMock()
mock_transaction.committed = mock_transaction.rolled_back = False
connection._transaction = mock_transaction
self.assertEqual(connection.transaction_checkout(), mock_transaction)
connection._autocommit = True
self.assertIsNone(connection.transaction_checkout())
def test__session_checkout(self, mock_database):
from google.cloud.spanner_dbapi import Connection
pool = self._make_pool()
mock_database._pool = pool
connection = Connection(INSTANCE, mock_database)
connection._session_checkout()
pool.get.assert_called_once_with()
self.assertEqual(connection._session, pool.get.return_value)
connection._session = "db_session"
connection._session_checkout()
self.assertEqual(connection._session, "db_session")
def test__session_checkout(self):
from google.cloud.spanner_dbapi import Connection
with mock.patch("google.cloud.spanner_v1.database.Database") as mock_database:
mock_database._pool = mock.MagicMock()
mock_database._pool.get = mock.MagicMock(return_value="db_session_pool")
connection = Connection(self.INSTANCE, mock_database)
connection._session_checkout()
mock_database._pool.get.assert_called_once_with()
self.assertEqual(connection._session, "db_session_pool")
connection._session = "db_session"
connection._session_checkout()
self.assertEqual(connection._session, "db_session")
def _make_connection(self):
# we don't need real Client object to test the constructor
instance = Instance(self.instance_name, client=None)
database = instance.database(self.database_name)
return Connection(instance, database)
def _make_connection(self, *args, **kwargs):
from google.cloud.spanner_dbapi import Connection
return Connection(*args, **kwargs)
def test_snapshot_checkout(self):
from google.cloud.spanner_dbapi import Connection
connection = Connection(INSTANCE, DATABASE, read_only=True)
connection.autocommit = False
session_checkout = mock.MagicMock(autospec=True)
connection._session_checkout = session_checkout
snapshot = connection.snapshot_checkout()
session_checkout.assert_called_once()
self.assertEqual(snapshot, connection.snapshot_checkout())
connection.commit()
self.assertIsNone(connection._snapshot)
connection.snapshot_checkout()
self.assertIsNotNone(connection._snapshot)
connection.rollback()
self.assertIsNone(connection._snapshot)
connection.autocommit = True
self.assertIsNone(connection.snapshot_checkout())
