class MigrationsTestCase(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.drop_table(MigrationHistory) def tearDown(self): self.database.drop_database() def tableExists(self, model_class): query = "EXISTS TABLE $db.`%s`" % model_class.table_name() return next(self.database.select(query)).result == 1 def getTableFields(self, model_class): query = "DESC `%s`.`%s`" % (self.database.db_name, model_class.table_name()) return [(row.name, row.type) for row in self.database.select(query)] def test_migrations(self): # Creation and deletion of table self.database.migrate('tests.sample_migrations', 1) self.assertTrue(self.tableExists(Model1)) self.database.migrate('tests.sample_migrations', 2) self.assertFalse(self.tableExists(Model1)) self.database.migrate('tests.sample_migrations', 3) self.assertTrue(self.tableExists(Model1)) # Adding, removing and altering simple fields self.assertEquals(self.getTableFields(Model1), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 4) self.assertEquals(self.getTableFields(Model2), [('date', 'Date'), ('f1', 'Int32'), ('f3', 'Float32'), ('f2', 'String'), ('f4', 'String')]) self.database.migrate('tests.sample_migrations', 5) self.assertEquals(self.getTableFields(Model3), [('date', 'Date'), ('f1', 'Int64'), ('f3', 'Float64'), ('f4', 'String')]) # Altering enum fields self.database.migrate('tests.sample_migrations', 6) self.assertTrue(self.tableExists(EnumModel1)) self.assertEquals(self.getTableFields(EnumModel1), [('date', 'Date'), ('f1', "Enum8('dog' = 1, 'cat' = 2, 'cow' = 3)")]) self.database.migrate('tests.sample_migrations', 7) self.assertTrue(self.tableExists(EnumModel1)) self.assertEquals( self.getTableFields(EnumModel2), [('date', 'Date'), ('f1', "Enum16('dog' = 1, 'cat' = 2, 'horse' = 3, 'pig' = 4)")]) self.database.migrate('tests.sample_migrations', 8) self.assertTrue(self.tableExists(MaterializedModel)) self.assertEquals(self.getTableFields(MaterializedModel), [('date_time', "DateTime"), ('date', 'Date')]) self.database.migrate('tests.sample_migrations', 9) self.assertTrue(self.tableExists(AliasModel)) self.assertEquals(self.getTableFields(AliasModel), [('date', 'Date'), ('date_alias', "Date")])
class MigrationsTestCase(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.drop_table(MigrationHistory) def tableExists(self, model_class): query = "EXISTS TABLE $db.`%s`" % model_class.table_name() return next(self.database.select(query)).result == 1 def getTableFields(self, model_class): query = "DESC `%s`.`%s`" % (self.database.db_name, model_class.table_name()) return [(row.name, row.type) for row in self.database.select(query)] def test_migrations(self): self.database.migrate('tests.sample_migrations', 1) self.assertTrue(self.tableExists(Model1)) self.database.migrate('tests.sample_migrations', 2) self.assertFalse(self.tableExists(Model1)) self.database.migrate('tests.sample_migrations', 3) self.assertTrue(self.tableExists(Model1)) self.assertEquals(self.getTableFields(Model1), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 4) self.assertEquals(self.getTableFields(Model2), [('date', 'Date'), ('f1', 'Int32'), ('f3', 'Float32'), ('f2', 'String'), ('f4', 'String')]) self.database.migrate('tests.sample_migrations', 5) self.assertEquals(self.getTableFields(Model3), [('date', 'Date'), ('f1', 'Int64'), ('f3', 'Float64'), ('f4', 'String')])
class FieldsTestCase(BaseTestCase): values_to_insert = { 'id': 1, 'timestamp': timezone.now(), 'timestamp_date': timezone.now().date(), 'string_field': 'a', 'intfield': 5, 'floatfield': 0.5, 'null_field': 'b', # populate enum_field with the first value in enum_ 'enum_field': list(enum_)[0] } def setUp(self): super(FieldsTestCase, self).setUp() self.login() self.db = Database('test', settings.CLICKHOUSE_URL) self.db.create_table(ClickhouseAllFields) object1 = ClickhouseAllFields(**self.values_to_insert) self.db.insert([object1]) def tearDown(self): self.db.drop_table(ClickhouseAllFields) self.db.drop_database() def test_all_fields_exists(self): res = self.client.get('/api/rest/allfields/') result = res.json()['result'] # check that each key exists and stores a value for key, val in self.values_to_insert.items(): # not comparing the values due to differences in case of datetime fields etc. that test is being done in # test_fields anyway self.assertIsNotNone(result[0].get(key)) def test_partial_fields(self): res = self.client.get('/api/rest/partialfields/') result = res.json()['result'] for key in result[0].keys(): self.assertTrue(key in PARTIAL_FIELDS) def test_exclude_fields(self): res = self.client.get('/api/rest/excludefields/') result = res.json()['result'] for key in EXCLUDE_FIELDS: self.assertFalse(key in result[0])
class TestCaseWithData(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.create_table(Person) def tearDown(self): self.database.drop_table(Person) self.database.drop_database() def _insert_and_check(self, data, count): self.database.insert(data) self.assertEquals(count, self.database.count(Person)) for instance in data: self.assertEquals(self.database, instance.get_database()) def _sample_data(self): for entry in data: yield Person(**entry)
class ReadonlyTestCase(TestCaseWithData): def _test_readonly_db(self, username): self._insert_and_check(self._sample_data(), len(data)) orig_database = self.database try: self.database = Database(orig_database.db_name, username=username, readonly=True) with self.assertRaises(DatabaseException): self._insert_and_check(self._sample_data(), len(data)) self.assertEquals(self.database.count(Person), 100) list(self.database.select('SELECT * from $table', Person)) with self.assertRaises(DatabaseException): self.database.drop_table(Person) with self.assertRaises(DatabaseException): self.database.drop_database() except DatabaseException as e: if 'Unknown user' in six.text_type(e): raise unittest.SkipTest('Database user "%s" is not defined' % username) else: raise finally: self.database = orig_database def test_readonly_db_with_default_user(self): self._test_readonly_db('default') def test_readonly_db_with_readonly_user(self): self._test_readonly_db('readonly') def test_insert_readonly(self): m = ReadOnlyModel(name='readonly') with self.assertRaises(DatabaseException): self.database.insert([m]) def test_create_readonly_table(self): with self.assertRaises(DatabaseException): self.database.create_table(ReadOnlyModel) def test_drop_readonly_table(self): with self.assertRaises(DatabaseException): self.database.drop_table(ReadOnlyModel)
class SystemTest(unittest.TestCase): def setUp(self): self.database = Database('test-db') def tearDown(self): self.database.drop_database() def test_insert_system(self): m = SystemPart() with self.assertRaises(DatabaseException): self.database.insert([m]) def test_create_readonly_table(self): with self.assertRaises(DatabaseException): self.database.create_table(SystemTestModel) def test_drop_readonly_table(self): with self.assertRaises(DatabaseException): self.database.drop_table(SystemTestModel)
class TestCaseWithData(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.create_table(Person) def tearDown(self): self.database.drop_table(Person) self.database.drop_database() def _insert_and_check(self, data, count, batch_size=1000): self.database.insert(data, batch_size=batch_size) self.assertEqual(count, self.database.count(Person)) for instance in data: self.assertEqual(self.database, instance.get_database()) def _sample_data(self): for entry in data: yield Person(**entry)
class TestCaseWithData(unittest.TestCase): def setUp(self): self.database = Database('test-db', log_statements=True) self.database.create_table(Person) def tearDown(self): self.database.drop_table(Person) self.database.drop_database() def _insert_all(self): self.database.insert(self._sample_data()) self.assertTrue(self.database.count(Person)) def _insert_and_check(self, data, count, batch_size=1000): self.database.insert(data, batch_size=batch_size) self.assertEqual(count, self.database.count(Person)) for instance in data: self.assertEqual(self.database, instance.get_database()) def _sample_data(self): for entry in data: yield Person(**entry)
class MigrationsTestCase(unittest.TestCase): def setUp(self): self.database = Database('test-db', log_statements=True) self.database.drop_table(MigrationHistory) def tearDown(self): self.database.drop_database() def table_exists(self, model_class): query = "EXISTS TABLE $db.`%s`" % model_class.table_name() return next(self.database.select(query)).result == 1 def get_table_fields(self, model_class): query = "DESC `%s`.`%s`" % (self.database.db_name, model_class.table_name()) return [(row.name, row.type) for row in self.database.select(query)] def get_table_def(self, model_class): return self.database.raw('SHOW CREATE TABLE $db.`%s`' % model_class.table_name()) def test_migrations(self): # Creation and deletion of table self.database.migrate('tests.sample_migrations', 1) self.assertTrue(self.table_exists(Model1)) self.database.migrate('tests.sample_migrations', 2) self.assertFalse(self.table_exists(Model1)) self.database.migrate('tests.sample_migrations', 3) self.assertTrue(self.table_exists(Model1)) # Adding, removing and altering simple fields self.assertEqual(self.get_table_fields(Model1), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 4) self.assertEqual(self.get_table_fields(Model2), [('date', 'Date'), ('f1', 'Int32'), ('f3', 'Float32'), ('f2', 'String'), ('f4', 'String'), ('f5', 'Array(UInt64)')]) self.database.migrate('tests.sample_migrations', 5) self.assertEqual(self.get_table_fields(Model3), [('date', 'Date'), ('f1', 'Int64'), ('f3', 'Float64'), ('f4', 'String')]) # Altering enum fields self.database.migrate('tests.sample_migrations', 6) self.assertTrue(self.table_exists(EnumModel1)) self.assertEqual(self.get_table_fields(EnumModel1), [('date', 'Date'), ('f1', "Enum8('dog' = 1, 'cat' = 2, 'cow' = 3)")]) self.database.migrate('tests.sample_migrations', 7) self.assertTrue(self.table_exists(EnumModel1)) self.assertEqual( self.get_table_fields(EnumModel2), [('date', 'Date'), ('f1', "Enum16('dog' = 1, 'cat' = 2, 'horse' = 3, 'pig' = 4)")]) # Materialized fields and alias fields self.database.migrate('tests.sample_migrations', 8) self.assertTrue(self.table_exists(MaterializedModel)) self.assertEqual(self.get_table_fields(MaterializedModel), [('date_time', "DateTime"), ('date', 'Date')]) self.database.migrate('tests.sample_migrations', 9) self.assertTrue(self.table_exists(AliasModel)) self.assertEqual(self.get_table_fields(AliasModel), [('date', 'Date'), ('date_alias', "Date")]) # Buffer models creation and alteration self.database.migrate('tests.sample_migrations', 10) self.assertTrue(self.table_exists(Model4)) self.assertTrue(self.table_exists(Model4Buffer)) self.assertEqual(self.get_table_fields(Model4), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.assertEqual(self.get_table_fields(Model4Buffer), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 11) self.assertEqual(self.get_table_fields(Model4), [('date', 'Date'), ('f3', 'DateTime'), ('f2', 'String')]) self.assertEqual(self.get_table_fields(Model4Buffer), [('date', 'Date'), ('f3', 'DateTime'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 12) self.assertEqual(self.database.count(Model3), 3) data = [ item.f1 for item in self.database.select( 'SELECT f1 FROM $table ORDER BY f1', model_class=Model3) ] self.assertListEqual(data, [1, 2, 3]) self.database.migrate('tests.sample_migrations', 13) self.assertEqual(self.database.count(Model3), 4) data = [ item.f1 for item in self.database.select( 'SELECT f1 FROM $table ORDER BY f1', model_class=Model3) ] self.assertListEqual(data, [1, 2, 3, 4]) self.database.migrate('tests.sample_migrations', 14) self.assertTrue(self.table_exists(MaterializedModel1)) self.assertEqual(self.get_table_fields(MaterializedModel1), [('date_time', 'DateTime'), ('int_field', 'Int8'), ('date', 'Date'), ('int_field_plus_one', 'Int8')]) self.assertTrue(self.table_exists(AliasModel1)) self.assertEqual(self.get_table_fields(AliasModel1), [('date', 'Date'), ('int_field', 'Int8'), ('date_alias', 'Date'), ('int_field_plus_one', 'Int8')]) # Codecs and low cardinality self.database.migrate('tests.sample_migrations', 15) self.assertTrue(self.table_exists(Model4_compressed)) if self.database.has_low_cardinality_support: self.assertEqual(self.get_table_fields(Model2LowCardinality), [('date', 'Date'), ('f1', 'LowCardinality(Int32)'), ('f3', 'LowCardinality(Float32)'), ('f2', 'LowCardinality(String)'), ('f4', 'LowCardinality(Nullable(String))'), ('f5', 'Array(LowCardinality(UInt64))')]) else: logging.warning('No support for low cardinality') self.assertEqual(self.get_table_fields(Model2), [('date', 'Date'), ('f1', 'Int32'), ('f3', 'Float32'), ('f2', 'String'), ('f4', 'Nullable(String)'), ('f5', 'Array(UInt64)')]) if self.database.server_version >= (19, 14, 3, 3): # Creating constraints self.database.migrate('tests.sample_migrations', 16) self.assertTrue(self.table_exists(ModelWithConstraints)) self.database.insert([ModelWithConstraints(f1=101, f2='a')]) with self.assertRaises(ServerError): self.database.insert([ModelWithConstraints(f1=99, f2='a')]) with self.assertRaises(ServerError): self.database.insert([ModelWithConstraints(f1=101, f2='x')]) # Modifying constraints self.database.migrate('tests.sample_migrations', 17) self.database.insert([ModelWithConstraints(f1=99, f2='a')]) with self.assertRaises(ServerError): self.database.insert([ModelWithConstraints(f1=101, f2='a')]) with self.assertRaises(ServerError): self.database.insert([ModelWithConstraints(f1=99, f2='x')]) if self.database.server_version >= (20, 1, 2, 4): # Creating indexes self.database.migrate('tests.sample_migrations', 18) self.assertTrue(self.table_exists(ModelWithIndex)) self.assertIn('INDEX index ', self.get_table_def(ModelWithIndex)) self.assertIn('INDEX another_index ', self.get_table_def(ModelWithIndex)) # Modifying indexes self.database.migrate('tests.sample_migrations', 19) self.assertNotIn('INDEX index ', self.get_table_def(ModelWithIndex)) self.assertIn('INDEX index2 ', self.get_table_def(ModelWithIndex)) self.assertIn('INDEX another_index ', self.get_table_def(ModelWithIndex))
class DatabaseTestCase(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.create_table(Person) def tearDown(self): self.database.drop_table(Person) self.database.drop_database() def _insert_and_check(self, data, count): self.database.insert(data) self.assertEquals(count, self.database.count(Person)) def test_insert__generator(self): self._insert_and_check(self._sample_data(), len(data)) def test_insert__list(self): self._insert_and_check(list(self._sample_data()), len(data)) def test_insert__iterator(self): self._insert_and_check(iter(self._sample_data()), len(data)) def test_insert__empty(self): self._insert_and_check([], 0) def test_count(self): self.database.insert(self._sample_data()) self.assertEquals(self.database.count(Person), 100) self.assertEquals(self.database.count(Person, "first_name = 'Courtney'"), 2) self.assertEquals(self.database.count(Person, "birthday > '2000-01-01'"), 22) self.assertEquals(self.database.count(Person, "birthday < '1970-03-01'"), 0) def test_select(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT * FROM `test-db`.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query, Person)) self.assertEquals(len(results), 2) self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 1.72) self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 1.70) def test_select_partial_fields(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT first_name, last_name FROM `test-db`.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query, Person)) self.assertEquals(len(results), 2) self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 0) # default value self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 0) # default value def test_select_ad_hoc_model(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT * FROM `test-db`.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query)) self.assertEquals(len(results), 2) self.assertEquals(results[0].__class__.__name__, 'AdHocModel') self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 1.72) self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 1.70) def test_pagination(self): self._insert_and_check(self._sample_data(), len(data)) # Try different page sizes for page_size in (1, 2, 7, 10, 30, 100, 150): # Iterate over pages and collect all intances page_num = 1 instances = set() while True: page = self.database.paginate(Person, 'first_name, last_name', page_num, page_size) self.assertEquals(page.number_of_objects, len(data)) self.assertGreater(page.pages_total, 0) [instances.add(obj.to_tsv()) for obj in page.objects] if page.pages_total == page_num: break page_num += 1 # Verify that all instances were returned self.assertEquals(len(instances), len(data)) def test_pagination_last_page(self): self._insert_and_check(self._sample_data(), len(data)) # Try different page sizes for page_size in (1, 2, 7, 10, 30, 100, 150): # Ask for the last page in two different ways and verify equality page_a = self.database.paginate(Person, 'first_name, last_name', -1, page_size) page_b = self.database.paginate(Person, 'first_name, last_name', page_a.pages_total, page_size) self.assertEquals(page_a[1:], page_b[1:]) self.assertEquals([obj.to_tsv() for obj in page_a.objects], [obj.to_tsv() for obj in page_b.objects]) def test_pagination_invalid_page(self): self._insert_and_check(self._sample_data(), len(data)) for page_num in (0, -2, -100): with self.assertRaises(ValueError): self.database.paginate(Person, 'first_name, last_name', page_num, 100) def test_special_chars(self): s = u'אבגד \\\'"`,.;éåäöšž\n\t\0\b\r' p = Person(first_name=s) self.database.insert([p]) p = list(self.database.select("SELECT * from $table", Person))[0] self.assertEquals(p.first_name, s) def _sample_data(self): for entry in data: yield Person(**entry)
class MigrationsTestCase(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.drop_table(MigrationHistory) def tearDown(self): self.database.drop_database() def tableExists(self, model_class): query = "EXISTS TABLE $db.`%s`" % model_class.table_name() return next(self.database.select(query)).result == 1 def getTableFields(self, model_class): query = "DESC `%s`.`%s`" % (self.database.db_name, model_class.table_name()) return [(row.name, row.type) for row in self.database.select(query)] def test_migrations(self): # Creation and deletion of table self.database.migrate('tests.sample_migrations', 1) self.assertTrue(self.tableExists(Model1)) self.database.migrate('tests.sample_migrations', 2) self.assertFalse(self.tableExists(Model1)) self.database.migrate('tests.sample_migrations', 3) self.assertTrue(self.tableExists(Model1)) # Adding, removing and altering simple fields self.assertEqual(self.getTableFields(Model1), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 4) self.assertEqual(self.getTableFields(Model2), [('date', 'Date'), ('f1', 'Int32'), ('f3', 'Float32'), ('f2', 'String'), ('f4', 'String'), ('f5', 'Array(UInt64)')]) self.database.migrate('tests.sample_migrations', 5) self.assertEqual(self.getTableFields(Model3), [('date', 'Date'), ('f1', 'Int64'), ('f3', 'Float64'), ('f4', 'String')]) # Altering enum fields self.database.migrate('tests.sample_migrations', 6) self.assertTrue(self.tableExists(EnumModel1)) self.assertEqual(self.getTableFields(EnumModel1), [('date', 'Date'), ('f1', "Enum8('dog' = 1, 'cat' = 2, 'cow' = 3)")]) self.database.migrate('tests.sample_migrations', 7) self.assertTrue(self.tableExists(EnumModel1)) self.assertEqual(self.getTableFields(EnumModel2), [('date', 'Date'), ('f1', "Enum16('dog' = 1, 'cat' = 2, 'horse' = 3, 'pig' = 4)")]) # Materialized fields and alias fields self.database.migrate('tests.sample_migrations', 8) self.assertTrue(self.tableExists(MaterializedModel)) self.assertEqual(self.getTableFields(MaterializedModel), [('date_time', "DateTime"), ('date', 'Date')]) self.database.migrate('tests.sample_migrations', 9) self.assertTrue(self.tableExists(AliasModel)) self.assertEqual(self.getTableFields(AliasModel), [('date', 'Date'), ('date_alias', "Date")]) # Buffer models creation and alteration self.database.migrate('tests.sample_migrations', 10) self.assertTrue(self.tableExists(Model4)) self.assertTrue(self.tableExists(Model4Buffer)) self.assertEqual(self.getTableFields(Model4), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.assertEqual(self.getTableFields(Model4Buffer), [('date', 'Date'), ('f1', 'Int32'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 11) self.assertEqual(self.getTableFields(Model4), [('date', 'Date'), ('f3', 'DateTime'), ('f2', 'String')]) self.assertEqual(self.getTableFields(Model4Buffer), [('date', 'Date'), ('f3', 'DateTime'), ('f2', 'String')]) self.database.migrate('tests.sample_migrations', 12) self.assertEqual(self.database.count(Model3), 3) data = [item.f1 for item in self.database.select('SELECT f1 FROM $table ORDER BY f1', model_class=Model3)] self.assertListEqual(data, [1, 2, 3]) self.database.migrate('tests.sample_migrations', 13) self.assertEqual(self.database.count(Model3), 4) data = [item.f1 for item in self.database.select('SELECT f1 FROM $table ORDER BY f1', model_class=Model3)] self.assertListEqual(data, [1, 2, 3, 4]) self.database.migrate('tests.sample_migrations', 14) self.assertTrue(self.tableExists(MaterializedModel1)) self.assertEqual(self.getTableFields(MaterializedModel1), [('date_time', 'DateTime'), ('int_field', 'Int8'), ('date', 'Date'), ('int_field_plus_one', 'Int8')]) self.assertTrue(self.tableExists(AliasModel1)) self.assertEqual(self.getTableFields(AliasModel1), [('date', 'Date'), ('int_field', 'Int8'), ('date_alias', 'Date'), ('int_field_plus_one', 'Int8')])
class DatabaseTestCase(unittest.TestCase): def setUp(self): self.database = Database('test_db') self.database.create_table(Person) def tearDown(self): self.database.drop_table(Person) self.database.drop_database() def _insert_and_check(self, data, count): self.database.insert(data) self.assertEquals(count, self.database.count(Person)) def test_insert__generator(self): self._insert_and_check(self._sample_data(), len(data)) def test_insert__list(self): self._insert_and_check(list(self._sample_data()), len(data)) def test_insert__iterator(self): self._insert_and_check(iter(self._sample_data()), len(data)) def test_insert__empty(self): self._insert_and_check([], 0) def test_count(self): self.database.insert(self._sample_data()) self.assertEquals(self.database.count(Person), 100) self.assertEquals(self.database.count(Person, "first_name = 'Courtney'"), 2) self.assertEquals(self.database.count(Person, "birthday > '2000-01-01'"), 22) self.assertEquals(self.database.count(Person, "birthday < '1970-03-01'"), 0) def test_select(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT * FROM test_db.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query, Person)) self.assertEquals(len(results), 2) self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 1.72) self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 1.70) def test_select_partial_fields(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT first_name, last_name FROM test_db.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query, Person)) self.assertEquals(len(results), 2) self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 0) # default value self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 0) # default value def test_select_ad_hoc_model(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT * FROM test_db.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query)) self.assertEquals(len(results), 2) self.assertEquals(results[0].__class__.__name__, 'AdHocModel') self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 1.72) self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 1.70) def _sample_data(self): for entry in data: yield Person(**entry)
class FieldsTestCase(BaseTestCase): values_to_insert = [ { 'id': 1, 'timestamp': timezone.now(), 'timestamp_date': timezone.now().date(), 'string_field': 'a', 'intfield': 5, 'floatfield': 0.5, 'null_field': 'b', # populate enum_field with the first value in enum_ 'enum_field': list(enum_)[0] }, { 'id': 2, 'timestamp': timezone.now(), 'timestamp_date': timezone.now().date(), 'string_field': 'c', 'intfield': 10, 'floatfield': 0.1, 'null_field': 'd', # populate enum_field with the first value in enum_ 'enum_field': list(enum_)[0] }, ] def setUp(self): super(FieldsTestCase, self).setUp() self.login() self.db = Database('test', settings.CLICKHOUSE_URL) self.db.create_table(ClickhouseAllFields) object1 = ClickhouseAllFields(**self.values_to_insert[0]) object2 = ClickhouseAllFields(**self.values_to_insert[1]) self.db.insert([object1, object2]) def tearDown(self): self.db.drop_table(ClickhouseAllFields) self.db.drop_database() def test_effective_filter(self): res = self.client.get('/api/rest/allfields/', {'string_field': 'eq:a'}) result = res.json()['result'] self.assertTrue(result) def test_not_effective_filter(self): res = self.client.get('/api/rest/allfields/', {'string_field': 'eq:z'}) result = res.json()['result'] self.assertFalse(result) def test_filter_startswith(self): res = self.client.get('/api/rest/allfields/', {'null_field': 'starts_with:b'}) result = res.json()['result'] self.assertTrue(result) def test_filter_endsswith(self): res = self.client.get('/api/rest/allfields/', {'null_field': 'ends_with:d'}) result = res.json()['result'] self.assertTrue(result) def test_filterable_fields(self): # send a request with a filter which is not in the get_filterable_fields in the serializer of the view # to check that the request failed res = self.client.get('/api/rest/filterablefields/', {'id': 1}) self.assertEqual(res.status_code, 400) def test_sorting(self): res = self.client.get('/api/rest/allfields/', {'sort': '-id'}) result = res.json()['result'] self.assertTrue(result[0]['id'] == 2 and result[1]['id'] == 1)
class FieldsTestCase(BaseTestCase): # a script to test the serializer of clickhouse_django_rest_utils values_to_insert = { 'id': 1, 'timestamp': timezone.now(), 'timestamp_date': timezone.now().date(), 'string_field': 'aaaaa', 'intfield': 5, 'floatfield': 0.5, 'null_field': 'bbbbb', # populate enum_field with the first value in enum_ 'enum_field': list(enum_)[0], 'array_field': [10, 20, 30, 40, 50] } def setUp(self): self.db = Database('test', settings.CLICKHOUSE_URL) self.db.create_table(ClickhouseAllFields) self.object = ClickhouseAllFields(**self.values_to_insert) self.db.insert([self.object]) def tearDown(self): self.db.drop_table(ClickhouseAllFields) self.db.drop_database() def test_simple_fields(self): simple_fields = ['string_field', 'intfield', 'floatfield'] obj = ClickhouseAllFields.objects_in(self.db)[0] serialized = AllFieldsSerializer(obj) serialized_data = serialized.data for field in simple_fields: self.assertEqual(self.values_to_insert.get(field), serialized_data.get(field)) def test_dates_fields(self): obj = ClickhouseAllFields.objects_in(self.db)[0] serialized = AllFieldsSerializer(obj) serialized_data = serialized.data for field in ['timestamp', 'timestamp_date']: self.assertEqual( parser.parse( serialized_data.get(field)).strftime("%Y-%m-%d %H:%M:%S"), self.values_to_insert.get(field).strftime("%Y-%m-%d %H:%M:%S")) def test_nullable_field(self): obj = ClickhouseAllFields.objects_in(self.db)[0] serialized = AllFieldsSerializer(obj) self.assertEqual(serialized.data.get('null_field'), self.values_to_insert.get('null_field')) def test_enum_fields(self): obj = ClickhouseAllFields.objects_in(self.db)[0] serialized = AllFieldsSerializer(obj) self.assertEqual( serialized.data.get('enum_field'), # take the name of the selected option in self.values_to_insert self.values_to_insert.get('enum_field').name) def test_array_fields(self): obj = ClickhouseAllFields.objects_in(self.db)[0] serialized = AllFieldsSerializer(obj) self.assertEqual(serialized.data.get('array_field'), self.values_to_insert.get('array_field'))
class DatabaseTestCase(unittest.TestCase): def setUp(self): self.database = Database('test-db') self.database.create_table(Person) def tearDown(self): self.database.drop_table(Person) self.database.drop_database() def _insert_and_check(self, data, count): self.database.insert(data) self.assertEquals(count, self.database.count(Person)) def test_insert__generator(self): self._insert_and_check(self._sample_data(), len(data)) def test_insert__list(self): self._insert_and_check(list(self._sample_data()), len(data)) def test_insert__iterator(self): self._insert_and_check(iter(self._sample_data()), len(data)) def test_insert__empty(self): self._insert_and_check([], 0) def test_count(self): self.database.insert(self._sample_data()) self.assertEquals(self.database.count(Person), 100) self.assertEquals(self.database.count(Person, "first_name = 'Courtney'"), 2) self.assertEquals(self.database.count(Person, "birthday > '2000-01-01'"), 22) self.assertEquals(self.database.count(Person, "birthday < '1970-03-01'"), 0) def test_select(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT * FROM `test-db`.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query, Person)) self.assertEquals(len(results), 2) self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 1.72) self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 1.70) def test_select_partial_fields(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT first_name, last_name FROM `test-db`.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query, Person)) self.assertEquals(len(results), 2) self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 0) # default value self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 0) # default value def test_select_ad_hoc_model(self): self._insert_and_check(self._sample_data(), len(data)) query = "SELECT * FROM `test-db`.person WHERE first_name = 'Whitney' ORDER BY last_name" results = list(self.database.select(query)) self.assertEquals(len(results), 2) self.assertEquals(results[0].__class__.__name__, 'AdHocModel') self.assertEquals(results[0].last_name, 'Durham') self.assertEquals(results[0].height, 1.72) self.assertEquals(results[1].last_name, 'Scott') self.assertEquals(results[1].height, 1.70) def test_pagination(self): self._insert_and_check(self._sample_data(), len(data)) # Try different page sizes for page_size in (1, 2, 7, 10, 30, 100, 150): # Iterate over pages and collect all intances page_num = 1 instances = set() while True: page = self.database.paginate(Person, 'first_name, last_name', page_num, page_size) self.assertEquals(page.number_of_objects, len(data)) self.assertGreater(page.pages_total, 0) [instances.add(obj.to_tsv()) for obj in page.objects] if page.pages_total == page_num: break page_num += 1 # Verify that all instances were returned self.assertEquals(len(instances), len(data)) def _sample_data(self): for entry in data: yield Person(**entry)