crate 0.29.0__py2.py3-none-any.whl → 0.30.1__py2.py3-none-any.whl

crate/client/sqlalchemy/tests/array_test.py

@@ -26,7 +26,10 @@ from unittest.mock import patch, MagicMock
 import sqlalchemy as sa
 from sqlalchemy.sql import operators
 from sqlalchemy.orm import Session
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 from crate.client.cursor import Cursor
 
@@ -40,7 +43,7 @@ class SqlAlchemyArrayTypeTest(TestCase):
 
     def setUp(self):
         self.engine = sa.create_engine('crate://')
-        Base = declarative_base(bind=self.engine)
+        Base = declarative_base()
         self.metadata = sa.MetaData()
 
         class User(Base):
@@ -51,7 +54,7 @@ class SqlAlchemyArrayTypeTest(TestCase):
             scores = sa.Column(sa.ARRAY(sa.Integer))
 
         self.User = User
-        self.session = Session()
+        self.session = Session(bind=self.engine)
 
     def assertSQL(self, expected_str, actual_expr):
         self.assertEqual(expected_str, str(actual_expr).replace('\n', ''))

crate/client/sqlalchemy/tests/bulk_test.py

@@ -24,7 +24,10 @@ from unittest.mock import patch, MagicMock
 
 import sqlalchemy as sa
 from sqlalchemy.orm import Session
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 from crate.client.cursor import Cursor
 
@@ -38,7 +41,7 @@ class SqlAlchemyBulkTest(TestCase):
 
     def setUp(self):
         self.engine = sa.create_engine('crate://')
-        Base = declarative_base(bind=self.engine)
+        Base = declarative_base()
 
         class Character(Base):
             __tablename__ = 'characters'
@@ -47,7 +50,7 @@ class SqlAlchemyBulkTest(TestCase):
             age = sa.Column(sa.Integer)
 
         self.character = Character
-        self.session = Session()
+        self.session = Session(bind=self.engine)
 
     @patch('crate.client.connection.Cursor', FakeCursor)
     def test_bulk_save(self):
@@ -75,4 +78,4 @@ class SqlAlchemyBulkTest(TestCase):
             ('Banshee', 26),
             ('Callisto', 37)
         )
-        self.assertEqual(expected_bulk_args, bulk_args)
+        self.assertSequenceEqual(expected_bulk_args, bulk_args)

crate/client/sqlalchemy/tests/compiler_test.py

@@ -24,8 +24,9 @@ from unittest import TestCase
 from crate.client.sqlalchemy.compiler import crate_before_execute
 
 import sqlalchemy as sa
-from sqlalchemy.sql import update, text
+from sqlalchemy.sql import text, Update
 
+from crate.client.sqlalchemy.sa_version import SA_VERSION, SA_1_4
 from crate.client.sqlalchemy.types import Craty
 
 
@@ -39,7 +40,7 @@ class SqlAlchemyCompilerTest(TestCase):
                                 sa.Column('name', sa.String),
                                 sa.Column('data', Craty))
 
-        self.update = update(self.mytable, text('where name=:name'))
+        self.update = Update(self.mytable).where(text('name=:name'))
         self.values = [{'name': 'crate'}]
         self.values = (self.values, )
 
@@ -74,25 +75,25 @@ class SqlAlchemyCompilerTest(TestCase):
         """
         Verify the `CrateCompiler.limit_clause` method, with offset.
         """
-        self.metadata.bind = self.crate_engine
         selectable = self.mytable.select().offset(5)
-        statement = str(selectable.compile())
-        self.assertEqual(statement, "SELECT mytable.name, mytable.data \nFROM mytable\n LIMIT ALL OFFSET ?")
+        statement = str(selectable.compile(bind=self.crate_engine))
+        if SA_VERSION >= SA_1_4:
+            self.assertEqual(statement, "SELECT mytable.name, mytable.data \nFROM mytable\n LIMIT ALL OFFSET ?")
+        else:
+            self.assertEqual(statement, "SELECT mytable.name, mytable.data \nFROM mytable \n LIMIT ALL OFFSET ?")
 
     def test_select_with_limit(self):
         """
         Verify the `CrateCompiler.limit_clause` method, with limit.
         """
-        self.metadata.bind = self.crate_engine
         selectable = self.mytable.select().limit(42)
