def test_scheduledtask_delete(self): assert_raises(exceptions.NotFound, self.other_client.scheduledtasks.delete, id=self.test_task.id) self.client.scheduledtasks.delete(id=self.test_task.id) assert_raises(exceptions.NotFound, self.client.scheduledtasks.get, self.test_task.id)
def test_node_patch(self): """ Testing PATCH:/api/2.0/nodes/:id """ data = {"name": 'fake_name_test'} Api().nodes_get_all() nodes = self.__get_data() codes = [] for n in nodes: if n.get('name') == 'test_compute_node': uuid = n.get('id') Api().nodes_patch_by_id(identifier=uuid,body=data) rsp = self.__client.last_response test_nodes = self.__get_data() assert_equal(test_nodes.get('name'), 'fake_name_test', 'Oops patch failed') codes.append(rsp) LOG.info('Restoring name to "test_compute_node"') correct_data = {"name": 'test_compute_node'} Api().nodes_patch_by_id(identifier=uuid,body=correct_data) rsp = self.__client.last_response restored_nodes = self.__get_data() assert_equal(restored_nodes.get('name'), 'test_compute_node', 'Oops restoring failed') codes.append(rsp) assert_not_equal(0, len(codes), message='Failed to find compute node Ids') for c in codes: assert_equal(200, c.status, message=c.reason) assert_raises(rest.ApiException, Api().nodes_patch_by_id, 'fooey', data)
def test_backup_delete(self): """test delete""" # Test to make sure that user in other tenant is not able # to DELETE this backup reqs = Requirements(is_admin=False) other_user = CONFIG.users.find_user( reqs, black_list=[instance_info.user.auth_user]) other_client = create_dbaas_client(other_user) assert_raises(exceptions.NotFound, other_client.backups.delete, backup_info.id) instance_info.dbaas.backups.delete(backup_info.id) assert_equal(202, instance_info.dbaas.last_http_code) def backup_is_gone(): result = instance_info.dbaas.instances.backups(instance_info.id) if len(result) == 0: return True else: return False poll_until(backup_is_gone) assert_raises(exceptions.NotFound, instance_info.dbaas.backups.get, backup_info.id)
def test_hostname_ipv4_restriction(self): # By default, user hostnames are required to be % or IPv4 addresses. user = {"name": "ipv4_nodice", "password": "******", "databases": [], "host": "disallowed_host"} assert_raises(exceptions.BadRequest, self.dbaas.users.create, instance_info.id, [user])
def create_too_many_instances(self): flavor, flavor_href = get_standby_instance_flavor(self.client1) asserts.assert_raises(exceptions.OverLimit, self.client1.instances.create, "too_many_instances", flavor_href, {'size': 1}) asserts.assert_equal(413, self.client1.last_http_code)
def test_scheduledtask_create(self): now = datetime.now() params = { "name": "Test Task", "instance_id": self.instance.id, "description": "Testing", "type": self.test_task_type, "enabled": True, "frequency": "daily", "window_start": now, "window_end": now + timedelta(hours=1), "metadata": { "meta": "data", "i_am": "so meta!", }, } self.test_task = self.client.scheduledtasks.create(**params) for key in params: assert_equal(getattr(self.test_task, key), params[key]) assert_is_not_none(self.test_task.id) params['frequency'] = 'dodecahourly' assert_raises(exceptions.NotFound, self.client.scheduledtasks.create, **params) params['type'] = 'nonexistent' assert_raises(exceptions.NotFound, self.client.scheduledtasks.create, **params)
def test_eject_valid_master(self): if CONFIG.fake_mode: raise SkipTest("eject_replica_source not supported in fake mode") assert_raises(exceptions.BadRequest, instance_info.dbaas.instances.eject_replica_source, instance_info.id)
def test_instance_size_too_big(self): if test_config.values['reddwarf_can_have_volume']: raise SkipTest("Wrong assertion because we have no volume limit") too_big = test_config.values['reddwarf_max_accepted_volume_size'] assert_raises(nova_exceptions.OverLimit, dbaas.instances.create, "way_too_large", instance_info.dbaas_flavor_href, {'size': too_big + 1}, [])
def test_cannot_create_taboo_database_names(self): for name in self.system_dbs: databases = [{"name": name, "charset": "latin2", "collate": "latin2_general_ci"}] assert_raises(exceptions.BadRequest, self.dbaas.databases.create, instance_info.id, databases) assert_equal(400, self.dbaas.last_http_code)
def test_invalid_username(self): users = [] users.append({"name": "user,", "password": self.password, "database": self.db1}) assert_raises(exceptions.BadRequest, self.dbaas.users.create, instance_info.id, users) assert_equal(400, self.dbaas.last_http_code)
def test_log_disable(self): self.instances.log_publish(instance_info.id, 'error', disable=True) self.wait_for_log_operation() container = 'log-mysql-error-' + instance_info.id # Check that the container is actually gone assert_raises(swiftclient.exceptions.ClientException, self.swift_client.get_container(container))
def test_node_patch(self): """ Verify PATCH:/nodes/:id """ data = {"name": "fake_name_test"} Nodes().api1_1_nodes_get() nodes = loads(self.__client.last_response.data) codes = [] for n in nodes: if n.get("name") == "test_compute_node": uuid = n.get("id") Nodes().api1_1_nodes_identifier_patch(uuid, data) rsp = self.__client.last_response test_nodes = loads(self.__client.last_response.data) assert_equal(test_nodes.get("name"), "fake_name_test", "Oops patch failed") codes.append(rsp) LOG.info('Restoring name to "test_compute_node"') correct_data = {"name": "test_compute_node"} Nodes().api1_1_nodes_identifier_patch(uuid, correct_data) rsp = self.__client.last_response restored_nodes = loads(self.__client.last_response.data) assert_equal(restored_nodes.get("name"), "test_compute_node", "Oops restoring failed") codes.append(rsp) assert_not_equal(0, len(codes), message="Failed to find compute node Ids") for c in codes: assert_equal(200, c.status, message=c.reason) assert_raises(rest.ApiException, Nodes().api1_1_nodes_identifier_patch, "fooey", data)
def create_list_import_delete_bootstrap_image(self): """Validate CRD operations of fuel-bootstrap utility Scenario: 1. Revert snapshot build_default_bootstrap 2. Build and Ubuntu bootstrap with default settings 3. Validate it is available in images list 4. Delete Ubuntu bootstrap image 5. Validate it is not available and can not be activated 6. Validate restriction for deleting active image Duration 30m """ self.env.revert_snapshot("build_default_bootstrap") expected_bootstrap_uuids = \ self.env.fuel_bootstrap_actions.list_bootstrap_images_uuids() uuid, bootstrap_location = \ self.env.fuel_bootstrap_actions.build_bootstrap_image() self.env.fuel_bootstrap_actions.\ import_bootstrap_image(bootstrap_location) bootstrap_uuids = self.env.fuel_bootstrap_actions.\ list_bootstrap_images_uuids() assert_true(uuid in bootstrap_uuids, "Newly built bootstrap image {0} is not in list of " "available images: {1}".format(uuid, bootstrap_uuids)) assert_equal( len(expected_bootstrap_uuids) + 1, len(bootstrap_uuids), "Only {0} bootstrap images should be available; current list: " "\n{1}".format(bootstrap_uuids, len(expected_bootstrap_uuids) + 1)) self.env.fuel_bootstrap_actions.delete_bootstrap_image(uuid) bootstrap_uuids = self.env.fuel_bootstrap_actions.\ list_bootstrap_images_uuids() assert_true(uuid not in bootstrap_uuids, "Bootstrap {0} was not deleted and still available: {1}" .format(uuid, bootstrap_uuids)) assert_raises(DevopsCalledProcessError, self.env.fuel_bootstrap_actions.activate_bootstrap_image, uuid) assert_equal( len(expected_bootstrap_uuids), len(bootstrap_uuids), "Only {0} bootstrap images should be available; current list: " "\n{1}".format(bootstrap_uuids, len(expected_bootstrap_uuids))) uuid = self.env.fuel_bootstrap_actions.get_active_bootstrap_uuid() # we need to fail in case uuid is None, otherwise the assert_raises # will use: uuid = None assert_true(uuid is not None, "No active bootstrap. Possibly centos " "is active or something went wrong.") assert_raises( DevopsCalledProcessError, self.env.fuel_bootstrap_actions.delete_bootstrap_image, uuid)
def test_mgmt_root_history(self): """ A regular user may not view the root access history of any instance. """ assert_raises(Unauthorized, self.dbaas.management.root_enabled_history, 0)
def test_node_patch(self): """ Verify PATCH:/nodes/:id """ data = {"name": 'fake_name_test'} Nodes().nodes_get() nodes = loads(self.__client.last_response.data) codes = [] for n in nodes: if n.get('name') == 'test_compute_node': uuid = n.get('id') Nodes().nodes_identifier_patch(uuid, data) rsp = self.__client.last_response test_nodes = loads(self.__client.last_response.data) assert_equal(test_nodes.get('name'), 'fake_name_test', 'Oops patch failed') codes.append(rsp) LOG.info('Restoring name to "test_compute_node"') correct_data = {"name": 'test_compute_node'} Nodes().nodes_identifier_patch(uuid, correct_data) rsp = self.__client.last_response restored_nodes = loads(self.__client.last_response.data) assert_equal(restored_nodes.get('name'), 'test_compute_node', 'Oops restoring failed') codes.append(rsp) assert_not_equal(0, len(codes), message='Failed to find compute node Ids') for c in codes: assert_equal(200, c.status, message=c.reason) assert_raises(rest.ApiException, Nodes().nodes_identifier_patch, 'fooey', data)
def test_updateduser_newhost_invalid(self): # Ensure invalid hostnames/usernames aren't allowed to enter the system users = [] username = "******" hostname1 = "192.168.0.1" users.append({"name": username, "password": "******", "host": hostname1, "databases": []}) self.dbaas.users.create(instance_info.id, users) hostname1 = hostname1.replace(".", "%2e") assert_raises( exceptions.BadRequest, self.dbaas.users.update_attributes, instance_info.id, username, {"host": "badjuju"}, hostname1, ) assert_equal(400, self.dbaas.last_http_code) assert_raises( exceptions.BadRequest, self.dbaas.users.update_attributes, instance_info.id, username, {"name": " bad username "}, hostname1, ) assert_equal(400, self.dbaas.last_http_code) self.dbaas.users.delete(instance_info.id, username, hostname=hostname1)
def test_compatability_wrapper_should_not_hide_error(self): def test_1(): raise RuntimeError() assert_raises(RuntimeError, compatability.capture_type_error, test_1)
def test_change_password_nonexistent_user(self): user = self._pick_a_user() user["name"] = "thisuserDNE" asserts.assert_raises(exceptions.NotFound, self.dbaas.users.change_passwords, instance_info.id, [user]) asserts.assert_equal(404, self.dbaas.last_http_code)
def test_change_password_bogus_user(self): user = self._pick_a_user() user["name"] = "thisuserhasanamethatstoolong" asserts.assert_raises(exceptions.BadRequest, self.dbaas.users.change_passwords, instance_info.id, [user]) asserts.assert_equal(400, self.dbaas.last_http_code)
def test_datastore_not_found(self): try: assert_raises(exceptions.NotFound, self.rd_client.datastores.get, NAME) except exceptions.BadRequest as e: assert_equal(e.message, "Datastore '%s' cannot be found." % NAME)
def set_duplicate_hostname(self): """Verify that a duplicate hostname is not allowed Scenario: 1. Revert the snapshot 2. Set a custom hostname for the node 3. Verify that new hostnames are validated to avoid duplicates Duration: 7m """ self.env.revert_snapshot("ready_with_5_slaves") # Set a custom hostname for a node for the 1st time custom_hostname = 'custom-hostname' node = self.fuel_web.client.list_nodes()[0] self.fuel_web.client.set_hostname(node['id'], custom_hostname) # Try to change the hostname of the provisioned node assert_raises( HTTPError, self.fuel_web.client.set_hostname, node, custom_hostname) self.env.make_snapshot("set_duplicate_hostname")
def test_assign_configuration_to_instance_with_config(self): # test assigning a configuration to an instance that # already has an assigned configuration config_id = configuration_info.id assert_raises(exceptions.BadRequest, instance_info.dbaas.instances.modify, instance_info.id, configuration=config_id)
def test_instance_size_too_big(self): if 'reddwarf_max_accepted_volume_size' in test_config.values: too_big = test_config.values['reddwarf_max_accepted_volume_size'] assert_raises(exceptions.OverLimit, dbaas.instances.create, "way_too_large", instance_info.dbaas_flavor_href, {'size': too_big + 1}, []) assert_equal(413, dbaas.last_http_code)
def test_username_too_long(self): users = [] users.append({"name": "1233asdwer345tyg56", "password": self.password, "database": self.db1}) assert_raises(exceptions.BadRequest, self.dbaas.users.create, instance_info.id, users) assert_equal(400, self.dbaas.last_http_code)
def delete_user(self): if self.test_user is None: raise SkipTest("User tests were never run.") admin = mymodule.get_admin_client() admin.delete_user(self.test_user.id) assert_raises(mymodule.UserNotFoundException, mymodule.login, {'username':self.test_user.username, 'password':'******'})
def must_work_with_blank_accept_headers(): """Test to make sure that trove works without the headers""" versions = Versions() versions.setUp() client = versions.client if type(client.client).morph_request != TroveHTTPClient.morph_request: raise SkipTest("Not using the JSON client so can't execute this test.") original_morph_request = client.client.morph_request def morph_content_type_to(content_type): @wraps(original_morph_request) def _morph_request(kwargs): original_morph_request(kwargs) kwargs['headers']['Accept'] = content_type kwargs['headers']['Content-Type'] = content_type client.client.morph_request = _morph_request try: morph_content_type_to('') # run versions to make sure the API still returns JSON even though the # header type is blank versions.test_list_versions_index() # now change headers to XML to make sure the test fails morph_content_type_to('application/xml') asserts.assert_raises(exceptions.ResponseFormatError, versions.test_list_versions_index) finally: client.client.morph_request = original_morph_request
def test_backup_get(self): """Test get backup.""" backup = instance_info.dbaas.backups.get(backup_info.id) assert_equal(backup_info.id, backup.id) assert_equal(backup_info.name, backup.name) assert_equal(backup_info.description, backup.description) assert_equal(instance_info.id, backup.instance_id) assert_not_equal(0.0, backup.size) assert_equal('COMPLETED', backup.status) assert_equal(instance_info.dbaas_datastore, backup.datastore['type']) assert_equal(instance_info.dbaas_datastore_version, backup.datastore['version']) datastore_version = instance_info.dbaas.datastore_versions.get( instance_info.dbaas_datastore, instance_info.dbaas_datastore_version) assert_equal(datastore_version.id, backup.datastore['version_id']) # Test to make sure that user in other tenant is not able # to GET this backup reqs = Requirements(is_admin=False) other_user = CONFIG.users.find_user( reqs, black_list=[instance_info.user.auth_user]) other_client = create_dbaas_client(other_user) assert_raises(exceptions.NotFound, other_client.backups.get, backup_info.id)
def test_node_tags_del(self): """ Testing DELETE:api/2.0/nodes/:id/tags/:tagName """ get_codes = [] del_codes = [] Api().nodes_get_all() rsp = self.__client.last_response nodes = loads(rsp.data) get_codes.append(rsp) for n in nodes: for t in self.__test_tags.get('tags'): Api().nodes_del_tag_by_id(identifier=n.get('id'), tag_name=t) rsp = self.__client.last_response del_codes.append(rsp) Api().nodes_get_by_id(identifier=n.get('id')) rsp = self.__client.last_response get_codes.append(rsp) updated_node = loads(rsp.data) for t in self.__test_tags.get('tags'): assert_true(t not in updated_node.get('tags'), message= "Tag " + t + " was not deleted" ) for c in get_codes: assert_equal(200, c.status, message=c.reason) for c in del_codes: assert_equal(204, c.status, message=c.reason) assert_raises(rest.ApiException, Api().nodes_del_tag_by_id, 'fooey',tag_name=['tag'])
def test_promote_master(self): if CONFIG.fake_mode: raise SkipTest("promote_master not supported in fake mode") assert_raises(exceptions.BadRequest, instance_info.dbaas.instances.promote_to_replica_source, instance_info.id)
def test_create_failure_with_no_volume_size(self): instance_name = "instance-failure-with-no-volume-size" databases = [] volume = {'size': None} assert_raises(nova_exceptions.BadRequest, dbaas.instances.create, instance_name, instance_info.dbaas_flavor_href, volume, databases)
def test_node_tags_del(self): """ Testing DELETE:api/2.0/nodes/:id/tags/:tagName """ codes = [] Api().nodes_get_all() rsp = self.__client.last_response nodes = loads(rsp.data) codes.append(rsp) for n in nodes: for t in self.__test_tags.get('tags'): Api().nodes_del_tag_by_id(identifier=n.get('id'), tag_name=t) rsp = self.__client.last_response codes.append(rsp) Api().nodes_get_by_id(identifier=n.get('id')) rsp = self.__client.last_response codes.append(rsp) updated_node = loads(rsp.data) for t in self.__test_tags.get('tags'): assert_true(t not in updated_node.get('tags'), message= "Tag " + t + " was not deleted" ) for c in codes: assert_equal(200, c.status, message=c.reason) assert_raises(rest.ApiException, Api().nodes_del_tag_by_id, 'fooey',tag_name=['tag'])
def test_node_id_obm(self): """ Testing GET:/api/2.0/nodes/:id/obm """ Api().nodes_get_all() nodes = self.__get_data() LOG.debug(nodes, json=True) codes = [] for n in nodes: if n.get('name') == 'test_compute_node': uuid = n.get('id') Api().nodes_get_obm_by_id(identifier=uuid) rsp = self.__client.last_response LOG.info('OBM setting for node ID {0} is {1}'.format( uuid, rsp.data)) codes.append(rsp) assert_not_equal(0, len(codes), message='Failed to find compute node Ids') for c in codes: assert_equal(200, c.status, message=c.reason) assert_raises(rest.ApiException, Api().nodes_get_obm_by_id, 'fooey')
def test_workflows_action(self): """ Testing PUT:/api/2.0/nodes/:id/workflows/action """ Api().nodes_get_all() nodes = self.__get_data() for n in nodes: if n.get('type') == 'compute': id = n.get('id') timeout = 5 done = False while timeout > 0 and done == False: if 0 == self.__post_workflow(id,'Graph.Discovery'): fail('Timed out waiting for graph to start!') try: Api().nodes_workflow_action_by_id(id, {'command': 'cancel'}) done = True except rest.ApiException as e: if e.status != 404: raise e timeout -= 1 assert_not_equal(timeout, 0, message='Failed to delete an active workflow') assert_raises(rest.ApiException, Api().nodes_workflow_action_by_id, 'fooey', {'command': 'test'})
def test_fails_when_creating_user_twice(self): users = [] users.append({ "name": self.username, "password": self.password, "databases": [{ "name": self.db1 }] }) users.append({ "name": self.username1, "password": self.password1, "databases": [{ "name": self.db1 }, { "name": self.db2 }] }) assert_raises(exceptions.BadRequest, self.dbaas.users.create, instance_info.id, users) assert_equal(400, self.dbaas.last_http_code)
def test_node_tags_patch(self): """ Testing PATCH:/api/2.0/nodes/:id/tags """ codes = [] Api().nodes_get_all() rsp = self.__client.last_response nodes = loads(rsp.data) codes.append(rsp) for n in nodes: LOG.info(n, json=True) Api().nodes_patch_tag_by_id(identifier=n.get('id'), body=self.__test_tags) LOG.info('Creating tag (name={0})'.format(self.__test_tags)) rsp = self.__client.last_response codes.append(rsp) LOG.info(n.get('id')) for c in codes: assert_equal(200, c.status, message=c.reason) assert_raises(rest.ApiException, Api().nodes_patch_tag_by_id, 'fooey', body=self.__test_tags)
def set_custom_hostname_for_provisioned_node(self): """Verify that it is not allowed to change a hostname of a provisioned node Scenario: 1. Revert the snapshot 2. Create a cluster 3. Add a node with controller role 4. Set a custom hostname for the node 5. Provision the node 6. Verify that updating node hostname of the provisioned node is not allowed Duration: 20m """ self.env.revert_snapshot("ready_with_5_slaves") cluster_id = self.fuel_web.create_cluster( name=self.__class__.__name__, mode=settings.DEPLOYMENT_MODE, settings={ 'net_provider': 'neutron', 'net_segment_type': settings.NEUTRON_SEGMENT_TYPE }) self.fuel_web.update_nodes(cluster_id, {'slave-01': ['controller']}) # Set a custom hostname for a node for the 1st time # and provision the node node = self.fuel_web.client.list_cluster_nodes(cluster_id)[0] self.fuel_web.client.set_hostname(node['id'], 'custom-hostname') self.fuel_web.provisioning_cluster_wait(cluster_id) # Try to change the hostname of the provisioned node # TODO(dkruglov): LP#1476722 assert_raises(HTTPError, self.fuel_web.client.set_hostname, node['id'], 'new-custom-hostname') self.env.make_snapshot("set_custom_hostname_for_provisioned_node")
def test_create_failure_with_datastore_notfound(self): if VOLUME_SUPPORT: volume = {'size': CONFIG.get('trove_volume_size', 1)} else: volume = None instance_name = "datastore_notfound" databases = [] users = [] datastore = "nonexistent" try: assert_raises(exceptions.NotFound, dbaas.instances.create, instance_name, instance_info.dbaas_flavor_href, volume, databases, users, datastore=datastore, nics=instance_info.nics) except exceptions.BadRequest as e: assert_equal(e.message, "Datastore '%s' cannot be found." % datastore)
def set_duplicate_hostname(self): """Verify that a duplicate hostname is not allowed Scenario: 1. Revert the snapshot 2. Set a custom hostname for the node 3. Verify that new hostnames are validated to avoid duplicates Duration: 7m """ self.env.revert_snapshot("ready_with_5_slaves") # Set a custom hostname for a node for the 1st time custom_hostname = 'custom-hostname' node = self.fuel_web.client.list_nodes()[0] self.fuel_web.client.set_hostname(node['id'], custom_hostname) # Try to change the hostname of the provisioned node assert_raises(HTTPError, self.fuel_web.client.set_hostname, node, custom_hostname) self.env.make_snapshot("set_duplicate_hostname")
def test_create_cluster_with_different_volumes(self): invalid_request_body_with_different_volumes = [{ "flavorRef": 2, "volume": { "size": 2 } }, { "flavorRef": 2, "volume": { "size": 3 } }] asserts.assert_raises( exceptions.BadRequest, self.rd_client.clusters.create, "test_cluster", self.instance.dbaas_datastore, self.instance.dbaas_datastore_version, instances=invalid_request_body_with_different_volumes) asserts.assert_equal(400, self.rd_client.last_http_code)
def test_create_too_many_instances(self): instance_quota = 0 quota_dict = {'instances': instance_quota} new_quotas = dbaas_admin.quota.update(self.test_info.user.tenant_id, quota_dict) verify_quota = dbaas_admin.quota.show(self.test_info.user.tenant_id) assert_equal(new_quotas['instances'], quota_dict['instances']) assert_equal(0, verify_quota['instances']) assert_equal(CONFIG.reddwarf_max_volumes_per_user, verify_quota['volumes']) self.test_info.volume = {'size': 1} self.test_info.name = "too_many_instances" assert_raises(exceptions.OverLimit, dbaas.instances.create, self.test_info.name, self.test_info.dbaas_flavor_href, self.test_info.volume) assert_equal(413, dbaas.last_http_code)
def test_node_workflows_post(self): """Testing node POST:id/workflows""" resps = [] Nodes().nodes_get() nodes = self.__get_data() for n in nodes: if n.get('type') == 'compute': id = n.get('id') timeout = self.__post_workflow(id, 'Graph.Discovery', {}) if timeout > 0: data = self.__get_data() resps.append({'data': data, 'id': id}) for resp in resps: assert_not_equal(0, len(resp['data']), message='No Workflows found for Node {0}'.format( resp['id'])) assert_raises(rest.ApiException, Nodes().nodes_identifier_workflows_post, 'fooey', 'Graph.Discovery', body={})
def test_node_workflows_del_active(self): """Testing node DELETE:id/workflows/active""" Nodes().nodes_get() nodes = self.__get_data() for n in nodes: if n.get('type') == 'compute': id = n.get('id') timeout = 5 done = False while timeout > 0 and done == False: if 0 == self.__post_workflow(id, 'Graph.Discovery', {}): fail('Timed out waiting for graph to start!') try: Nodes().nodes_identifier_workflows_active_delete(id) done = True except rest.ApiException as e: if e.status != 404: raise e timeout -= 1 assert_raises(rest.ApiException, Nodes().nodes_identifier_workflows_active_delete, 'fooey')
def check_can_not_enable_dpdk_with_tun(self): """Check can not enable DPDK on tun network Scenario: 1. Create new environment with VXLAN segmentation for Neutron 2. Set KVM as Hypervisor 3. Add controller and compute nodes 4. Configure HugePages for compute nodes 5. Try configure private network in DPDK mode """ self.env.revert_snapshot("ready_with_3_slaves") self.show_step(1) self.show_step(2) cluster_id = self.fuel_web.create_cluster( name=self.__class__.__name__, mode=settings.DEPLOYMENT_MODE, settings={ "net_provider": 'neutron', "net_segment_type": "tun" }) self.show_step(3) self.fuel_web.update_nodes( cluster_id, { 'slave-01': ['controller'], 'slave-02': ['compute'], 'slave-03': ['cinder'] }) compute = self.fuel_web.get_nailgun_cluster_nodes_by_roles( cluster_id, ['compute'], role_status='pending_roles')[0] self.show_step(4) self.setup_hugepages(compute, hp_2mb=256, hp_dpdk_mb=128) self.show_step(5) assert_raises(HTTPError, self.enable_dpdk, compute, forceEnable=True)
def test_re_create_user(self): user_list = ["re_create_user"] # create, grant, then check a new user self._add_users(user_list) self._test_access(user_list, []) self._grant_access_singular(user_list[0], self.databases) self._test_access(user_list, self.databases) # drop the user temporarily self.dbaas.users.delete(instance_info.id, user_list[0]) # check his access - user should not be found asserts.assert_raises(exceptions.NotFound, self.dbaas.users.list_access, instance_info.id, user_list[0]) # re-create the user self._add_users(user_list) # check his access - should not exist self._test_access(user_list, []) # grant user access to all database. self._grant_access_singular(user_list[0], self.databases) # check his access - user should exist self._test_access(user_list, self.databases) # revoke users access self._revoke_access_plural(user_list, self.databases)
def test_updateduser_newhost_invalid(self): # Ensure invalid hostnames/usernames aren't allowed to enter the system users = [] username = "******" hostname1 = "192.168.0.1" users.append({ "name": username, "password": "******", "host": hostname1, "databases": [] }) self.dbaas.users.create(instance_info.id, users) hostname1 = hostname1.replace('.', '%2e') assert_raises(exceptions.BadRequest, self.dbaas.users.update_attributes, instance_info.id, username, {"host": "badjuju"}, hostname1) assert_equal(400, self.dbaas.last_http_code) assert_raises(exceptions.BadRequest, self.dbaas.users.update_attributes, instance_info.id, username, {"name": " bad username "}, hostname1) assert_equal(400, self.dbaas.last_http_code) self.dbaas.users.delete(instance_info.id, username, hostname=hostname1)
def assert_raises(self, expected_exception, expected_http_code, client, client_cmd, *cmd_args, **cmd_kwargs): if client: # Make sure that the client_cmd comes from the same client that # was passed in, otherwise asserting the client code may fail. cmd_clz = client_cmd.im_self cmd_clz_name = cmd_clz.__class__.__name__ client_attrs = [ attr[0] for attr in inspect.getmembers(client.real_client) if '__' not in attr[0] ] match = [ getattr(client, a) for a in client_attrs if getattr(client, a).__class__.__name__ == cmd_clz_name ] self.assert_true( any(match), "Could not find method class in client: %s" % client_attrs) self.assert_equal( match[0], cmd_clz, "Test error: client_cmd must be from client obj") asserts.assert_raises(expected_exception, client_cmd, *cmd_args, **cmd_kwargs) self.assert_client_code(client, expected_http_code)
def set_custom_hostname_for_provisioned_node(self): """Verify that it is not allowed to change a hostname of a provisioned node Scenario: 1. Revert the snapshot 2. Create a cluster 3. Add a node with controller role 4. Set a custom hostname for the node 5. Provision the node 6. Verify that updating node hostname of the provisioned node is not allowed Duration: 20m """ self.env.revert_snapshot("ready_with_5_slaves") cluster_id = self.fuel_web.create_cluster( name=self.__class__.__name__, mode=settings.DEPLOYMENT_MODE, ) self.fuel_web.update_nodes(cluster_id, {'slave-01': ['controller']}) # Set a custom hostname for a node for the 1st time # and provision the node node = self.fuel_web.client.list_cluster_nodes(cluster_id)[0] self.fuel_web.client.set_hostname(node['id'], 'custom-hostname') self.fuel_web.provisioning_cluster_wait(cluster_id) # Try to change the hostname of the provisioned node assert_raises(http_exceptions.Forbidden, self.fuel_web.client.set_hostname, node['id'], 'new-custom-hostname') self.env.make_snapshot("set_custom_hostname_for_provisioned_node")
def test_instance_resize_to_non_ephemeral_flavor_should_fail(self): flavor_name = CONFIG.values.get('instance_bigger_flavor_name', 'm1-small') flavors = self.dbaas.find_flavors_by_name(flavor_name) asserts.assert_raises(BadRequest, self.dbaas.instances.resize_instance, self.instance_id, flavors[0].id)
def test_instance_resize_same_size_should_fail(self): asserts.assert_raises(BadRequest, self.dbaas.instances.resize_instance, self.instance_id, self.flavor_id)
def test_root_cannot_be_deleted(self): """Even if root was enabled, the user root cannot be deleted.""" assert_raises(exceptions.BadRequest, self.dbaas.users.delete, self.id, "root")
def test_root_disable_when_root_not_enabled(self): reh = self.dbaas_admin.management.root_enabled_history self.root_enabled_timestamp = reh(self.id).enabled assert_raises(exceptions.NotFound, self.dbaas.root.delete, self.id) self._verify_root_timestamp(self.id)
def test_delete_user_os_admin_failure(self): assert_raises(exceptions.BadRequest, self.dbaas.users.delete, self.id, "os_admin")
def test_create_user_os_admin_failure(self): users = [{"name": "os_admin", "password": "******"}] assert_raises(exceptions.BadRequest, self.dbaas.users.create, self.id, users)
def test_backup_create_instance_not_found(self): """Test create backup with unknown instance.""" assert_raises(exceptions.NotFound, instance_info.dbaas.backups.create, BACKUP_NAME, generate_uuid(), BACKUP_DESC)
def test_flavor_not_found(self): assert_raises(exceptions.NotFound, self.rd_client.flavors.get, "foo")
def assert_raises(self, expected_exception, expected_http_code, client_cmd, *cmd_args, **cmd_kwargs): asserts.assert_raises(expected_exception, client_cmd, *cmd_args, **cmd_kwargs) self.assert_client_code(expected_http_code)
def test_assign_in_wrong_state(self): # test assigning a config to an instance in RESTART state assert_raises(exceptions.BadRequest, instance_info.dbaas.instances.modify, configuration_instance.id, configuration=configuration_info.id)
def test_unable_delete_instance_configurations(self): # test deleting a configuration that is assigned to # an instance is not allowed. assert_raises(exceptions.BadRequest, instance_info.dbaas.configurations.delete, configuration_info.id)
def test_delete_invalid_configuration_not_found(self): # test deleting a configuration that does not exist throws exception invalid_configuration_id = "invalid-config-id" assert_raises(exceptions.NotFound, instance_info.dbaas.configurations.delete, invalid_configuration_id)
def test_configurations_get(self): # test that the instance shows up on the assigned configuration result = instance_info.dbaas.configurations.get(configuration_info.id) assert_equal(configuration_info.id, result.id) assert_equal(configuration_info.name, result.name) assert_equal(configuration_info.description, result.description) # check the result field types with TypeCheck("configuration", result) as check: check.has_field("id", six.string_types) check.has_field("name", six.string_types) check.has_field("description", six.string_types) check.has_field("values", dict) check.has_field("created", six.string_types) check.has_field("updated", six.string_types) check.has_field("instance_count", int) print(result.values) # check for valid timestamps assert_true(_is_valid_timestamp(result.created)) assert_true(_is_valid_timestamp(result.updated)) # check that created and updated timestamps differ, since # test_appending_to_existing_configuration should have changed the # updated timestamp if not CONFIG.fake_mode: assert_not_equal(result.created, result.updated) assert_equal(result.instance_count, 1) with CollectionCheck("configuration_values", result.values) as check: # check each item has the correct type according to the rules for (item_key, item_val) in result.values.items(): print("item_key: %s" % item_key) print("item_val: %s" % item_val) dbaas = instance_info.dbaas param = dbaas.configuration_parameters.get_parameter( instance_info.dbaas_datastore, instance_info.dbaas_datastore_version, item_key) if param.type == 'integer': check.has_element(item_key, int) if param.type == 'string': check.has_element(item_key, six.string_types) if param.type == 'boolean': check.has_element(item_key, bool) # Test to make sure that another user is not able to GET this config reqs = Requirements(is_admin=False) test_auth_user = instance_info.user.auth_user other_user = CONFIG.users.find_user(reqs, black_list=[test_auth_user]) other_user_tenant_id = other_user.tenant_id client_tenant_id = instance_info.user.tenant_id if other_user_tenant_id == client_tenant_id: other_user = CONFIG.users.find_user( reqs, black_list=[instance_info.user.auth_user, other_user]) print(other_user) print(other_user.__dict__) other_client = create_dbaas_client(other_user) assert_raises(exceptions.NotFound, other_client.configurations.get, configuration_info.id)