def fuzzify(engine, config): """Do the actual fuzzification based on the loaded attributes of the models.""" modelObjects = {} Session = sessionmaker(bind=engine) session = Session() metadata = MetaData(bind=engine, reflect=True) cascade_fkeys(metadata) for table_name, columns in config.items(): tables = [] if table_name in metadata.tables.keys(): tables.append(utils.get_table(engine, table_name)) if 'shadow_' + table_name in metadata.tables.keys(): tables.append(utils.get_table(engine, 'shadow_' + table_name)) for table in tables: print "Doing table: " + str(table) modelObjects[table] = type('Model_' + str(table), (object, ), {}) mapper(modelObjects[table], table) q = session.query(modelObjects[table]) for row in q.all(): for column, column_type in columns.items(): if hasattr(row, column): before = getattr(row, column) after = randomness(before, column_type) setattr(row, column, after) cascade_fkeys(metadata, restore=True) session.commit() session.flush()
def downgrade(migrate_engine): actions_events = utils.get_table(migrate_engine, 'instance_actions_events') actions_events.drop_column('host') actions_events.drop_column('details') shadow_actions_events = utils.get_table(migrate_engine, api._SHADOW_TABLE_PREFIX + 'instance_actions_events') shadow_actions_events.drop_column('host') shadow_actions_events.drop_column('details')
def downgrade(migrate_engine): compute_nodes = utils.get_table(migrate_engine, 'compute_nodes') compute_nodes.drop_column('host_ip') compute_nodes.drop_column('supported_instances') shadow_compute_nodes = utils.get_table( migrate_engine, db._SHADOW_TABLE_PREFIX + 'compute_nodes') shadow_compute_nodes.drop_column('host_ip') shadow_compute_nodes.drop_column('supported_instances')
def downgrade(migrate_engine): compute_nodes = utils.get_table(migrate_engine, 'compute_nodes') compute_nodes.drop_column('host_ip') compute_nodes.drop_column('supported_instances') shadow_compute_nodes = utils.get_table(migrate_engine, db._SHADOW_TABLE_PREFIX + 'compute_nodes') shadow_compute_nodes.drop_column('host_ip') shadow_compute_nodes.drop_column('supported_instances')
def downgrade(migrate_engine): actions_events = utils.get_table(migrate_engine, 'instance_actions_events') actions_events.drop_column('host') actions_events.drop_column('details') shadow_actions_events = utils.get_table( migrate_engine, api._SHADOW_TABLE_PREFIX + 'instance_actions_events') shadow_actions_events.drop_column('host') shadow_actions_events.drop_column('details')
def upgrade(migrate_engine): actions_events = utils.get_table(migrate_engine, 'instance_actions_events') host = Column('host', String(255)) details = Column('details', Text) actions_events.create_column(host) actions_events.create_column(details) shadow_actions_events = utils.get_table( migrate_engine, api._SHADOW_TABLE_PREFIX + 'instance_actions_events') shadow_actions_events.create_column(host.copy()) shadow_actions_events.create_column(details.copy())
def upgrade(migrate_engine): actions_events = utils.get_table(migrate_engine, 'instance_actions_events') host = Column('host', String(255)) details = Column('details', Text) actions_events.create_column(host) actions_events.create_column(details) shadow_actions_events = utils.get_table(migrate_engine, api._SHADOW_TABLE_PREFIX + 'instance_actions_events') shadow_actions_events.create_column(host.copy()) shadow_actions_events.create_column(details.copy())
def upgrade(migrate_engine): compute_nodes = utils.get_table(migrate_engine, 'compute_nodes') host_ip = Column('host_ip', types.IPAddress()) supported_instances = Column('supported_instances', Text) compute_nodes.create_column(host_ip) compute_nodes.create_column(supported_instances) shadow_compute_nodes = utils.get_table( migrate_engine, db._SHADOW_TABLE_PREFIX + 'compute_nodes') host_ip = Column('host_ip', types.IPAddress()) supported_instances = Column('supported_instances', Text) shadow_compute_nodes.create_column(host_ip) shadow_compute_nodes.create_column(supported_instances)
def upgrade(migrate_engine): compute_nodes = utils.get_table(migrate_engine, 'compute_nodes') host_ip = Column('host_ip', types.IPAddress()) supported_instances = Column('supported_instances', Text) compute_nodes.create_column(host_ip) compute_nodes.create_column(supported_instances) shadow_compute_nodes = utils.get_table(migrate_engine, db._SHADOW_TABLE_PREFIX + 'compute_nodes') host_ip = Column('host_ip', types.IPAddress()) supported_instances = Column('supported_instances', Text) shadow_compute_nodes.create_column(host_ip) shadow_compute_nodes.create_column(supported_instances)
def test_change_deleted_column_type_to_id_type_custom(self): if 'sqlite' in self.engines: table_name = 'test_change_deleted_column_type_to_id_type_custom' engine = self.engines['sqlite'] meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('foo', CustomType), Column('deleted', Boolean)) table.create() self.assertRaises(exception.NovaException, utils.change_deleted_column_type_to_id_type, engine, table_name) fooColumn = Column('foo', CustomType()) utils.change_deleted_column_type_to_id_type(engine, table_name, foo=fooColumn) table = utils.get_table(engine, table_name) # NOTE(boris-42): There is no way to check has foo type CustomType. # but sqlalchemy will set it to NullType. self.assertIsInstance(table.c.foo.type, NullType) self.assertIsInstance(table.c.deleted.type, Integer) table.drop()
def test_change_deleted_column_type_to_id_type_custom(self): if 'sqlite' in self.engines: table_name = 'test_change_deleted_column_type_to_id_type_custom' engine = self.engines['sqlite'] meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('foo', CustomType), Column('deleted', Boolean)) table.create() # reflection of custom types has been fixed upstream if SA_VERSION < (0, 9, 0): self.assertRaises(exception.NovaException, utils.change_deleted_column_type_to_id_type, engine, table_name) fooColumn = Column('foo', CustomType()) utils.change_deleted_column_type_to_id_type(engine, table_name, foo=fooColumn) table = utils.get_table(engine, table_name) # NOTE(boris-42): There is no way to check has foo type CustomType. # but sqlalchemy will set it to NullType. This has # been fixed upstream in recent SA versions if SA_VERSION < (0, 9, 0): self.assertIsInstance(table.c.foo.type, NullType) self.assertIsInstance(table.c.deleted.type, Integer) table.drop()
def _check_231(self, engine, data): self.assertColumnExists(engine, 'instances', 'ephemeral_key_uuid') instances = db_utils.get_table(engine, 'instances') self.assertIsInstance(instances.c.ephemeral_key_uuid.type, sqlalchemy.types.String) self.assertTrue(db_utils.check_shadow_table(engine, 'instances'))
def _check_229(self, engine, data): self.assertColumnExists(engine, 'compute_nodes', 'extra_resources') compute_nodes = db_utils.get_table(engine, 'compute_nodes') self.assertTrue( isinstance(compute_nodes.c.extra_resources.type, sqlalchemy.types.Text))
def test_change_deleted_column_type_to_boolean_type_custom(self): if 'sqlite' in self.engines: table_name = \ 'test_change_deleted_column_type_to_boolean_type_custom' engine = self.engines['sqlite'] meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('foo', CustomType), Column('deleted', Integer)) table.create() # reflection of custom types has been fixed upstream if SA_VERSION < (0, 9, 0): self.assertRaises(exception.NovaException, utils.change_deleted_column_type_to_boolean, engine, table_name) fooColumn = Column('foo', CustomType()) utils.change_deleted_column_type_to_boolean(engine, table_name, foo=fooColumn) table = utils.get_table(engine, table_name) # NOTE(boris-42): There is no way to check has foo type CustomType. # but sqlalchemy will set it to NullType. This has # been fixed upstream in recent SA versions. if SA_VERSION < (0, 9, 0): self.assertIsInstance(table.c.foo.type, NullType) self.assertIsInstance(table.c.deleted.type, Boolean) table.drop()
def test_change_deleted_column_type_to_boolean_type_custom(self): if 'sqlite' in self.engines: table_name = \ 'test_change_deleted_column_type_to_boolean_type_custom' engine = self.engines['sqlite'] meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('foo', CustomType), Column('deleted', Integer)) table.create() self.assertRaises(exception.NovaException, utils.change_deleted_column_type_to_boolean, engine, table_name) fooColumn = Column('foo', CustomType()) utils.change_deleted_column_type_to_boolean(engine, table_name, foo=fooColumn) table = utils.get_table(engine, table_name) # NOTE(boris-42): There is no way to check has foo type CustomType. # but sqlalchemy will set it to NullType. self.assertIsInstance(table.c.foo.type, NullType) self.assertIsInstance(table.c.deleted.type, Boolean) table.drop()
def upgrade(migrate_engine): meta = MetaData(bind=migrate_engine) pci_devices_uc_name = 'uniq_pci_devices0compute_node_id0address0deleted' pci_devices = Table('pci_devices', meta, Column('created_at', DateTime(timezone=False)), Column('updated_at', DateTime(timezone=False)), Column('deleted_at', DateTime(timezone=False)), Column('deleted', Integer, default=0, nullable=False), Column('id', Integer, primary_key=True), Column('compute_node_id', Integer, nullable=False), Column('address', String(12), nullable=False), Column('product_id', String(4)), Column('vendor_id', String(4)), Column('dev_type', String(8)), Column('dev_id', String(255)), Column('label', String(255), nullable=False), Column('status', String(36), nullable=False), Column('extra_info', Text, nullable=True), Column('instance_uuid', String(36), nullable=True), Index('ix_pci_devices_compute_node_id_deleted', 'compute_node_id', 'deleted'), Index('ix_pci_devices_instance_uuid_deleted', 'instance_uuid', 'deleted'), UniqueConstraint('compute_node_id', 'address', 'deleted', name=pci_devices_uc_name), mysql_engine='InnoDB', mysql_charset='utf8') try: pci_devices.create() utils.create_shadow_table(migrate_engine, table=pci_devices) except Exception: LOG.exception(_("Exception while creating table 'pci_devices'.")) raise try: compute_nodes = utils.get_table(migrate_engine, 'compute_nodes') pci_stats = Column('pci_stats', Text, nullable=True) compute_nodes.create_column(pci_stats) shadow_compute_nodes = utils.get_table( migrate_engine, api._SHADOW_TABLE_PREFIX + 'compute_nodes') shadow_compute_nodes.create_column(pci_stats.copy()) except Exception: LOG.exception(_("Exception for adding pci stats to compute node.")) raise
def downgrade_pci_device_table(self, migrate_engine): LOG.audit(_("downgrading pci_devices table")) meta = MetaData(bind=migrate_engine) pci_devices = utils.get_table(migrate_engine, 'pci_devices') pci_devices.drop_column('bus') pci_devices.drop_column('slot') pci_devices.drop_column('function') pci_devices.drop_column('workload')
def upgrade_instance_table(self, migrate_engine): LOG.audit(_("upgrading instance table")) meta = MetaData(bind=migrate_engine) instances = utils.get_table(migrate_engine, 'instances') workload_type = Column('workload_type', String(100), nullable=True) policy = Column('policy', Integer(11), nullable=True) instances.create_column(workload_type) instances.create_column(policy)
def _post_downgrade_006(self, engine): ifs = db_utils.get_table(engine, 'bm_interfaces') rows = ifs.select().where(ifs.c.bm_node_id == 1).execute().fetchall() self.assertEqual(len(rows), 1) self.assertEqual(rows[0]['address'], 'bb:bb:bb:bb:bb:bb') rows = ifs.select().where(ifs.c.bm_node_id == 2).execute().fetchall() self.assertEqual(len(rows), 0)
def _check_233(self, engine, data): self.assertColumnExists(engine, 'compute_nodes', 'stats') compute_nodes = db_utils.get_table(engine, 'compute_nodes') self.assertIsInstance(compute_nodes.c.stats.type, sqlalchemy.types.Text) self.assertRaises(sqlalchemy.exc.NoSuchTableError, db_utils.get_table, engine, 'compute_node_stats')
def _pre_upgrade_006(self, engine): nodes = db_utils.get_table(engine, 'bm_nodes') ifs = db_utils.get_table(engine, 'bm_interfaces') # node 1 has two different addresses in bm_nodes and bm_interfaces engine.execute(nodes.insert(), [{'id': 1, 'prov_mac_address': 'aa:aa:aa:aa:aa:aa'}]) engine.execute(ifs.insert(), [{'id': 101, 'bm_node_id': 1, 'address': 'bb:bb:bb:bb:bb:bb'}]) # node 2 has one same address both in bm_nodes and bm_interfaces engine.execute(nodes.insert(), [{'id': 2, 'prov_mac_address': 'cc:cc:cc:cc:cc:cc'}]) engine.execute(ifs.insert(), [{'id': 201, 'bm_node_id': 2, 'address': 'cc:cc:cc:cc:cc:cc'}])
def _check_010(self, engine, data): bm_nodes = db_utils.get_table(engine, 'bm_nodes') self.assertIn('preserve_ephemeral', bm_nodes.columns) default = engine.execute( sqlalchemy.select([bm_nodes.c.preserve_ephemeral]) .where(bm_nodes.c.id == data[0]['id']) ).scalar() self.assertEqual(default, False) bm_nodes.delete().where(bm_nodes.c.id == data[0]['id']).execute()
def _check_230(self, engine, data): for table_name in ['instance_actions_events', 'shadow_instance_actions_events']: self.assertColumnExists(engine, table_name, 'host') self.assertColumnExists(engine, table_name, 'details') action_events = db_utils.get_table(engine, 'instance_actions_events') self.assertIsInstance(action_events.c.host.type, sqlalchemy.types.String) self.assertIsInstance(action_events.c.details.type, sqlalchemy.types.Text)
def _check_010(self, engine, data): bm_nodes = db_utils.get_table(engine, 'bm_nodes') self.assertIn('preserve_ephemeral', bm_nodes.columns) default = engine.execute( sqlalchemy.select([ bm_nodes.c.preserve_ephemeral ]).where(bm_nodes.c.id == data[0]['id'])).scalar() self.assertEqual(default, False) bm_nodes.delete().where(bm_nodes.c.id == data[0]['id']).execute()
def assertIndexMembers(self, engine, table, index, members): self.assertIndexExists(engine, table, index) t = db_utils.get_table(engine, table) index_columns = None for idx in t.indexes: if idx.name == index: index_columns = idx.columns.keys() break self.assertEqual(sorted(members), sorted(index_columns))
def upgrade_pci_device_table(self, migrate_engine): LOG.audit(_("upgrading pci_devices table")) meta = MetaData(bind=migrate_engine) pci_devices = utils.get_table(migrate_engine, 'pci_devices') bus = Column('bus', String(2), nullable=False) slot = Column('slot', String(2), nullable=False) function = Column('function', String(2), nullable=False) workload = Column('workload', String(2), nullable=True) pci_devices.create_column(bus) pci_devices.create_column(slot) pci_devices.create_column(function) pci_devices.create_column(workload)
def test_change_deleted_column_type_to_id_type_string(self): table_name = "test_change_deleted_column_type_to_id_type_string" for key, engine in self.engines.items(): meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column("id", String(255), primary_key=True), Column("deleted", Boolean)) table.create() utils.change_deleted_column_type_to_id_type(engine, table_name) table = utils.get_table(engine, table_name) self.assertIsInstance(table.c.deleted.type, String) table.drop()
def _pre_upgrade_002(self, engine): data = [{ 'id': 1, 'key': 'fake-key', 'image_path': '/dev/null', 'pxe_config_path': '/dev/null/', 'root_mb': 0, 'swap_mb': 0 }] table = db_utils.get_table(engine, 'bm_deployments') engine.execute(table.insert(), data) return data
def downgrade(migrate_engine): quota_usages = utils.get_table(migrate_engine, 'quota_usages') quota_usages.drop_column('user_id') shadow_quota_usages = utils.get_table(migrate_engine, db._SHADOW_TABLE_PREFIX + 'quota_usages') shadow_quota_usages.drop_column('user_id') reservations = utils.get_table(migrate_engine, 'reservations') reservations.drop_column('user_id') shadow_reservations = utils.get_table(migrate_engine, db._SHADOW_TABLE_PREFIX + 'reservations') shadow_reservations.drop_column('user_id') project_user_quotas = utils.get_table(migrate_engine, 'project_user_quotas') try: project_user_quotas.drop() except Exception: LOG.error(_("project_user_quotas table not dropped")) raise shadow_table_name = db._SHADOW_TABLE_PREFIX + 'project_user_quotas' shadow_table = utils.get_table(migrate_engine, shadow_table_name) try: shadow_table.drop() except Exception: LOG.error(_("%s table not dropped") % shadow_table_name) raise
def downgrade(migrate_engine): quota_usages = utils.get_table(migrate_engine, 'quota_usages') quota_usages.drop_column('user_id') shadow_quota_usages = utils.get_table( migrate_engine, db._SHADOW_TABLE_PREFIX + 'quota_usages') shadow_quota_usages.drop_column('user_id') reservations = utils.get_table(migrate_engine, 'reservations') reservations.drop_column('user_id') shadow_reservations = utils.get_table( migrate_engine, db._SHADOW_TABLE_PREFIX + 'reservations') shadow_reservations.drop_column('user_id') project_user_quotas = utils.get_table(migrate_engine, 'project_user_quotas') try: project_user_quotas.drop() except Exception: LOG.error(_("project_user_quotas table not dropped")) raise shadow_table_name = db._SHADOW_TABLE_PREFIX + 'project_user_quotas' shadow_table = utils.get_table(migrate_engine, shadow_table_name) try: shadow_table.drop() except Exception: LOG.error(_("%s table not dropped") % shadow_table_name) raise
def test_change_deleted_column_type_to_id_type_integer(self): table_name = 'abc' for key, engine in self.engines.items(): meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('deleted', Boolean)) table.create() utils.change_deleted_column_type_to_id_type(engine, table_name) table = utils.get_table(engine, table_name) self.assertTrue(isinstance(table.c.deleted.type, Integer))
def test_change_deleted_column_type_to_id_type_string(self): table_name = 'abc' for key, engine in self.engines.items(): meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', String(255), primary_key=True), Column('deleted', Boolean)) table.create() utils.change_deleted_column_type_to_id_type(engine, table_name) table = utils.get_table(engine, table_name) self.assertTrue(isinstance(table.c.deleted.type, String))
def _check_006(self, engine, data): ifs = db_utils.get_table(engine, 'bm_interfaces') rows = ifs.select().\ where(ifs.c.bm_node_id == 1).\ execute().\ fetchall() self.assertEqual(len(rows), 2) rows = ifs.select().\ where(ifs.c.bm_node_id == 2).\ execute().\ fetchall() self.assertEqual(len(rows), 1) self.assertEqual(rows[0]['address'], 'cc:cc:cc:cc:cc:cc')
def downgrade(migrate_engine): meta = MetaData(bind=migrate_engine) try: pci_device = Table('pci_devices', meta, autoload=True) pci_device.drop() shadow_pci_device = Table(api._SHADOW_TABLE_PREFIX + 'pci_devices', meta, autoload=True) shadow_pci_device.drop() except Exception: LOG.exception(_("Exception while dropping 'pci_devices' tables.")) raise try: compute_nodes = utils.get_table(migrate_engine, 'compute_nodes') compute_nodes.drop_column('pci_stats') shadow_compute_nodes = utils.get_table( migrate_engine, api._SHADOW_TABLE_PREFIX + 'compute_nodes') shadow_compute_nodes.drop_column('pci_stats') except Exception: LOG.exception(_("Exception for dropping pci stats from compute node.")) raise
def test_change_deleted_column_type_to_boolean(self): table_name = "test_change_deleted_column_type_to_boolean" for key, engine in self.engines.items(): meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column("id", Integer, primary_key=True), Column("deleted", Integer)) table.create() utils.change_deleted_column_type_to_boolean(engine, table_name) table = utils.get_table(engine, table_name) expected_type = Boolean if key != "mysql" else mysql.TINYINT self.assertIsInstance(table.c.deleted.type, expected_type) table.drop()
def _check_227(self, engine, data): table = db_utils.get_table(engine, 'project_user_quotas') # Insert fake_quotas with the longest resource name. fake_quotas = {'id': 5, 'project_id': 'fake_project', 'user_id': 'fake_user', 'resource': 'injected_file_content_bytes', 'hard_limit': 10} table.insert().execute(fake_quotas) # Check we can get the longest resource name. quota = table.select(table.c.id == 5).execute().first() self.assertEqual(quota['resource'], 'injected_file_content_bytes')
def test_change_deleted_column_type_to_id_type_integer(self): table_name = 'test_change_deleted_column_type_to_id_type_integer' for key, engine in self.engines.items(): meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('deleted', Boolean)) table.create() utils.change_deleted_column_type_to_id_type(engine, table_name) table = utils.get_table(engine, table_name) self.assertIsInstance(table.c.deleted.type, Integer) table.drop()
def test_change_deleted_column_type_to_boolean(self): table_name = 'abc' for key, engine in self.engines.items(): meta = MetaData() meta.bind = engine table = Table(table_name, meta, Column('id', Integer, primary_key=True), Column('deleted', Integer)) table.create() utils.change_deleted_column_type_to_boolean(engine, table_name) table = utils.get_table(engine, table_name) expected_type = Boolean if key != "mysql" else mysql.TINYINT self.assertTrue(isinstance(table.c.deleted.type, expected_type))
def fuzzify(engine, config): """Do the actual fuzzification based on the loaded attributes of the models.""" Session = sessionmaker(bind=engine) session = Session() metadata = MetaData(bind=engine, reflect=True) cascade_fkeys(metadata) for model_name, columns in config.items(): table_name = getattr(models, model_name).__tablename__ tables = [getattr(models, model_name)] if 'shadow_' + table_name in metadata.tables.keys(): tables.append(utils.get_table(engine, 'shadow_' + table_name)) for table in tables: q = session.query(table) for row in q.all(): for column, column_type in columns: setattr(row, column, randomness(getattr(row, column), column_type)) session.commit() cascade_fkeys(metadata, restore=True)
def downgrade(migrate_engine): quota_usages = utils.get_table(migrate_engine, 'quota_usages') reservations = utils.get_table(migrate_engine, 'reservations') if migrate_engine.name == 'mysql' or migrate_engine.name == 'postgresql': # Remove the indexes first indexes = [ Index('ix_quota_usages_user_id_deleted', quota_usages.c.user_id, quota_usages.c.deleted), Index('ix_reservations_user_id_deleted', reservations.c.user_id, reservations.c.deleted) ] for index in indexes: index.drop(migrate_engine) quota_usages.drop_column('user_id') shadow_quota_usages = utils.get_table(migrate_engine, db._SHADOW_TABLE_PREFIX + 'quota_usages') shadow_quota_usages.drop_column('user_id') reservations.drop_column('user_id') shadow_reservations = utils.get_table(migrate_engine, db._SHADOW_TABLE_PREFIX + 'reservations') shadow_reservations.drop_column('user_id') project_user_quotas = utils.get_table(migrate_engine, 'project_user_quotas') try: project_user_quotas.drop() except Exception: LOG.error(_("project_user_quotas table not dropped")) raise shadow_table_name = db._SHADOW_TABLE_PREFIX + 'project_user_quotas' shadow_table = utils.get_table(migrate_engine, shadow_table_name) try: shadow_table.drop() except Exception: LOG.error(_("%s table not dropped") % shadow_table_name) raise
def _post_downgrade_010(self, engine): bm_nodes = db_utils.get_table(engine, 'bm_nodes') self.assertNotIn('preserve_ephemeral', bm_nodes.columns)
def _post_downgrade_008(self, engine): db_utils.get_table(engine, 'bm_pxe_ips')
def _pre_upgrade_010(self, engine): bm_nodes = db_utils.get_table(engine, 'bm_nodes') data = [{'id': 10, 'prov_mac_address': 'cc:cc:cc:cc:cc:cc'}] engine.execute(bm_nodes.insert(), data) return data
def _check_007(self, engine, data): bm_nodes = db_utils.get_table(engine, 'bm_nodes') columns = [c.name for c in bm_nodes.columns] self.assertNotIn(u'prov_mac_address', columns)
def _check_005(self, engine, data): bm_nodes = db_utils.get_table(engine, 'bm_nodes') columns = [c.name for c in bm_nodes.columns] self.assertNotIn(u'prov_vlan_id', columns) self.assertNotIn(u'registration_status', columns)
def _post_downgrade_004(self, engine): bm_nodes = db_utils.get_table(engine, 'bm_nodes') self.assertNotIn(u'instance_name', [c.name for c in bm_nodes.columns])