-        statement = str(selectable.compile())
+        statement = str(selectable.compile(bind=self.crate_engine))
         self.assertEqual(statement, "SELECT mytable.name, mytable.data \nFROM mytable \n LIMIT ?")
 
     def test_select_with_offset_and_limit(self):
         """
         Verify the `CrateCompiler.limit_clause` method, with offset and limit.
         """
-        self.metadata.bind = self.crate_engine
         selectable = self.mytable.select().offset(5).limit(42)
-        statement = str(selectable.compile())
+        statement = str(selectable.compile(bind=self.crate_engine))
         self.assertEqual(statement, "SELECT mytable.name, mytable.data \nFROM mytable \n LIMIT ? OFFSET ?")

crate/client/sqlalchemy/tests/connection_test.py

@@ -34,21 +34,27 @@ class SqlAlchemyConnectionTest(TestCase):
         engine = sa.create_engine('crate://')
         conn = engine.raw_connection()
         self.assertEqual("<Connection <Client ['http://127.0.0.1:4200']>>",
-                         repr(conn.connection))
+                         repr(conn.driver_connection))
+        conn.close()
+        engine.dispose()
 
     def test_connection_server_uri_http(self):
         engine = sa.create_engine(
             "crate://otherhost:19201")
         conn = engine.raw_connection()
         self.assertEqual("<Connection <Client ['http://otherhost:19201']>>",
-                         repr(conn.connection))
+                         repr(conn.driver_connection))
+        conn.close()
+        engine.dispose()
 
     def test_connection_server_uri_https(self):
         engine = sa.create_engine(
             "crate://otherhost:19201/?ssl=true")
         conn = engine.raw_connection()
         self.assertEqual("<Connection <Client ['https://otherhost:19201']>>",
-                         repr(conn.connection))
+                         repr(conn.driver_connection))
+        conn.close()
+        engine.dispose()
 
     def test_connection_server_uri_invalid_port(self):
         with self.assertRaises(ValueError) as context:
@@ -60,18 +66,22 @@ class SqlAlchemyConnectionTest(TestCase):
             "crate://foo@otherhost:19201/?ssl=true")
         conn = engine.raw_connection()
         self.assertEqual("<Connection <Client ['https://otherhost:19201']>>",
-                         repr(conn.connection))
-        self.assertEqual(conn.connection.client.username, "foo")
-        self.assertEqual(conn.connection.client.password, None)
+                         repr(conn.driver_connection))
+        self.assertEqual(conn.driver_connection.client.username, "foo")
+        self.assertEqual(conn.driver_connection.client.password, None)
+        conn.close()
+        engine.dispose()
 
     def test_connection_server_uri_https_with_credentials(self):
         engine = sa.create_engine(
             "crate://foo:bar@otherhost:19201/?ssl=true")
         conn = engine.raw_connection()
         self.assertEqual("<Connection <Client ['https://otherhost:19201']>>",
-                         repr(conn.connection))
-        self.assertEqual(conn.connection.client.username, "foo")
-        self.assertEqual(conn.connection.client.password, "bar")
+                         repr(conn.driver_connection))
+        self.assertEqual(conn.driver_connection.client.username, "foo")
+        self.assertEqual(conn.driver_connection.client.password, "bar")
+        conn.close()
+        engine.dispose()
 
     def test_connection_multiple_server_http(self):
         engine = sa.create_engine(
@@ -83,7 +93,9 @@ class SqlAlchemyConnectionTest(TestCase):
         self.assertEqual(
             "<Connection <Client ['http://localhost:4201', " +
             "'http://localhost:4202']>>",
-            repr(conn.connection))
+            repr(conn.driver_connection))
+        conn.close()
+        engine.dispose()
 
     def test_connection_multiple_server_https(self):
         engine = sa.create_engine(
@@ -96,4 +108,6 @@ class SqlAlchemyConnectionTest(TestCase):
         self.assertEqual(
             "<Connection <Client ['https://localhost:4201', " +
             "'https://localhost:4202']>>",
-            repr(conn.connection))
+            repr(conn.driver_connection))
+        conn.close()
+        engine.dispose()

crate/client/sqlalchemy/tests/create_table_test.py

@@ -20,7 +20,10 @@
 # software solely pursuant to the terms of the relevant commercial agreement.
 
 import sqlalchemy as sa
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 from crate.client.sqlalchemy.types import Object, ObjectArray, Geopoint
 from crate.client.cursor import Cursor
