More tests

Author: xzkostyan

src/engines.py

@@ -140,7 +140,7 @@ def __init__(self, database, table, num_layers=16,
                  min_time=10, max_time=100, min_rows=10000, max_rows=1000000,
                  min_bytes=10000000, max_bytes=100000000):
         self.database = database
-        self.table = table
+        self.table_name = table
         self.num_layers = num_layers
         self.min_time = min_time
         self.max_time = max_time
@@ -153,7 +153,7 @@ def __init__(self, database, table, num_layers=16,
     def get_params(self):
         return [
             self.database,
-            self.table.name,
+            self.table_name,
             self.num_layers,
             self.min_time,
             self.max_time,

tests/drivers/native/__init__.py

@@ -0,0 +1,20 @@
+from sqlalchemy import Column
+
+from src import engines, types, Table
+from tests.session import native_session, mocked_engine
+from tests.testcase import BaseTestCase
+
+
+class SanityTestCase(BaseTestCase):
+    session = native_session
+
+    def test_sanity(self):
+        table = Table(
+            't1', self.metadata(),
+            Column('x', types.Int32, primary_key=True),
+            engines.Memory()
+        )
+
+        with mocked_engine(self.session) as engine:
+            table.drop(if_exists=True)
+            engine.assert_sql(['DROP TABLE IF EXISTS t1'])

tests/drivers/native/test_select.py

@@ -1,6 +1,10 @@
+from decimal import Decimal
+from datetime import date
+
 from six import text_type
 from sqlalchemy import literal
 
+from src.drivers.escaper import Escaper
 from tests.session import session
 from tests.testcase import BaseTestCase
 
@@ -14,4 +18,22 @@ def test_select_escaping(self):
             self.compile(session.query(literal('\t')), literal_binds=True),
             "SELECT '\t' AS param_1"
         )
-    # TODO: test escaping \t, etc.
+
+    def test_escaper(self):
+        e = Escaper()
+        self.assertEqual(e.escape([None]), ['NULL'])
+        self.assertEqual(e.escape([[123]]), [[123]])
+        self.assertEqual(e.escape({'x': 'str'}), {'x': "'str'"})
+        self.assertEqual(e.escape([Decimal('10')]), [10.0])
+        self.assertEqual(e.escape([10.0]), [10.0])
+        self.assertEqual(e.escape([date(2017, 1, 2)]), ["'2017-01-02'"])
+
+        with self.assertRaises(Exception) as ex:
+            e.escape([object()])
+
+        self.assertIn('Unsupported object', text_type(ex.exception))
+
+        with self.assertRaises(Exception) as ex:
+            e.escape('str')
+
+        self.assertIn('Unsupported param format', text_type(ex.exception))

tests/drivers/test_escaping.py

@@ -34,3 +34,9 @@ def test_extract_day(self):
             self.compile(extract('day', get_date_column('x'))),
             'toDayOfMonth(x)'
         )
+
+    def test_extract_unknown(self):
+        self.assertEqual(
+            self.compile(extract('test', get_date_column('x'))),
+            'x'
+        )

tests/functions/test_extract.py

@@ -0,0 +1,17 @@
+from sqlalchemy import literal, func, text
+
+from tests.testcase import BaseTestCase
+
+
+class IfTestCase(BaseTestCase):
+    def test_if(self):
+        expression = func.if_(
+            literal(1) > literal(2),
+            text('a'),
+            text('b'),
+        )
+
+        self.assertEqual(
+            self.compile(expression, literal_binds=True),
+            'if(1 > 2, a, b)'
+        )

tests/functions/test_if.py

@@ -1,11 +1,50 @@
+import re
+
 from sqlalchemy import create_engine
 from sqlalchemy.dialects import registry
 
 from src import make_session
 
 
 registry.register("clickhouse", "src.drivers.http.base", "dialect")
+registry.register("clickhouse.native", "src.drivers.native.base", "dialect")
 
 uri = 'clickhouse://default:@localhost:8123/default'
-
 session = make_session(create_engine(uri))
