diff --git a/kingbird/tests/tempest/scenario/consts.py b/kingbird/tests/tempest/scenario/consts.py index 3ab3e65..dd0dc3c 100644 --- a/kingbird/tests/tempest/scenario/consts.py +++ b/kingbird/tests/tempest/scenario/consts.py @@ -15,15 +15,13 @@ DEFAULT_QUOTAS = { - u'quota_set': { - u'metadata_items': 128, u'subnet': 10, - u'floatingip': 50, u'gigabytes': 1000, u'backup_gigabytes': 1000, - u'ram': 51200, u'floating_ips': 10, u'snapshots': 10, - u'security_group_rule': 100, - u'instances': 10, u'key_pairs': 100, u'volumes': 10, u'router': 10, - u'security_group': 10, u'cores': 20, u'backups': 10, u'fixed_ips': -1, - u'port': 50, u'security_groups': 10, u'network': 10 - } + u'metadata_items': 128, u'subnet': 10, + u'floatingip': 50, u'gigabytes': 1000, u'backup_gigabytes': 1000, + u'ram': 51200, u'floating_ips': 10, u'snapshots': 10, + u'security_group_rule': 100, + u'instances': 10, u'key_pairs': 100, u'volumes': 10, u'router': 10, + u'security_group': 10, u'cores': 20, u'backups': 10, u'fixed_ips': -1, + u'port': 50, u'security_groups': 10, u'network': 10 } KEYPAIR_RESOURCE_TYPE = "keypair" diff --git a/kingbird/tests/tempest/scenario/quota_management/client_tests/base.py b/kingbird/tests/tempest/scenario/quota_management/client_tests/base.py index d118d34..9118b8d 100644 --- a/kingbird/tests/tempest/scenario/quota_management/client_tests/base.py +++ b/kingbird/tests/tempest/scenario/quota_management/client_tests/base.py @@ -1,4 +1,4 @@ -# Copyright 2016 Ericsson AB +# Copyright 2016 Ericsson AB. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may @@ -50,8 +50,8 @@ class BaseKingbirdTest(api_version_utils.BaseMicroversionTest, super(BaseKingbirdTest, cls).setup_credentials() session = sync_client.get_session() cls.auth_token = session.get_token() - cls.key_client = sync_client.get_key_client(session) - cls.regions = sync_client.get_regions(cls.key_client) + cls.keystone_client = sync_client.get_keystone_client(session) + cls.regions = sync_client.get_regions(cls.keystone_client) @classmethod def setup_clients(cls): @@ -71,11 +71,12 @@ class BaseKingbirdTest(api_version_utils.BaseMicroversionTest, target_project_name = data_utils.rand_name('kb-target-project') target_user_name = data_utils.rand_name('kb-target-user') cls.openstack_details = sync_client.get_openstack_drivers( - cls.key_client, cls.regions[0], project_name, user_name, + cls.keystone_client, cls.regions[0], project_name, user_name, password, target_project_name, target_user_name) cls.openstack_drivers = cls.openstack_details['os_drivers'] cls.session = cls.openstack_details['session'] cls.token = cls.openstack_details['token'] + cls.target_token = cls.openstack_details['target_token'] cls.resource_ids = sync_client.create_resources(cls.openstack_drivers) cls.resource_ids.update(cls.openstack_details) cls.resource_ids["server_ids"] = [] @@ -90,49 +91,51 @@ class BaseKingbirdTest(api_version_utils.BaseMicroversionTest, sync_client.resource_cleanup(cls.openstack_drivers, cls.resource_ids) @classmethod - def create_custom_kingbird_quota(cls, project_id, target_project_id, - new_quota_values): + def create_custom_kingbird_quota(cls, project_id, new_quota_values): new_values = sync_client.create_custom_kingbird_quota( - cls.token, project_id, target_project_id, new_quota_values) + cls.openstack_drivers, project_id, new_quota_values) return new_values @classmethod - def get_custom_kingbird_quota(cls, project_id, target_project_id): - return_quotas = sync_client.get_custom_kingbird_quota( - cls.token, project_id, target_project_id) + def get_kingbird_quota_another_tenant(cls, target_project_id): + new_values = sync_client.get_kingbird_quota_another_tenant( + cls.openstack_drivers, target_project_id) + return new_values + + @classmethod + def get_own_kingbird_quota(cls, target_project_id): + return_quotas = sync_client.get_own_kingbird_quota( + cls.target_token, target_project_id) return return_quotas @classmethod - def delete_custom_kingbird_quota(cls, project_id, target_project_id, - quota_to_delete=None): - deleted_quotas = sync_client.delete_custom_kingbird_quota( - cls.token, project_id, target_project_id, quota_to_delete) - return deleted_quotas + def delete_custom_kingbird_quota(cls, target_project_id): + sync_client.delete_custom_kingbird_quota( + cls.openstack_drivers, target_project_id) @classmethod def get_default_kingbird_quota(cls, project_id): - return_quotas = sync_client.get_default_kingbird_quota(cls.token, - project_id) + return_quotas = sync_client.get_default_kingbird_quota( + cls.target_token, project_id) return return_quotas @classmethod - def quota_sync_for_project(cls, project_id, target_project_id): + def quota_sync_for_project(cls, project_id): sync_status = sync_client.quota_sync_for_project( - cls.token, project_id, target_project_id) + cls.openstack_drivers, project_id) return sync_status @classmethod - def get_quota_usage_for_project(cls, project_id, target_project_id): + def get_quota_usage_for_project(cls, project_id): quota_usage = sync_client.get_quota_usage_for_project( - cls.token, project_id, target_project_id) + cls.openstack_drivers, project_id) return quota_usage @classmethod - def create_custom_kingbird_quota_wrong_token(cls, project_id, - target_project_id, + def create_custom_kingbird_quota_wrong_token(cls, target_project_id, new_quota_values): - new_values = sync_client.create_custom_kingbird_quota( - 'fake_token', project_id, target_project_id, new_quota_values) + new_values = sync_client.kingbird_create_quota_wrong_token( + cls.openstack_drivers, target_project_id, new_quota_values) return new_values @classmethod @@ -211,20 +214,19 @@ class BaseKingbirdTest(api_version_utils.BaseMicroversionTest, cls.session, cls.regions, project_id, **quota_to_set) @classmethod - def update_quota_for_class(cls, class_name, project_id, - new_quota_values): + def update_quota_for_class(cls, class_name, new_quota_values): new_values = sync_client.update_quota_for_class( - cls.token, class_name, project_id, new_quota_values) + cls.openstack_drivers, class_name, new_quota_values) return new_values @classmethod - def get_quota_for_class(cls, class_name, project_id): + def get_quota_for_class(cls, class_name): return_quotas = sync_client.get_quota_for_class( - cls.token, class_name, project_id) + cls.openstack_drivers, class_name) return return_quotas @classmethod - def delete_quota_for_class(cls, class_name, project_id): + def delete_quota_for_class(cls, class_name): deleted_quotas = sync_client.delete_quota_for_class( - cls.token, class_name, project_id) + cls.openstack_drivers, class_name) return deleted_quotas diff --git a/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_class_api.py b/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_class_api.py index 46ea8b4..c60b28e 100644 --- a/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_class_api.py +++ b/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_class_api.py @@ -13,10 +13,15 @@ # License for the specific language governing permissions and limitations # under the License. +import kingbirdclient + from kingbird.tests.tempest.scenario.quota_management. \ client_tests import base +from kingbird.tests import utils DEFAULT_CLASS = "default" +DEFAULT_QUOTAS = base.DEFAULT_QUOTAS +QUOTA_CLASS_FORMAT = base.DEFAULT_QUOTAS.copy() class KingbirdQuotaClassTestJSON(base.BaseKingbirdTest): @@ -38,60 +43,68 @@ class KingbirdQuotaClassTestJSON(base.BaseKingbirdTest): super(KingbirdQuotaClassTestJSON, self).resource_setup() self.create_resources() + def _delete_quota_values(self, class_name): + quota_value = self.get_quota_for_class(class_name) + resource_value = quota_value['cores'] + return resource_value == DEFAULT_QUOTAS['cores'] + def test_kb_quota_class_put_method(self): - new_quota = {"quota_class_set": {"instances": 15, "cores": 10}} + new_quota = {"instances": 15, "cores": 10} actual_value = self.update_quota_for_class( - self.class_name, self.resource_ids["project_id"], - new_quota) - new_quota["quota_class_set"].update({"id": self.class_name}) - self.assertEqual(new_quota, eval(actual_value)) - self.delete_quota_for_class(self.class_name, - self.resource_ids["project_id"]) + self.class_name, new_quota) + expected_value = QUOTA_CLASS_FORMAT + expected_value['cores'] = 10 + expected_value['instances'] = 15 + expected_value['class_name'] = self.class_name + self.assertEqual(expected_value, actual_value) + self.delete_quota_for_class(self.class_name) + utils.wait_until_true( + lambda: self._delete_quota_values(self.class_name), + exception=RuntimeError("Timed out ")) def test_kb_quota_class_get_method(self): - new_quota = {"quota_class_set": {"instances": 15, "cores": 10}} - self.update_quota_for_class( - self.class_name, self.resource_ids["project_id"], new_quota) - actual_value = self.get_quota_for_class( - self.class_name, self.resource_ids["project_id"]) - new_quota["quota_class_set"].update({'id': self.class_name}) - self.assertEqual(new_quota, eval(actual_value)) - self.delete_quota_for_class(self.class_name, - self.resource_ids["project_id"]) + new_quota = {"instances": 15, "cores": 10} + self.update_quota_for_class(self.class_name, new_quota) + actual_value = self.get_quota_for_class(self.class_name) + expected_value = QUOTA_CLASS_FORMAT + expected_value['cores'] = 10 + expected_value['instances'] = 15 + expected_value['class_name'] = self.class_name + self.assertEqual(expected_value, actual_value) + self.delete_quota_for_class(self.class_name) + utils.wait_until_true( + lambda: self._delete_quota_values(self.class_name), + exception=RuntimeError("Timed out ")) def test_kb_quota_class_delete_method(self): - new_quota = {"quota_class_set": {"instances": 15, "cores": 10}} - self.update_quota_for_class( - self.class_name, self.resource_ids["project_id"], new_quota) - self.delete_quota_for_class(self.class_name, - self.resource_ids["project_id"]) - quota_after_delete = eval(self.get_quota_for_class( - self.class_name, self.resource_ids["project_id"])) - self.assertNotIn("cores", quota_after_delete["quota_class_set"]) - self.assertNotIn("instances", quota_after_delete["quota_class_set"]) + new_quota = {"instances": 15, "cores": 15} + self.update_quota_for_class(self.class_name, new_quota) + self.delete_quota_for_class(self.class_name) + utils.wait_until_true( + lambda: self._delete_quota_values(self.class_name), + exception=RuntimeError("Timed out ")) + quota_after_delete = self.get_quota_for_class(self.class_name) + self.assertNotEqual(quota_after_delete['cores'], 15) + self.assertNotEqual(quota_after_delete['instances'], 15) def test_kb_quota_class_wrong_input(self): - new_quota = {"quota_class_unset": {"instances": 15, "cores": 10}} - actual_value = self.update_quota_for_class( - self.class_name, self.resource_ids["project_id"], new_quota) - self.assertIn("Missing quota_class_set in the body", actual_value) - - def test_kb_quota_class_wrong_quotas(self): - new_quota = {"quota_class_set": {"instan": 15, "cor": 10}} - actual_value = self.update_quota_for_class( - self.class_name, self.resource_ids["project_id"], - new_quota) - self.assertEmpty(actual_value) + new_quota = {"instanc": 15, "cores": 10} + self.assertRaises(kingbirdclient.exceptions.APIException, + self.update_quota_for_class, self.class_name, + new_quota) def test_kb_quota_default_class_get_method(self): - actual_value = self.get_quota_for_class( - DEFAULT_CLASS, self.resource_ids["project_id"]) - expected_value = {"quota_class_set": base.DEFAULT_QUOTAS["quota_set"]} - expected_value["quota_class_set"].update({"id": DEFAULT_CLASS}) - self.assertEqual(eval(actual_value), expected_value) + actual_value = self.get_quota_for_class(DEFAULT_CLASS) + expected_value = DEFAULT_QUOTAS + expected_value['class_name'] = DEFAULT_CLASS + self.assertEqual(actual_value, expected_value) - def test_kb_quota_class_get_method_wrong_class_name(self): - actual_value = self.get_quota_for_class( - "no_class", self.resource_ids["project_id"]) - expected_value = {"quota_class_set": {"id": "no_class"}} - self.assertEqual(eval(actual_value), expected_value) + def test_kb_quota_class_get_method_for_random_class_name(self): + actual_value = self.get_quota_for_class("random_class") + expected_value = DEFAULT_QUOTAS + expected_value['class_name'] = "random_class" + self.assertEqual(actual_value, expected_value) + + def test_delete_quota_for_random_class(self): + self.assertRaisesRegex(kingbirdclient.exceptions.APIException, "404 *", + self.delete_quota_for_class, 'random_class') diff --git a/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_management_api.py b/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_management_api.py index 6317b51..a2fb42f 100644 --- a/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_management_api.py +++ b/kingbird/tests/tempest/scenario/quota_management/client_tests/test_quota_management_api.py @@ -1,4 +1,4 @@ -# Copyright 2016 Ericsson AB +# Copyright 2016 Ericsson AB. # All Rights Reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); you may @@ -17,6 +17,7 @@ from kingbird.tests.tempest.scenario.quota_management. \ client_tests import base from tempest import config +import kingbirdclient import novaclient CONF = config.CONF @@ -43,166 +44,114 @@ class KingbirdQMTestJSON(base.BaseKingbirdTest): self.create_resources() def test_kingbird_put_method(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} - response = self.create_custom_kingbird_quota( - self.resource_ids["project_id"], + new_quota = {"instances": 15, "cores": 10} + actual_value = self.create_custom_kingbird_quota( self.resource_ids["target_project_id"], new_quota) - actual_value = response.json() - expected_value = { - self.resource_ids["target_project_id"]: new_quota["quota_set"] - } - self.assertEqual(expected_value, actual_value) + self.assertEqual(new_quota, actual_value) def test_kingbird_get_another_tenant_quota(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} + new_quota = {"instances": 15, "cores": 10} self.create_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["target_project_id"], new_quota) - actual_value = self.get_custom_kingbird_quota( - self.resource_ids["project_id"], + new_quota['project_id'] = self.resource_ids["target_project_id"] + actual_value = self.get_kingbird_quota_another_tenant( self.resource_ids["target_project_id"]) - new_quota["quota_set"].update( - {'project_id': self.resource_ids["target_project_id"]} - ) - self.assertEqual(new_quota, eval(actual_value)) + self.assertEqual(new_quota, actual_value) def test_kingbird_get_own_quota(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} + new_quota = {"instances": 15, "cores": 10} self.create_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["project_id"], - new_quota) - actual_value = self.get_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["project_id"]) - new_quota["quota_set"].update( - {'project_id': self.resource_ids["project_id"]} - ) - self.assertEqual(new_quota, eval(actual_value)) - - def test_kingbird_delete_method(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} - quota_to_delete = {"quota_set": ["cores"]} - self.create_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["target_project_id"], new_quota) - self.delete_custom_kingbird_quota( - self.resource_ids["project_id"], - self.resource_ids["target_project_id"], - quota_to_delete) - quota_after_delete = eval(self.get_custom_kingbird_quota( - self.resource_ids["project_id"], - self.resource_ids["target_project_id"])) - self.assertNotIn("cores", quota_after_delete["quota_set"]) + new_quota['project_id'] = self.resource_ids["target_project_id"] + actual_value = self.get_own_kingbird_quota( + self.resource_ids["target_project_id"]) + self.assertEqual(new_quota, actual_value) def test_kingbird_delete_all_method(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} + new_quota = {"instances": 15, "cores": 10} self.create_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["target_project_id"], new_quota) self.delete_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["target_project_id"]) - actual_quota_after_delete = eval(self.get_custom_kingbird_quota( - self.resource_ids["project_id"], - self.resource_ids["target_project_id"])) + actual_quota_after_delete = self.get_kingbird_quota_another_tenant( + self.resource_ids["target_project_id"]) expected_quota_after_delete = { - "quota_set": { - "project_id": self.resource_ids["target_project_id"] - } + "project_id": self.resource_ids["target_project_id"] } self.assertEqual(expected_quota_after_delete, actual_quota_after_delete) def test_kingbird_get_default_method_after_update(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} + new_quota = {"instances": 15, "cores": 10} self.create_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["project_id"], - new_quota) + self.resource_ids["target_project_id"], new_quota) actual_value = self.get_default_kingbird_quota( - self.resource_ids["project_id"]) - if 'id' in DEFAULT_QUOTAS['quota_set']: - del DEFAULT_QUOTAS['quota_set']['id'] - self.assertEqual(eval(actual_value), DEFAULT_QUOTAS) - self.delete_custom_kingbird_quota(self.resource_ids["project_id"], - self.resource_ids["project_id"]) + self.resource_ids["target_project_id"]) + self.assertEqual(actual_value, DEFAULT_QUOTAS) + self.delete_custom_kingbird_quota( + self.resource_ids["target_project_id"]) + + def test_kingbird_put_method_wrong_token(self): + new_quota = {"instances": 15, "cores": 10} + self.assertRaisesRegex( + kingbirdclient.exceptions.APIException, "401 *", + self.create_custom_kingbird_quota_wrong_token, + self.resource_ids["target_project_id"], new_quota) + + def test_kingbird_get_default_method_after_delete(self): + new_quota = {"instances": 15, "cores": 10} + self.create_custom_kingbird_quota( + self.resource_ids["target_project_id"], new_quota) + self.delete_custom_kingbird_quota( + self.resource_ids["target_project_id"]) + actual_value = self.get_default_kingbird_quota( + self.resource_ids["target_project_id"]) + self.assertEqual(actual_value, DEFAULT_QUOTAS) def test_get_quota_usage_for_project(self): self.create_instance(count=1) actual_usage = self.get_quota_usage_for_project( - self.resource_ids["project_id"], self.resource_ids["project_id"]) + self.resource_ids["project_id"]) expected_usage = self.get_usage_manually( self.resource_ids["project_id"]) - self.assertEqual(eval(actual_usage)["quota_set"]['usage']["ram"], + self.assertEqual(actual_usage["ram"][1], expected_usage["quota_set"]["ram"]) - self.assertEqual(eval(actual_usage)["quota_set"]['usage']["cores"], + self.assertEqual(actual_usage["cores"][1], expected_usage["quota_set"]["cores"]) - self.assertEqual(eval(actual_usage)["quota_set"]['usage']["instances"], + self.assertEqual(actual_usage["instances"][1], expected_usage["quota_set"]["instances"]) - self.assertEqual(eval(actual_usage)["quota_set"]['usage']["network"], + self.assertEqual(actual_usage["network"][1], expected_usage["quota_set"]["network"]) - self.assertEqual(eval(actual_usage)["quota_set"]['usage']["subnet"], + self.assertEqual(actual_usage["subnet"][1], expected_usage["quota_set"]["subnet"]) - self.assertEqual(eval(actual_usage)["quota_set"]['usage']["volumes"], + self.assertEqual(actual_usage["volumes"][1], expected_usage["quota_set"]["volumes"]) self.delete_instance() - def test_kingbird_put_method_wrong_token(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} - response = self.create_custom_kingbird_quota_wrong_token( - self.resource_ids["project_id"], - self.resource_ids["target_project_id"], - new_quota) - self.assertEqual(response.status_code, 401) - def test_quota_sync_for_project(self): # Delete custom quota if there are any for this project self.delete_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["project_id"]) self.create_instance() - sync_status = self.quota_sync_for_project( - self.resource_ids["project_id"], - self.resource_ids["project_id"]) - expected_status = u"triggered quota sync for " + \ - self.resource_ids["project_id"] + self.quota_sync_for_project(self.resource_ids["project_id"]) calculated_limits = self.calculate_quota_limits( self.resource_ids["project_id"]) self.wait_sometime_for_sync() - actual_limits = self.get_actual_limits(self.resource_ids["project_id"]) - self.assertEqual(calculated_limits, actual_limits) - self.assertEqual(eval(sync_status), expected_status) - self.delete_instance() - - def test_kingbird_get_default_method_after_delete(self): - new_quota = {"quota_set": {"instances": 15, "cores": 10}} - self.create_custom_kingbird_quota( - self.resource_ids["project_id"], self.resource_ids["project_id"], - new_quota) - self.delete_custom_kingbird_quota(self.resource_ids["project_id"], - self.resource_ids["project_id"]) - actual_value = self.get_default_kingbird_quota( + actual_limits = self.get_actual_limits( self.resource_ids["project_id"]) - if 'id' in DEFAULT_QUOTAS['quota_set']: - del DEFAULT_QUOTAS['quota_set']['id'] - self.assertEqual(eval(actual_value), DEFAULT_QUOTAS) - self.delete_custom_kingbird_quota(self.resource_ids["project_id"], - self.resource_ids["project_id"]) + self.assertEqual(calculated_limits, actual_limits) + self.delete_instance() def test_quota_exceed_after_sync(self): - new_quota = {"quota_set": {"instances": 2}} + new_quota = {"instances": 2} self.create_custom_kingbird_quota(self.resource_ids["project_id"], - self.resource_ids["project_id"], new_quota) - self.quota_sync_for_project(self.resource_ids["project_id"], - self.resource_ids["project_id"]) + self.quota_sync_for_project(self.resource_ids["project_id"]) self.wait_sometime_for_sync() - try: - self.create_instance(count=3) - except Exception as exp: - self.assertIsInstance(exp, novaclient.exceptions.Forbidden) - message = exp.message - self.assertIn(u"Quota exceeded for instances", message) + self.assertRaises(novaclient.exceptions.Forbidden, + self.create_instance, count=3) self.delete_instance() diff --git a/kingbird/tests/tempest/scenario/quota_management/sync_client.py b/kingbird/tests/tempest/scenario/quota_management/sync_client.py index 1f00c18..edcfffd 100644 --- a/kingbird/tests/tempest/scenario/quota_management/sync_client.py +++ b/kingbird/tests/tempest/scenario/quota_management/sync_client.py @@ -14,14 +14,13 @@ # limitations under the License. import collections -import json -import requests import time from cinderclient import client as ci_client from keystoneclient.auth.identity import v3 from keystoneclient import session from keystoneclient.v3 import client as ks_client +from kingbirdclient.api.v1 import client as kb_client from neutronclient.neutron import client as nt_client from novaclient import client as nv_client from oslo_log import log as logging @@ -38,8 +37,7 @@ NETWORK_NAME = "kb_test_network" SUBNET_NAME = "kb_test_subnet" SERVER_NAME = "kb_test_server" SUBNET_RANGE = "192.168.199.0/24" -quota_api_url = "/os-quota-sets/" -quota_class_api_url = "/os-quota-class-sets/" +KINGBIRD_URL = CONF.kingbird.endpoint_url + CONF.kingbird.api_version LOG = logging.getLogger(__name__) @@ -64,28 +62,35 @@ def get_current_session(username, password, tenant_name): return sess -def get_openstack_drivers(key_client, region, project_name, user_name, +def get_openstack_drivers(keystone_client, region, project_name, user_name, password, target_project_name, target_user_name): + resources = dict() # Create Project, User and assign role to new user - project = key_client.projects.create(project_name, - CONF.auth.admin_domain_name) - user = key_client.users.create(user_name, CONF.auth.admin_domain_name, - project.id, password) - target_project = key_client.projects.create(target_project_name, - CONF.auth.admin_domain_name) - target_user = key_client.users.create(target_user_name, - CONF.auth.admin_domain_name, - target_project.id, password) + project = keystone_client.projects.create(project_name, + CONF.auth.admin_domain_name) + user = keystone_client.users.create(user_name, CONF.auth.admin_domain_name, + project.id, password) + target_project = keystone_client.projects.create( + target_project_name, CONF.auth.admin_domain_name) + target_user = keystone_client.users.create(target_user_name, + CONF.auth.admin_domain_name, + target_project.id, password) admin_role = [current_role.id for current_role in - key_client.roles.list() if current_role.name == 'admin'][0] + keystone_client.roles.list() + if current_role.name == 'admin'][0] mem_role = [current_role.id for current_role in - key_client.roles.list() + keystone_client.roles.list() if current_role.name == 'Member'][0] - key_client.roles.grant(admin_role, user=user, project=project) - key_client.roles.grant(mem_role, user=target_user, project=target_project) + keystone_client.roles.grant(admin_role, user=user, project=project) + keystone_client.roles.grant(mem_role, user=target_user, + project=target_project) session = get_current_session(user_name, password, project_name) - new_key_client = ks_client.Client(session=session) - token = new_key_client.session.get_token() + target_session = get_current_session(target_user_name, password, + target_project_name) + target_keystone_client = ks_client.Client(session=target_session) + target_token = target_keystone_client.session.get_token() + new_keystone_client = ks_client.Client(session=session) + token = new_keystone_client.session.get_token() nova_client = nv_client.Client(NOVA_API_VERSION, session=session, region_name=region) @@ -93,19 +98,32 @@ def get_openstack_drivers(key_client, region, project_name, user_name, region_name=region) cinder_client = ci_client.Client(CINDER_API_VERSION, session=session, region_name=region) - return {"user_id": user.id, "project_id": project.id, "session": session, - "token": token, "target_project_id": target_project.id, - "target_user_id": target_user.id, - "os_drivers": [key_client, nova_client, neutron_client, - cinder_client]} + kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL, + auth_token=token, + project_id=project.id) + dummy_kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL, + auth_token='fake_token', + project_id=project.id) + resources = {"user_id": user.id, "project_id": project.id, + "session": session, "token": token, + "target_token": target_token, + "target_project_id": target_project.id, + "target_user_id": target_user.id, + "os_drivers": {'keystone': keystone_client, + 'nova': nova_client, + 'neutron': neutron_client, + 'cinder': cinder_client, + 'kingbird': kingbird_client, + 'dummy_kb': dummy_kingbird_client}} + return resources -def get_key_client(session): +def get_keystone_client(session): return ks_client.Client(session=session) def create_instance(openstack_drivers, resource_ids, count=1): - nova_client = openstack_drivers[1] + nova_client = openstack_drivers['nova'] server_ids = [] image = nova_client.images.find(id=CONF.compute.image_ref) flavor = nova_client.flavors.find(id=resource_ids['flavor_id']) @@ -121,75 +139,71 @@ def create_instance(openstack_drivers, resource_ids, count=1): raise e -def get_urlstring_and_headers(token, project_id, api_url): - headers = { - 'Content-Type': 'application/json', - 'X-Auth-Token': token, - } - url_string = CONF.kingbird.endpoint_url + CONF.kingbird.api_version + \ - "/" + project_id + api_url - - return headers, url_string +def create_custom_kingbird_quota(openstack_drivers, project_id, new_quota): + kingbird_client = openstack_drivers['kingbird'] + kwargs = new_quota + response = kingbird_client.quota_manager.\ + update_global_limits(project_id, **kwargs) + result = {i._data: i._Limit for i in response} + return result -def create_custom_kingbird_quota(token, project_id, target_project_id, - new_quota_values): - body = json.dumps(new_quota_values) - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_api_url) - url_string = url_string + target_project_id - response = requests.put(url_string, headers=headers, data=body) - return response +def get_kingbird_quota_another_tenant(openstack_drivers, project_id): + kingbird_client = openstack_drivers['kingbird'] + response = kingbird_client.quota_manager.\ + global_limits(project_id) + result = {i._data: i._Limit for i in response} + return result -def get_custom_kingbird_quota(token, project_id, target_project_id): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_api_url) - url_string = url_string + target_project_id - response = requests.get(url_string, headers=headers) - return response.text +def get_own_kingbird_quota(token, project_id): + kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL, + auth_token=token, + project_id=project_id) + response = kingbird_client.quota_manager.\ + global_limits(project_id) + result = {i._data: i._Limit for i in response} + return result -def delete_custom_kingbird_quota(token, project_id, target_project_id, - quota_to_delete=None): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_api_url) - url_string = url_string + target_project_id - if quota_to_delete: - body = json.dumps(quota_to_delete) - response = requests.delete(url_string, headers=headers, data=body) - else: - response = requests.delete(url_string, headers=headers) - return response.text +def delete_custom_kingbird_quota(openstack_drivers, target_project_id): + kingbird_client = openstack_drivers['kingbird'] + kingbird_client.quota_manager.delete_quota(target_project_id) def get_default_kingbird_quota(token, project_id): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_api_url) - url_string = url_string + "defaults" - response = requests.get(url_string, headers=headers) - return response.text + kingbird_client = kb_client.Client(kingbird_url=KINGBIRD_URL, + auth_token=token, + project_id=project_id) + response = kingbird_client.quota_manager.\ + list_defaults() + result = {i._data: i._Limit for i in response} + return result -def quota_sync_for_project(token, project_id, target_project_id): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_api_url) - url_string = url_string + target_project_id + "/sync" - response = requests.put(url_string, headers=headers) - return response.text +def kingbird_create_quota_wrong_token(openstack_drivers, + project_id, new_quota): + kingbird_client = openstack_drivers['dummy_kb'] + kwargs = new_quota + kingbird_client.quota_manager.\ + update_global_limits(project_id, **kwargs) -def get_quota_usage_for_project(token, project_id, target_project_id): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_api_url) - url_string = url_string + target_project_id + "/detail" - response = requests.get(url_string, headers=headers) - return response.text +def quota_sync_for_project(openstack_drivers, project_id): + kingbird_client = openstack_drivers['kingbird'] + kingbird_client.quota_manager.sync_quota(project_id) -def get_regions(key_client): +def get_quota_usage_for_project(openstack_drivers, project_id): + kingbird_client = openstack_drivers['kingbird'] + data = kingbird_client.quota_manager.quota_detail(project_id) + response = {items._data: [items._Limit, items._Usage] for items in data} + return response + + +def get_regions(keystone_client): return [current_region.id for current_region in - key_client.regions.list()] + keystone_client.regions.list()] def delete_resource_with_timeout(service_client, resource_ids, service_type): @@ -228,31 +242,31 @@ def delete_resource_with_timeout(service_client, resource_ids, service_type): def delete_instance(openstack_drivers, resource_ids): delete_resource_with_timeout( - openstack_drivers[1], + openstack_drivers['nova'], resource_ids['server_ids'], 'nova') resource_ids['server_ids'] = [] def delete_volume(openstack_drivers, resource_ids): delete_resource_with_timeout( - openstack_drivers[3], + openstack_drivers['cinder'], resource_ids['volume_ids'], 'cinder') resource_ids['volume_ids'] = [] def resource_cleanup(openstack_drivers, resource_ids): - key_client = openstack_drivers[0] - nova_client = openstack_drivers[1] - neutron_client = openstack_drivers[2] + keystone_client = openstack_drivers['keystone'] + nova_client = openstack_drivers['nova'] + neutron_client = openstack_drivers['neutron'] delete_instance(openstack_drivers, resource_ids) delete_volume(openstack_drivers, resource_ids) nova_client.flavors.delete(resource_ids['flavor_id']) neutron_client.delete_subnet(resource_ids['subnet_id']) neutron_client.delete_network(resource_ids['network_id']) - key_client.projects.delete(resource_ids['project_id']) - key_client.projects.delete(resource_ids['target_project_id']) - key_client.users.delete(resource_ids['user_id']) - key_client.users.delete(resource_ids['target_user_id']) + keystone_client.projects.delete(resource_ids['project_id']) + keystone_client.projects.delete(resource_ids['target_project_id']) + keystone_client.users.delete(resource_ids['user_id']) + keystone_client.users.delete(resource_ids['target_user_id']) def get_usage_from_os_client(session, regions, project_id): @@ -311,9 +325,9 @@ def get_actual_limits(session, regions, project_id): def create_resources(openstack_drivers): - nova_client = openstack_drivers[1] - neutron_client = openstack_drivers[2] - cinder_client = openstack_drivers[3] + nova_client = openstack_drivers['nova'] + neutron_client = openstack_drivers['neutron'] + cinder_client = openstack_drivers['cinder'] volume = cinder_client.volumes.create(VOLUME_SIZE, name=VOLUME_NAME) flavor = nova_client.flavors.create( @@ -347,26 +361,24 @@ def set_default_quota(session, regions, project_id, **quota_to_set): nova_client.quotas.update(project_id, **quota_to_set) -def update_quota_for_class(token, class_name, project_id, new_quota_values): - body = json.dumps(new_quota_values) - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_class_api_url) - url_string = url_string + class_name - response = requests.put(url_string, headers=headers, data=body) - return response.text +def update_quota_for_class(openstack_drivers, class_name, new_quota_values): + kingbird_client = openstack_drivers['kingbird'] + kwargs = new_quota_values + response = kingbird_client.quota_class_manager.\ + quota_class_update(class_name, **kwargs) + result = {i._data: i._Limit for i in response} + return result -def get_quota_for_class(token, class_name, project_id): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_class_api_url) - url_string = url_string + class_name - response = requests.get(url_string, headers=headers) - return response.text +def get_quota_for_class(openstack_drivers, class_name): + kingbird_client = openstack_drivers['kingbird'] + response = kingbird_client.quota_class_manager.\ + list_quota_class(class_name) + result = {i._data: i._Limit for i in response} + return result -def delete_quota_for_class(token, class_name, project_id): - headers, url_string = get_urlstring_and_headers(token, project_id, - quota_class_api_url) - url_string = url_string + class_name - response = requests.delete(url_string, headers=headers) - return response.text +def delete_quota_for_class(openstack_drivers, class_name): + kingbird_client = openstack_drivers['kingbird'] + kingbird_client.quota_class_manager.\ + delete_quota_class(class_name)