@@ -35,11 +38,11 @@ FakeCursor.return_value = fake_cursor
 
 
 @patch('crate.client.connection.Cursor', FakeCursor)
-class CreateTableTest(TestCase):
+class SqlAlchemyCreateTableTest(TestCase):
 
     def setUp(self):
         self.engine = sa.create_engine('crate://')
-        self.Base = declarative_base(bind=self.engine)
+        self.Base = declarative_base()
 
     def test_table_basic_types(self):
         class User(self.Base):
@@ -57,7 +60,7 @@ class CreateTableTest(TestCase):
             float_col = sa.Column(sa.Float)
             double_col = sa.Column(sa.DECIMAL)
 
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE users (\n\tstring_col STRING NOT NULL, '
              '\n\tunicode_col STRING, \n\ttext_col STRING, \n\tint_col INT, '
@@ -74,7 +77,7 @@ class CreateTableTest(TestCase):
             __tablename__ = 'dummy'
             pk = sa.Column(sa.String, primary_key=True)
             obj_col = sa.Column(Object)
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE dummy (\n\tpk STRING NOT NULL, \n\tobj_col OBJECT, '
              '\n\tPRIMARY KEY (pk)\n)\n\n'),
@@ -88,7 +91,7 @@ class CreateTableTest(TestCase):
             }
             pk = sa.Column(sa.String, primary_key=True)
             p = sa.Column(sa.String)
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -102,7 +105,7 @@ class CreateTableTest(TestCase):
             __tablename__ = 't'
             ts = sa.Column(sa.BigInteger, primary_key=True)
             p = sa.Column(sa.BigInteger, sa.Computed("date_trunc('day', ts)"))
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'ts LONG NOT NULL, \n\t'
@@ -117,7 +120,7 @@ class CreateTableTest(TestCase):
             ts = sa.Column(sa.BigInteger, primary_key=True)
             p = sa.Column(sa.BigInteger, sa.Computed("date_trunc('day', ts)", persisted=False))
         with self.assertRaises(sa.exc.CompileError):
-            self.Base.metadata.create_all()
+            self.Base.metadata.create_all(bind=self.engine)
 
     def test_table_partitioned_by(self):
         class DummyTable(self.Base):
@@ -128,7 +131,7 @@ class CreateTableTest(TestCase):
             }
             pk = sa.Column(sa.String, primary_key=True)
             p = sa.Column(sa.String)
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -146,7 +149,7 @@ class CreateTableTest(TestCase):
             }
             pk = sa.Column(sa.String, primary_key=True)
 
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -163,7 +166,7 @@ class CreateTableTest(TestCase):
             }
             pk = sa.Column(sa.String, primary_key=True)
             p = sa.Column(sa.String, primary_key=True)
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -178,7 +181,7 @@ class CreateTableTest(TestCase):
             pk = sa.Column(sa.String, primary_key=True)
             tags = sa.Column(ObjectArray)
 
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -192,7 +195,7 @@ class CreateTableTest(TestCase):
             a = sa.Column(sa.Integer, nullable=True)
             b = sa.Column(sa.Integer, nullable=False)
 
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -205,7 +208,7 @@ class CreateTableTest(TestCase):
             __tablename__ = 't'
             pk = sa.Column(sa.String, primary_key=True, nullable=True)
         with self.assertRaises(sa.exc.CompileError):
-            self.Base.metadata.create_all()
+            self.Base.metadata.create_all(bind=self.engine)
 
     def test_column_crate_index(self):
         class DummyTable(self.Base):
@@ -214,7 +217,7 @@ class CreateTableTest(TestCase):
             a = sa.Column(sa.Integer, crate_index=False)
             b = sa.Column(sa.Integer, crate_index=True)
 