+
+native_uri = 'clickhouse+native://default:@localhost/default'
+native_session = make_session(create_engine(native_uri))
+
+
+class MockedEngine(object):
+    def __init__(self, engine_session=None):
+        self.buffer = buffer = []
+
+        engine_session = engine_session or session
+
+        self.dialect_cls = engine_session.bind.dialect
+        self.prev_do_execute = self.dialect_cls.do_execute
+        self.prev_do_executemany = self.dialect_cls.do_executemany
+
+        def do_executemany(cursor, statement, parameters, context=None):
+            buffer.append(statement)
+
+        def do_execute(cursor, statement, parameters, context=None):
+            buffer.append(statement)
+
+        self.dialect_cls.do_execute = do_execute
+        self.dialect_cls.do_executemany = do_executemany
+
+    def assert_sql(self, stmts):
+        recv = [re.sub(r'[\n\t]', '', str(s)) for s in self.buffer]
+        assert recv == stmts, recv
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *exc_info):
+        self.dialect_cls.do_execute = self.prev_do_execute
+        self.dialect_cls.do_executemany = self.prev_do_executemany
+
+
+mocked_engine = MockedEngine

tests/session.py

@@ -41,6 +41,6 @@ class MyEnum(enum.Enum):
         MyEnum = enum.Enum('MyEnum', data)
 
         self.assertEqual(
-            self.compile(types.Enum16(MyEnum)),
-            "Enum16(' \\' t = ' = 1, 'test' = 2)"
+            self.compile(types.Enum8(MyEnum)),
+            "Enum8(' \\' t = ' = 1, 'test' = 2)"
         )

tests/test_compiler.py

@@ -4,6 +4,7 @@
 from src import types, engines, Table
 from src.sql.ddl import DropTable
 from tests.testcase import BaseTestCase
+from tests.session import mocked_engine
 
 
 class DDLTestCase(BaseTestCase):
@@ -114,7 +115,7 @@ def test_create_table_nullable_nested_nullable(self):
             'ENGINE = Memory'
         )
 
-    def test_drop_table(self):
+    def test_drop_table_clause(self):
         table = Table(
             't1', self.metadata(),
             Column('x', types.Int32, primary_key=True)
@@ -128,3 +129,13 @@ def test_drop_table(self):
             self.compile(DropTable(table, if_exists=True)),
             'DROP TABLE IF EXISTS t1'
         )
+
+    def test_table_drop(self):
+        table = Table(
+            't1', self.metadata(),
+            Column('x', types.Int32, primary_key=True)
+        )
+
+        with mocked_engine() as engine:
+            table.drop(if_exists=True)
+            engine.assert_sql(['DROP TABLE IF EXISTS t1'])

tests/test_ddl.py

@@ -61,7 +61,7 @@ class TestTable(base):
             ')'
         )
 
-    def test_index_granularity(self):
+    def test_merge_tree_index_granularity(self):
         base = get_declarative_base()
 
         class TestTable(base):
@@ -90,3 +90,61 @@ def test_create_table_without_engine(self):
             self.compile(CreateTable(no_engine_table))
 
         self.assertEqual(text_type(ex.exception), "No engine for table 't1'")
+
+    def test_collapsing_merge_tree(self):
+        base = get_declarative_base()
+
+        class TestTable(base):
+            date = Column(types.Date, primary_key=True)
+            x = Column(types.Int32)
+            y = Column(types.String)
+            sign = Column(types.Int8)
+
+            __table_args__ = (
+                engines.CollapsingMergeTree(date, (date, x), sign),
+            )
+
+        self.assertEqual(
+            self.compile(CreateTable(TestTable.__table__)),
+            'CREATE TABLE test_table '
+            '(date Date, x Int32, y String, sign Int8) '
+            'ENGINE = CollapsingMergeTree(date, (date, x), 8192, sign)'
+        )
+
+    def test_summing_merge_tree(self):
+        base = get_declarative_base()
+
+        class TestTable(base):
+            date = Column(types.Date, primary_key=True)
+            x = Column(types.Int32)
+            y = Column(types.Int32)
+
+            __table_args__ = (
+                engines.SummingMergeTree(date, (date, x), (y, )),
+            )
+
+        self.assertEqual(
+            self.compile(CreateTable(TestTable.__table__)),
+            'CREATE TABLE test_table (date Date, x Int32, y Int32) '
+            'ENGINE = SummingMergeTree(date, (date, x), 8192, (y))'
+        )
+
+    def test_buffer(self):
+        base = get_declarative_base()
+
+        class TestTable(base):
+            date = Column(types.Date, primary_key=True)
+            x = Column(types.Int32)
+            y = Column(types.String)
+
+            __table_args__ = (
+                engines.Buffer('db', 'table'),
+            )
+
+        self.assertEqual(
+            self.compile(CreateTable(TestTable.__table__)),
+            "CREATE TABLE test_table (date Date, x Int32, y String) "
+            "ENGINE = Buffer("
+            "db, table, 16, 10, 100, 10000, 1000000, 10000000, 100000000"
+            ")"
+        )