def test_static_columns(self): class StaticModel(Model): id = columns.Integer(primary_key=True) c = columns.Integer(primary_key=True) name = columns.Text(static=True) drop_table(StaticModel) session = get_session() with mock.patch.object(session, "execute", wraps=session.execute) as m: sync_table(StaticModel) self.assertGreater(m.call_count, 0) statement = m.call_args[0][0].query_string self.assertIn('"name" text static', statement) # if we sync again, we should not apply an alter w/ a static sync_table(StaticModel) with mock.patch.object(session, "execute", wraps=session.execute) as m2: sync_table(StaticModel) self.assertEqual(len(m2.call_args_list), 0)
def test_extra_field(self): drop_table(self.TestModel) sync_table(self.TestModel) self.TestModel.create() execute("ALTER TABLE {0} add blah int".format( self.TestModel.column_family_name(include_keyspace=True))) self.TestModel.objects().all()
def test_table_definition(self): """ Tests that creating a table with capitalized column names succeeds """ sync_table(LowercaseKeyModel) sync_table(CapitalizedKeyModel) drop_table(LowercaseKeyModel) drop_table(CapitalizedKeyModel)
def test_model_over_write(self): """ Test to ensure overwriting of primary keys in model inheritance is allowed This is currently only an issue in PyPy. When PYTHON-504 is introduced this should be updated error out and warn the user @since 3.6.0 @jira_ticket PYTHON-576 @expected_result primary keys can be overwritten via inheritance @test_category object_mapper """ class TimeModelBase(Model): uuid = columns.TimeUUID(primary_key=True) class DerivedTimeModel(TimeModelBase): __table_name__ = 'derived_time' uuid = columns.TimeUUID(primary_key=True, partition_key=True) value = columns.Text(required=False) # In case the table already exists in keyspace drop_table(DerivedTimeModel) sync_table(DerivedTimeModel) uuid_value = uuid1() uuid_value2 = uuid1() DerivedTimeModel.create(uuid=uuid_value, value="first") DerivedTimeModel.create(uuid=uuid_value2, value="second") DerivedTimeModel.objects.filter(uuid=uuid_value)
def setUpClass(cls): if PROTOCOL_VERSION < 4: return super(TestQuerying, cls).setUpClass() drop_table(TestQueryModel) sync_table(TestQueryModel)
def tearDownClass(cls): super(ContextQueryConnectionTests, cls).tearDownClass() with ContextQuery(TestModel, connection='cluster') as tm: drop_table(tm) drop_keyspace('ks1', connections=['cluster']) # reset the default connection conn.unregister_connection('fake_cluster') conn.unregister_connection('cluster') setup_connection(DEFAULT_KEYSPACE)
def test_keywords_as_names(self): """ Test for CQL keywords as names test_keywords_as_names tests that CQL keywords are properly and automatically quoted in cqlengine. It creates a keyspace, keyspace, which should be automatically quoted to "keyspace" in CQL. It then creates a table, table, which should also be automatically quoted to "table". It then verfies that operations can be done on the "keyspace"."table" which has been created. It also verifies that table alternations work and operations can be performed on the altered table. @since 2.6.0 @jira_ticket PYTHON-244 @expected_result Cqlengine should quote CQL keywords properly when creating keyspaces and tables. @test_category schema:generation """ # If the keyspace exists, it will not be re-created create_keyspace_simple('keyspace', 1) class table(Model): __keyspace__ = 'keyspace' select = columns.Integer(primary_key=True) table = columns.Text() # In case the table already exists in keyspace drop_table(table) # Create should work sync_table(table) created = table.create(select=0, table='table') selected = table.objects(select=0)[0] self.assertEqual(created.select, selected.select) self.assertEqual(created.table, selected.table) # Alter should work class table(Model): __keyspace__ = 'keyspace' select = columns.Integer(primary_key=True) table = columns.Text() where = columns.Text() sync_table(table) created = table.create(select=1, table='table') selected = table.objects(select=1)[0] self.assertEqual(created.select, selected.select) self.assertEqual(created.table, selected.table) self.assertEqual(created.where, selected.where) drop_keyspace('keyspace')
def test_clustering_order_more_complex(self): """ Tests that models can be saved and retrieved """ sync_table(TestClusteringComplexModel) items = list(range(20)) random.shuffle(items) for i in items: TestClusteringComplexModel.create(id=1, clustering_key=i, some_value=2) values = list(TestClusteringComplexModel.objects.values_list('some_value', flat=True)) self.assertEqual([2] * 20, values) drop_table(TestClusteringComplexModel)
def test_alter_actually_alters(self): tmp = copy.deepcopy(LeveledCompactionTestTable) drop_table(tmp) sync_table(tmp) tmp.__options__ = { 'compaction': { 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy' } } sync_table(tmp) table_meta = _get_table_metadata(tmp) self.assertRegexpMatches(table_meta.export_as_string(), '.*SizeTieredCompactionStrategy.*')
def test_concrete_class_table_creation_cycle(self): """ Tests that models with inherited abstract classes can be created, and have io performed """ from dse.cqlengine.management import sync_table, drop_table sync_table(ConcreteModelWithCol) w1 = ConcreteModelWithCol.create(pkey=5, data=6) w2 = ConcreteModelWithCol.create(pkey=6, data=7) r1 = ConcreteModelWithCol.get(pkey=5) r2 = ConcreteModelWithCol.get(pkey=6) assert w1.pkey == r1.pkey assert w1.data == r1.data assert w2.pkey == r2.pkey assert w2.data == r2.data drop_table(ConcreteModelWithCol)
def test_all_leveled_options(self): class AllLeveledOptionsModel(Model): __options__ = { 'compaction': { 'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy', 'sstable_size_in_mb': '64' } } cid = columns.UUID(primary_key=True) name = columns.Text() drop_table(AllLeveledOptionsModel) sync_table(AllLeveledOptionsModel) table_meta = _get_table_metadata(AllLeveledOptionsModel) self._verify_options(table_meta, AllLeveledOptionsModel.__options__)
def test_batch_execute_on_exception_succeeds(self): # makes sure if execute_on_exception == True we still apply the batch drop_table(BatchQueryLogModel) sync_table(BatchQueryLogModel) obj = BatchQueryLogModel.objects(k=1) self.assertEqual(0, len(obj)) try: with BatchQuery(execute_on_exception=True) as b: BatchQueryLogModel.batch(b).create(k=1, v=1) raise Exception("Blah") except: pass obj = BatchQueryLogModel.objects(k=1) # should be 1 because the batch should execute self.assertEqual(1, len(obj))
def test_compaction_not_altered_without_changes_leveled(self): class LeveledCompactionChangesDetectionTest(Model): __options__ = { 'compaction': { 'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy', 'sstable_size_in_mb': '160', 'tombstone_threshold': '0.125', 'tombstone_compaction_interval': '3600' } } pk = columns.Integer(primary_key=True) drop_table(LeveledCompactionChangesDetectionTest) sync_table(LeveledCompactionChangesDetectionTest) self.assertFalse( _update_options(LeveledCompactionChangesDetectionTest))
def test_batch_execute_on_exception_skips_if_not_specified(self): # makes sure if execute_on_exception == True we still apply the batch drop_table(BatchQueryLogModel) sync_table(BatchQueryLogModel) obj = BatchQueryLogModel.objects(k=2) self.assertEqual(0, len(obj)) try: with BatchQuery() as b: BatchQueryLogModel.batch(b).create(k=2, v=2) raise Exception("Blah") except: pass obj = BatchQueryLogModel.objects(k=2) # should be 0 because the batch should not execute self.assertEqual(0, len(obj))
def test_all_size_tiered_options(self): class AllSizeTieredOptionsModel(Model): __options__ = { 'compaction': { 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'bucket_low': '.3', 'bucket_high': '2', 'min_threshold': '2', 'max_threshold': '64', 'tombstone_compaction_interval': '86400' } } cid = columns.UUID(primary_key=True) name = columns.Text() drop_table(AllSizeTieredOptionsModel) sync_table(AllSizeTieredOptionsModel) table_meta = _get_table_metadata(AllSizeTieredOptionsModel) self._verify_options(table_meta, AllSizeTieredOptionsModel.__options__)
def test_compaction_not_altered_without_changes_sizetiered(self): class SizeTieredCompactionChangesDetectionTest(Model): __options__ = { 'compaction': { 'class': 'org.apache.cassandra.db.compaction.SizeTieredCompactionStrategy', 'bucket_high': '20', 'bucket_low': '10', 'max_threshold': '200', 'min_threshold': '100', 'min_sstable_size': '1000', 'tombstone_threshold': '0.125', 'tombstone_compaction_interval': '3600' } } pk = columns.Integer(primary_key=True) drop_table(SizeTieredCompactionChangesDetectionTest) sync_table(SizeTieredCompactionChangesDetectionTest) self.assertFalse( _update_options(SizeTieredCompactionChangesDetectionTest))
def test_alter_options(self): class AlterTable(Model): __options__ = { 'compaction': { 'class': 'org.apache.cassandra.db.compaction.LeveledCompactionStrategy', 'sstable_size_in_mb': '64' } } user_id = columns.UUID(primary_key=True) name = columns.Text() drop_table(AlterTable) sync_table(AlterTable) table_meta = _get_table_metadata(AlterTable) self.assertRegexpMatches(table_meta.export_as_string(), ".*'sstable_size_in_mb': '64'.*") AlterTable.__options__['compaction']['sstable_size_in_mb'] = '128' sync_table(AlterTable) table_meta = _get_table_metadata(AlterTable) self.assertRegexpMatches(table_meta.export_as_string(), ".*'sstable_size_in_mb': '128'.*")
def test_create_drop_table(self): """ Tests drop and create Table with connections explicitly set @since 3.7 @jira_ticket PYTHON-613 @expected_result Tables should be created and dropped @test_category object_mapper """ for ks in self.keyspaces: create_keyspace_simple(ks, 1, connections=self.conns) # No connection (default is fake) with self.assertRaises(NoHostAvailable): sync_table(TestModel) # Explicit connections sync_table(TestModel, connections=self.conns) # Explicit drop drop_table(TestModel, connections=self.conns) # Model connection TestModel.__connection__ = 'cluster' sync_table(TestModel) TestModel.__connection__ = None # No connection (default is fake) with self.assertRaises(NoHostAvailable): drop_table(TestModel) # Model connection TestModel.__connection__ = 'cluster' drop_table(TestModel) TestModel.__connection__ = None # Model connection for ks in self.keyspaces: drop_keyspace(ks, connections=self.conns)
def setUp(self): drop_table(ModelWithTableProperties)
def test_alter_is_called_table(self): drop_table(LeveledCompactionTestTable) sync_table(LeveledCompactionTestTable) with patch('dse.cqlengine.management._update_options') as mock: sync_table(LeveledCompactionTestTable) assert mock.called == 1
def tearDownClass(cls): super(ModelUpdateTests, cls).tearDownClass() drop_table(TestUpdateModel)
def tearDownClass(cls): super(BaseColumnIOTest, cls).tearDownClass() if not cls.column: return drop_table(cls._generated_model)
def tearDownClass(cls): super(BaseIfNotExistsWithCounterTest, cls).tearDownClass() drop_table(TestIfNotExistsWithCounterModel)
def tearDownClass(cls): super(BaseIfNotExistsTest, cls).tearDownClass() drop_table(TestIfNotExistsModel)
def test_multiple_deletes_dont_fail(self): sync_table(TestModel) drop_table(TestModel) drop_table(TestModel)
def setUp(self): drop_table(FirstModel)
def setUp(self): drop_table(IndexModel) drop_table(IndexCaseSensitiveModel)
def setUp(self): drop_table(IndexModel)
def tearDownClass(cls): super(TestClusteringOrder, cls).tearDownClass() drop_table(TestModel)
def setUp(self): drop_table(PrimaryKeysOnlyModel)