-        self.Base.metadata.create_all()
+        self.Base.metadata.create_all(bind=self.engine)
         fake_cursor.execute.assert_called_with(
             ('\nCREATE TABLE t (\n\t'
              'pk STRING NOT NULL, \n\t'
@@ -228,4 +231,4 @@ class CreateTableTest(TestCase):
             pk = sa.Column(sa.String, primary_key=True)
             a = sa.Column(Geopoint, crate_index=False)
         with self.assertRaises(sa.exc.CompileError):
-            self.Base.metadata.create_all()
+            self.Base.metadata.create_all(bind=self.engine)

crate/client/sqlalchemy/tests/datetime_test.py

@@ -27,7 +27,10 @@ from unittest.mock import patch, MagicMock
 import sqlalchemy as sa
 from sqlalchemy.exc import DBAPIError
 from sqlalchemy.orm import Session
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 from crate.client.cursor import Cursor
 
@@ -54,7 +57,7 @@ class SqlAlchemyDateAndDateTimeTest(TestCase):
 
     def setUp(self):
         self.engine = sa.create_engine('crate://')
-        Base = declarative_base(bind=self.engine)
+        Base = declarative_base()
 
         class Character(Base):
             __tablename__ = 'characters'
@@ -66,7 +69,7 @@ class SqlAlchemyDateAndDateTimeTest(TestCase):
             ('characters_name', None, None, None, None, None, None),
             ('characters_date', None, None, None, None, None, None)
         )
-        self.session = Session()
+        self.session = Session(bind=self.engine)
         self.Character = Character
 
     def test_date_can_handle_datetime(self):

crate/client/sqlalchemy/tests/dialect_test.py

@@ -20,23 +20,28 @@
 # software solely pursuant to the terms of the relevant commercial agreement.
 
 from datetime import datetime
-from unittest import TestCase
+from unittest import TestCase, skipIf
 from unittest.mock import MagicMock, patch
 
 import sqlalchemy as sa
 
 from crate.client.cursor import Cursor
+from crate.client.sqlalchemy import SA_VERSION
+from crate.client.sqlalchemy.sa_version import SA_1_4, SA_2_0
 from crate.client.sqlalchemy.types import Object
 from sqlalchemy import inspect
-from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy.orm import Session
-from sqlalchemy.testing import eq_, in_
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.testing import eq_, in_, is_true
 
 FakeCursor = MagicMock(name='FakeCursor', spec=Cursor)
 
 
 @patch('crate.client.connection.Cursor', FakeCursor)
-class DialectTest(TestCase):
+class SqlAlchemyDialectTest(TestCase):
 
     def execute_wrapper(self, query, *args, **kwargs):
         self.executed_statement = query
@@ -48,13 +53,14 @@ class DialectTest(TestCase):
         FakeCursor.return_value = self.fake_cursor
 
         self.engine = sa.create_engine('crate://')
+
         self.executed_statement = None
 
         self.connection = self.engine.connect()
 
         self.fake_cursor.execute = self.execute_wrapper
 
-        self.base = declarative_base(bind=self.engine)
+        self.base = declarative_base()
 
         class Character(self.base):
             __tablename__ = 'characters'
@@ -64,12 +70,17 @@ class DialectTest(TestCase):
             obj = sa.Column(Object)
             ts = sa.Column(sa.DateTime, onupdate=datetime.utcnow)
 
-        self.character = Character
-        self.session = Session()
+        self.session = Session(bind=self.engine)
+
+    def init_mock(self, return_value=None):
+        self.fake_cursor.rowcount = 1
+        self.fake_cursor.description = (
+            ('foo', None, None, None, None, None, None),
+        )
+        self.fake_cursor.fetchall = MagicMock(return_value=return_value)
 
     def test_primary_keys_2_3_0(self):
-        meta = self.character.metadata
-        insp = inspect(meta.bind)
+        insp = inspect(self.session.bind)
         self.engine.dialect.server_version_info = (2, 3, 0)
 
         self.fake_cursor.rowcount = 3
@@ -84,8 +95,7 @@ class DialectTest(TestCase):
         in_("table_catalog = ?", self.executed_statement)
 
     def test_primary_keys_3_0_0(self):
-        meta = self.character.metadata
-        insp = inspect(meta.bind)
+        insp = inspect(self.session.bind)
         self.engine.dialect.server_version_info = (3, 0, 0)
 
         self.fake_cursor.rowcount = 3
@@ -106,7 +116,7 @@ class DialectTest(TestCase):
         )
         self.fake_cursor.fetchall = MagicMock(return_value=[["t1"], ["t2"]])
 
-        insp = inspect(self.character.metadata.bind)
+        insp = inspect(self.session.bind)
         self.engine.dialect.server_version_info = (2, 0, 0)
         eq_(insp.get_table_names(schema="doc"),
             ['t1', 't2'])
