def test_cascade_release_deletion(self): release_component_table = self.meta.tables['release_components'] release_table = self.meta.tables['releases'] release_id = insert_table_row( release_table, { 'name': 'release_with_components', 'version': '2014.2.2-6.1', 'operating_system': 'ubuntu', 'state': 'available' } ) component_id = insert_table_row( self.meta.tables['components'], {'name': six.text_type(uuid.uuid4()), 'type': 'hypervisor'} ) insert_table_row( release_component_table, {'release_id': release_id, 'component_id': component_id} ) db.execute( sa.delete(release_table).where(release_table.c.id == release_id)) deleted_plugin_components = db.execute( sa.select([sa.func.count(release_component_table.c.id)]). where(release_component_table.c.release_id == release_id) ).fetchone()[0] self.assertEqual(deleted_plugin_components, 0)
def prepare(): meta = base.reflect_db_metadata() releaseid = insert_table_row( meta.tables["releases"], {"name": "test_name", "version": "2014.2.2-6.1", "operating_system": "ubuntu", "state": "available"}, ) clusterid = insert_table_row( meta.tables["clusters"], { "name": "test_env", "release_id": releaseid, "mode": "ha_compact", "status": "new", "net_provider": "neutron", "grouping": "roles", "fuel_version": "6.1", }, ) db.execute( meta.tables["nodegroups"].insert(), [ {"cluster_id": clusterid, "name": "test_nodegroup_a"}, {"cluster_id": clusterid, "name": "test_nodegroup_a"}, {"cluster_id": clusterid, "name": "test_nodegroup_b"}, {"cluster_id": clusterid, "name": "test_nodegroup_b"}, ], ) db.commit()
def test_new_columns_exist(self): deployment_graphs_table = self.meta.tables['deployment_graphs'] db.execute( deployment_graphs_table.insert(), { 'name': 'test', 'node_filter': '$.status == ready', 'on_success': '{"node_attributes": {"status": "new"}}', 'on_error': '{"node_attributes": {"status": "error"}}', 'on_stop': '{}' } ) result = db.execute( sa.select([ deployment_graphs_table.c.node_filter, deployment_graphs_table.c.on_success, deployment_graphs_table.c.on_error, deployment_graphs_table.c.on_stop, ]).where(deployment_graphs_table.c.name == 'test') ).first() self.assertEqual('$.status == ready', result['node_filter']) self.assertEqual( '{"node_attributes": {"status": "new"}}', result['on_success'] ) self.assertEqual( '{"node_attributes": {"status": "error"}}', result['on_error'] ) self.assertEqual('{}', result['on_stop'])
def test_tun_segment_type_added(self): result = db.execute( self.meta.tables["networking_configs"].insert(), [ { "cluster_id": None, "dns_nameservers": ["8.8.8.8"], "floating_ranges": [], "configuration_template": None, } ], ) db.execute( self.meta.tables["neutron_config"].insert(), [ { "id": result.inserted_primary_key[0], "vlan_range": [], "gre_id_range": [], "base_mac": "00:00:00:00:00:00", "internal_cidr": "10.10.10.00/24", "internal_gateway": "10.10.10.01", "segmentation_type": "tun", "net_l23_provider": "ovs", } ], ) types = db.execute(sa.select([self.meta.tables["neutron_config"].c.segmentation_type])).fetchall() self.assertIn(("tun",), types)
def test_new_fields_exists_and_empty(self): # check node_nic_interfaces fields result = db.execute(sa.select([self.meta.tables["node_nic_interfaces"].c.offloading_modes])) self.assertEqual(jsonutils.loads(result.fetchone()[0]), []) # the same for bond interfaces result = db.execute(sa.select([self.meta.tables["node_bond_interfaces"].c.offloading_modes])) self.assertEqual(jsonutils.loads(result.fetchone()[0]), [])
def test_baremetal_fields_saving(self): baremetal_gateway = '192.168.3.51' baremetal_range = jsonutils.dumps(['192.168.3.52', '192.168.3.254']) result = db.execute( self.meta.tables['networking_configs'].insert(), [{ 'cluster_id': None, 'dns_nameservers': ['8.8.8.8'], 'floating_ranges': [], 'configuration_template': None, }]) db.execute( self.meta.tables['neutron_config'].insert(), [{ 'id': result.inserted_primary_key[0], 'vlan_range': [], 'gre_id_range': [], 'base_mac': '00:00:00:00:00:00', 'internal_cidr': '10.10.10.00/24', 'internal_gateway': '10.10.10.01', 'internal_name': 'my_internal_name', 'floating_name': 'my_floating_name', 'baremetal_gateway': baremetal_gateway, 'baremetal_range': baremetal_range, 'segmentation_type': 'vlan', 'net_l23_provider': 'ovs' }]) result = db.execute( sa.select( [self.meta.tables['neutron_config'].c.baremetal_gateway, self.meta.tables['neutron_config'].c.baremetal_range])).\ fetchall() self.assertIn((baremetal_gateway, baremetal_range), result)
def test_openstack_configs_table_saving(self): result = db.execute( sa.select([self.meta.tables['clusters'].c.id])) cluster_id = result.fetchone()[0] db.execute( self.meta.tables['openstack_configs'].insert(), [{ 'cluster_id': cluster_id, 'is_active': True, 'config_type': 'cluster', 'node_id': None, 'node_role': None, 'created_at': datetime.now(), 'configuration': jsonutils.dumps({ 'config_a': {}, 'config_b': {}, }), }] ) result = db.execute( sa.select([self.meta.tables['openstack_configs'].c.cluster_id])) config = result.fetchone() self.assertEqual(config[0], cluster_id)
def test_unique_name_fields_insert_unique(self): nodegroup = db.execute( sa.select([self.meta.tables['nodegroups'].c.cluster_id, self.meta.tables['nodegroups'].c.name])).fetchone() db.execute(self.meta.tables['nodegroups'].insert(), [{'cluster_id': nodegroup['cluster_id'], 'name': six.text_type(uuid.uuid4())}])
def test_moving_plugin_attributes(self): clusters = self.meta.tables['clusters'] attributes = self.meta.tables['attributes'] plugins = self.meta.tables['plugins'] cluster_plugins = self.meta.tables['cluster_plugins'] query = sa.select([attributes.c.editable])\ .select_from( sa.join( attributes, clusters, attributes.c.cluster_id == clusters.c.id)) result = jsonutils.loads(db.execute(query).fetchone()[0]) self.assertItemsEqual(result, {}) query = sa.select([cluster_plugins.c.attributes])\ .select_from( sa.join( cluster_plugins, plugins, cluster_plugins.c.plugin_id == plugins.c.id))\ .where(plugins.c.name == 'test_plugin_a') result = jsonutils.loads(db.execute(query).fetchone()[0]) self.assertNotIn('metadata', result) self.assertItemsEqual(result['attribute'], { 'value': 'value', 'type': 'text', 'description': 'description', 'weight': 25, 'label': 'label' })
def test_tun_segment_type_added(self): result = db.execute( self.meta.tables['networking_configs'].insert(), [{ 'cluster_id': None, 'dns_nameservers': ['8.8.8.8'], 'floating_ranges': [], 'configuration_template': None, }]) db.execute( self.meta.tables['neutron_config'].insert(), [{ 'id': result.inserted_primary_key[0], 'vlan_range': [], 'gre_id_range': [], 'base_mac': '00:00:00:00:00:00', 'internal_cidr': '10.10.10.00/24', 'internal_gateway': '10.10.10.01', 'segmentation_type': 'tun', 'net_l23_provider': 'ovs' }]) types = db.execute( sa.select( [self.meta.tables['neutron_config'].c.segmentation_type])).\ fetchall() self.assertIn(('tun',), types)
def test_network_group_name_is_string(self): db.execute( self.meta.tables["network_groups"].insert(), [{"id": 3, "name": "custom_name", "vlan_start": None, "cidr": "10.20.0.0/24", "gateway": "10.20.0.200"}], ) names = db.execute(sa.select([self.meta.tables["network_groups"].c.name])).fetchall() self.assertIn(("custom_name",), names)
def test_new_fields_exists_and_empty(self): # check attributes_metadata field exists result = db.execute( sa.select([self.meta.tables['plugins'].c.attributes_metadata])) # check attributes_metadata value is empty self.assertEqual( jsonutils.loads(result.fetchone()[0]), {}) result = db.execute( sa.select([self.meta.tables['plugins'].c.volumes_metadata])) self.assertEqual( jsonutils.loads(result.fetchone()[0]), {}) result = db.execute( sa.select([self.meta.tables['plugins'].c.roles_metadata])) self.assertEqual( jsonutils.loads(result.fetchone()[0]), {}) result = db.execute( sa.select([self.meta.tables['plugins'].c.deployment_tasks])) self.assertEqual( jsonutils.loads(result.fetchone()[0]), []) result = db.execute( sa.select([self.meta.tables['plugins'].c.tasks])) self.assertEqual( jsonutils.loads(result.fetchone()[0]), [])
def prepare(): meta = base.reflect_db_metadata() result = db.execute( meta.tables['releases'].insert(), [{ 'name': 'test_name', 'version': '2015.1-8.0', 'operating_system': 'ubuntu', 'state': 'available', 'networks_metadata': jsonutils.dumps({ 'neutron': { 'networks': [], 'config': {} } }) }] ) releaseid = result.inserted_primary_key[0] db.execute( meta.tables['clusters'].insert(), [{ 'name': 'test_env', 'release_id': releaseid, 'mode': 'ha_compact', 'status': 'new', 'net_provider': 'neutron', 'grouping': 'roles', 'fuel_version': '8.0', 'deployment_tasks': '[]', 'replaced_deployment_info': '{}' }]) db.commit()
def prepare(): meta = base.reflect_db_metadata() result = db.execute( meta.tables['releases'].insert(), [{ 'name': 'test_name', 'version': '2015.1-10.0', 'operating_system': 'ubuntu', 'state': 'available', 'deployment_tasks': '{}', 'roles': '{}', 'roles_metadata': '{}', 'is_deployable': True, 'required_component_types': ['network', 'storage'] }] ) release_id = result.inserted_primary_key[0] result = db.execute( meta.tables['clusters'].insert(), [{ 'name': 'test', 'release_id': release_id, 'mode': 'ha_compact', 'status': 'new', 'net_provider': 'neutron', 'grouping': 'roles', 'fuel_version': '10.0', }] ) cluster_id = result.inserted_primary_key[0] TestPluginLinksConstraints.prepare(meta, cluster_id)
def prepare(cls, meta, cluster_id): cls.test_link['cluster_id'] = cluster_id db.execute( meta.tables['cluster_plugin_links'].insert(), [cls.test_link], )
def test_cluster_status_upgraded(self): clusters_table = self.meta.tables['clusters'] columns = [clusters_table.c.id, clusters_table.c.status] cluster = db.execute(sa.select(columns)).fetchone() db.execute(clusters_table.update().where( clusters_table.c.id == cluster.id ).values(status='partially_deployed'))
def test_unique_name_fields_insert_unique(self): nodegroup = db.execute( sa.select([self.meta.tables["nodegroups"].c.cluster_id, self.meta.tables["nodegroups"].c.name]) ).fetchone() db.execute( self.meta.tables["nodegroups"].insert(), [{"cluster_id": nodegroup["cluster_id"], "name": six.text_type(uuid.uuid4())}], )
def test_extensions_field_with_default_data(self): cluster_result = db.execute( sa.select([self.meta.tables['clusters'].c.extensions])).fetchone() release_result = db.execute( sa.select([self.meta.tables['releases'].c.extensions])).fetchone() self.assertEqual(list(cluster_result)[0], ['volume_manager']) self.assertEqual(list(release_result)[0], ['volume_manager'])
def test_new_field_exists_and_filled(self): nic_table = self.meta.tables["node_nic_interfaces"] result = db.execute(sa.select([nic_table.c.pxe]).where(nic_table.c.id == 1)) # check 'pxe' property is true for admin interfaces self.assertTrue(result.fetchone()[0]) result = db.execute(sa.select([nic_table.c.pxe]).where(nic_table.c.id != 1)) # and 'false' for any others for res in result.fetchall(): self.assertFalse(res[0])
def test_downgrade_field_tags_from_roles(self): releases = self.meta.tables['releases'] query = sa.select([releases.c.roles_metadata]) for role_meta in db.execute(query).fetchall(): self.assertNotIn('tags', role_meta) plugins = self.meta.tables['plugins'] query = sa.select([plugins.c.roles_metadata]) for role_meta in db.execute(query): self.assertNotIn('tags', role_meta)
def test_new_fields_exists_and_empty(self): result = db.execute( sa.select([self.meta.tables['networking_configs'] .c.configuration_template])) self.assertIsNone(result.fetchone()[0]) result = db.execute( sa.select([self.meta.tables['nodes'] .c.network_template])) self.assertIsNone(result.fetchone()[0])
def test_minimal_task_creation_success(self): deployment_graph_id = self._insert_deployment_graph() db.execute( self.meta.tables['deployment_graph_tasks'].insert(), { 'deployment_graph_id': deployment_graph_id, 'task_name': 'minimal task', 'type': 'puppet' }, )
def test_split_deployment_info(self): node_di_table = self.meta.tables['node_deployment_info'] res = db.execute(sa.select([node_di_table])) for data in res: self.assertEqual(jsonutils.loads(data.deployment_info), DEPLOYMENT_INFO[data.task_id][data.node_uid]) tasks_table = self.meta.tables['tasks'] res = db.execute(sa.select([tasks_table])) for data in res: self.assertIsNone(data.deployment_info)
def prepare(cls, meta): db.execute( meta.tables['releases'].insert(), [{ 'name': cls.release_name, 'version': cls.version, 'operating_system': 'ubuntu', 'state': 'available', 'roles_metadata': '{}', 'is_deployable': True }])
def test_field_reset_nodes_exist(self): db.execute( self.meta.tables['tasks'].insert(), [ { 'uuid': 'fake_task_uuid_0', 'name': 'reset_nodes', 'status': 'pending' } ] )
def test_field_remove_ironic_bootstrap_exist(self): db.execute( self.meta.tables['tasks'].insert(), [ { 'uuid': 'fake_task_uuid_0', 'name': 'remove_ironic_bootstrap', 'status': 'pending' } ] )
def test_fields_exist(self): db.execute( self.meta.tables['tasks'].insert(), [ { 'uuid': 'fake_task_uuid_0', 'name': 'dry_run_deployment', 'status': 'pending' } ] )
def test_duplicate_cluster_link(self): db.execute( self.meta.tables['cluster_plugin_links'].insert(), [self.test_link] ) links_count = db.execute( sa.select( [sa.func.count(self.meta.tables['cluster_plugin_links'].c.id)] )).fetchone()[0] self.assertEqual(links_count, 2)
def test_graph_type_field_exist(self): db.execute( self.meta.tables['tasks'].insert(), [{ 'uuid': 'fake_task_uuid_0', 'name': 'dump', 'status': 'pending', }] ) result = db.execute(sa.select([self.meta.tables['tasks']])).first() self.assertIn('graph_type', result)
def test_cobbler_profile_updated(self): result = db.execute( sa.select([self.meta.tables['attributes'].c.generated])) generated = jsonutils.loads(result.fetchone()[0]) self.assertEqual(generated['cobbler']['profile'], 'ubuntu_1404_x86_64') result = db.execute(sa.select( [self.meta.tables['releases'].c.attributes_metadata])) attrs_metadata = jsonutils.loads(result.fetchone()[0]) self.assertEqual( attrs_metadata['generated']['cobbler']['profile']['generator_arg'], 'ubuntu_1404_x86_64')