@@ -119,9 +129,28 @@ class DialectTest(TestCase):
         )
         self.fake_cursor.fetchall = MagicMock(return_value=[["v1"], ["v2"]])
 
-        insp = inspect(self.character.metadata.bind)
+        insp = inspect(self.session.bind)
         self.engine.dialect.server_version_info = (2, 0, 0)
         eq_(insp.get_view_names(schema="doc"),
             ['v1', 'v2'])
         eq_(self.executed_statement, "SELECT table_name FROM information_schema.views "
                                      "ORDER BY table_name ASC, table_schema ASC")
+
+    @skipIf(SA_VERSION < SA_1_4, "Inspector.has_table only available on SQLAlchemy>=1.4")
+    def test_has_table(self):
+        self.init_mock(return_value=[["foo"], ["bar"]])
+        insp = inspect(self.session.bind)
+        is_true(insp.has_table("bar"))
+        eq_(self.executed_statement,
+            "SELECT table_name FROM information_schema.tables "
+            "WHERE table_schema = ? AND table_type = 'BASE TABLE' "
+            "ORDER BY table_name ASC, table_schema ASC")
+
+    @skipIf(SA_VERSION < SA_2_0, "Inspector.has_schema only available on SQLAlchemy>=2.0")
+    def test_has_schema(self):
+        self.init_mock(
+            return_value=[["blob"], ["doc"], ["information_schema"], ["pg_catalog"], ["sys"]])
+        insp = inspect(self.session.bind)
+        is_true(insp.has_schema("doc"))
+        eq_(self.executed_statement,
+            "select schema_name from information_schema.schemata order by schema_name asc")

crate/client/sqlalchemy/tests/dict_test.py

@@ -26,7 +26,10 @@ from unittest.mock import patch, MagicMock
 import sqlalchemy as sa
 from sqlalchemy.sql import select
 from sqlalchemy.orm import Session
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 from crate.client.sqlalchemy.types import Craty, ObjectArray
 from crate.client.cursor import Cursor
@@ -46,19 +49,20 @@ class SqlAlchemyDictTypeTest(TestCase):
                                 sa.Column('name', sa.String),
                                 sa.Column('data', Craty))
 
-    def assertSQL(self, expected_str, actual_expr):
+    def assertSQL(self, expected_str, selectable):
+        actual_expr = selectable.compile(bind=self.engine)
         self.assertEqual(expected_str, str(actual_expr).replace('\n', ''))
 
     def test_select_with_dict_column(self):
         mytable = self.mytable
         self.assertSQL(
             "SELECT mytable.data['x'] AS anon_1 FROM mytable",
-            select([mytable.c.data['x']], bind=self.engine)
+            select(mytable.c.data['x'])
         )
 
     def test_select_with_dict_column_where_clause(self):
         mytable = self.mytable
-        s = select([mytable.c.data], bind=self.engine).\
+        s = select(mytable.c.data).\
             where(mytable.c.data['x'] == 1)
         self.assertSQL(
             "SELECT mytable.data FROM mytable WHERE mytable.data['x'] = ?",
@@ -67,7 +71,7 @@ class SqlAlchemyDictTypeTest(TestCase):
 
     def test_select_with_dict_column_nested_where(self):
         mytable = self.mytable
-        s = select([mytable.c.name], bind=self.engine)
+        s = select(mytable.c.name)
         s = s.where(mytable.c.data['x']['y'] == 1)
         self.assertSQL(
             "SELECT mytable.name FROM mytable " +
@@ -77,7 +81,7 @@ class SqlAlchemyDictTypeTest(TestCase):
 
     def test_select_with_dict_column_where_clause_gt(self):
         mytable = self.mytable
-        s = select([mytable.c.data], bind=self.engine).\
+        s = select(mytable.c.data).\
             where(mytable.c.data['x'] > 1)
         self.assertSQL(
             "SELECT mytable.data FROM mytable WHERE mytable.data['x'] > ?",
@@ -86,7 +90,7 @@ class SqlAlchemyDictTypeTest(TestCase):
 
     def test_select_with_dict_column_where_clause_other_col(self):
         mytable = self.mytable
-        s = select([mytable.c.name], bind=self.engine)
+        s = select(mytable.c.name)
         s = s.where(mytable.c.data['x'] == mytable.c.name)
         self.assertSQL(
             "SELECT mytable.name FROM mytable " +
@@ -96,7 +100,7 @@ class SqlAlchemyDictTypeTest(TestCase):
 
     def test_update_with_dict_column(self):
         mytable = self.mytable
-        stmt = mytable.update(bind=self.engine).\
+        stmt = mytable.update().\
             where(mytable.c.name == 'Arthur Dent').\
             values({
                 "data['x']": "Trillian"
@@ -114,7 +118,7 @@ class SqlAlchemyDictTypeTest(TestCase):
             ('characters_data', None, None, None, None, None, None)
         )
         fake_cursor.rowcount = 1
-        Base = declarative_base(bind=self.engine)
+        Base = declarative_base()
 
         class Character(Base):
             __tablename__ = 'characters'
@@ -123,7 +127,7 @@ class SqlAlchemyDictTypeTest(TestCase):
             data = sa.Column(Craty)
             data_list = sa.Column(ObjectArray)
 
-        session = Session()
+        session = Session(bind=self.engine)
         return session, Character
 
     def test_assign_null_to_object_array(self):
@@ -266,7 +270,7 @@ class SqlAlchemyDictTypeTest(TestCase):
             return_value=[('Trillian', {'x': 1})]
         )
 
-        session = Session()
+        session = Session(bind=self.engine)
         char = Character(name='Trillian')
         char.data = {'x': 1}
         session.add(char)
@@ -339,14 +343,14 @@ class SqlAlchemyDictTypeTest(TestCase):
 
         )
         fake_cursor.rowcount = 1
-        Base = declarative_base(bind=self.engine)
+        Base = declarative_base()
 
         class Character(Base):
             __tablename__ = 'characters'
             name = sa.Column(sa.String, primary_key=True)
             data_list = sa.Column(ObjectArray)
 
-        session = Session()
+        session = Session(bind=self.engine)
         return session, Character
 
     def _setup_object_array_char(self):

crate/client/sqlalchemy/tests/function_test.py

@@ -23,12 +23,15 @@ from unittest import TestCase
 
 import sqlalchemy as sa
 from sqlalchemy.sql.sqltypes import TIMESTAMP
-from sqlalchemy.ext.declarative import declarative_base
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 
-class FunctionTest(TestCase):
+class SqlAlchemyFunctionTest(TestCase):
     def setUp(self):
-        Base = declarative_base(bind=sa.create_engine("crate://"))
+        Base = declarative_base()
 
         class Character(Base):
             __tablename__ = "characters"

crate/client/sqlalchemy/tests/insert_from_select_test.py

@@ -24,9 +24,12 @@ from unittest import TestCase
 from unittest.mock import patch, MagicMock
 
 import sqlalchemy as sa
-from sqlalchemy.orm import Session
-from sqlalchemy.ext.declarative import declarative_base
 from sqlalchemy import select, insert
+from sqlalchemy.orm import Session
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
 
 from crate.client.cursor import Cursor
 
@@ -44,7 +47,7 @@ class SqlAlchemyInsertFromSelectTest(TestCase):
 
     def setUp(self):
         self.engine = sa.create_engine('crate://')
-        Base = declarative_base(bind=self.engine)
+        Base = declarative_base()
 
         class Character(Base):
             __tablename__ = 'characters'
@@ -64,7 +67,7 @@ class SqlAlchemyInsertFromSelectTest(TestCase):
 
         self.character = Character
         self.character_archived = CharacterArchive
-        self.session = Session()
+        self.session = Session(bind=self.engine)
 
     @patch('crate.client.connection.Cursor', FakeCursor)
     def test_insert_from_select_triggered(self):
@@ -72,11 +75,11 @@ class SqlAlchemyInsertFromSelectTest(TestCase):
         self.session.add(char)
         self.session.commit()
 
-        sel = select([self.character.name, self.character.age]).where(self.character.status == "Archived")
+        sel = select(self.character.name, self.character.age).where(self.character.status == "Archived")
         ins = insert(self.character_archived).from_select(['name', 'age'], sel)
         self.session.execute(ins)
         self.session.commit()
         self.assertSQL(
             "INSERT INTO characters_archive (name, age) SELECT characters.name, characters.age FROM characters WHERE characters.status = ?",
-            ins
+            ins.compile(bind=self.engine)
         )