def test_users_contains_correct_endpoint_type(self, mock_identity): credential = oscredential.OpenStackCredential( "foo_url", "foo", "foo_pass", endpoint_type=consts.EndpointType.INTERNAL) config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "admin": { "credential": credential }, "task": { "uuid": "task_id", "deployment_uuid": "deployment_id" } } user_generator = users.UserGenerator(config) users_ = user_generator._create_users() for user in users_: self.assertEqual("internal", user["credential"].endpoint_type)
def test__create_tenants(self, mock_keystone, mock_sleep): user_generator = users.UserGenerator(self.context) user_generator.config["tenants"] = 1 tenants = user_generator._create_tenants() self.assertEqual(1, len(tenants)) id, tenant = tenants.popitem() self.assertIn("name", tenant)
def test__delete_users(self, mock_identity): user_generator = users.UserGenerator(self.context) user1 = mock.MagicMock() user2 = mock.MagicMock() user_generator.context["users"] = [user1, user2] user_generator._delete_users() self.assertEqual(0, len(user_generator.context["users"]))
def test__create_tenants(self, mock_identity): self.context["config"]["users"]["tenants"] = 1 user_generator = users.UserGenerator(self.context) tenants = user_generator._create_tenants() self.assertEqual(1, len(tenants)) id, tenant = tenants.popitem() self.assertIn("name", tenant)
def test_users_contains_correct_endpoint_type(self, mock_keystone): endpoint = objects.Endpoint("foo_url", "foo", "foo_pass", endpoint_type=consts.EndpointType.INTERNAL) config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "admin": { "endpoint": endpoint }, "task": { "uuid": "task_id" } } user_generator = users.UserGenerator(config) users_ = user_generator._create_users() for user in users_: self.assertEqual("internal", user["endpoint"].endpoint_type)
def test__remove_associated_networks_failure(self, mock_check_service_status): def fake_get_network(req_network): for network in networks: if network.project_id == req_network.project_id: return network networks = [ mock.MagicMock(project_id="t1"), mock.MagicMock(project_id="t4") ] nova_admin = mock.MagicMock() clients = mock.MagicMock() self.osclients.Clients.return_value = clients clients.services.return_value = {"compute": "nova"} clients.nova.return_value = nova_admin nova_admin.networks.list.return_value = networks nova_admin.networks.get = fake_get_network nova_admin.networks.disassociate.side_effect = Exception() user_generator = users.UserGenerator(self.context) user_generator.context["tenants"] = { "t1": { "id": "t1", "name": "t1" }, "t2": { "id": "t2", "name": "t2" } } user_generator._remove_associated_networks() mock_check_service_status.assert_called_once_with( mock.ANY, "nova-network") nova_admin.networks.disassociate.assert_called_once_with(networks[0])
def _get_user_ctx_for_validation(self, ctx): if self.existing_users: ctx["config"] = {"existing_users": self.existing_users} user_context = existing_users.ExistingUsers(ctx) else: user_context = users_ctx.UserGenerator(ctx) return user_context
def test__delete_tenants_failure(self, mock_keystone): wrapped_keystone = mock_keystone.wrap.return_value wrapped_keystone.delete_project.side_effect = Exception() user_generator = users.UserGenerator(self.context) user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"}, "t2": {"id": "t2", "name": "t2"}} user_generator._delete_tenants() self.assertEqual(len(user_generator.context["tenants"]), 0)
def test_setup_and_cleanup_failure(self, mock_keystone): wrapped_keystone = mock_keystone.wrap.return_value wrapped_keystone.create_user.side_effect = Exception() with users.UserGenerator(self.context) as ctx: self.assertRaises(exceptions.ContextSetupFailure, ctx.setup) # Ensure that tenants get deleted anyway self.assertEqual(len(ctx.context["tenants"]), 0)
def test__delete_tenants_failure(self, mock_identity): identity_service = mock_identity.Identity.return_value identity_service.delete_project.side_effect = Exception() user_generator = users.UserGenerator(self.context) user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"}, "t2": {"id": "t2", "name": "t2"}} user_generator._delete_tenants() self.assertEqual(0, len(user_generator.context["tenants"]))
def test___init__for_existing_users(self): foo_user = mock.Mock() self.platforms["openstack"]["users"] = [foo_user] user_generator = users.UserGenerator(self.context) self.assertEqual([foo_user], user_generator.existing_users) self.assertEqual({"user_choice_method": "random"}, user_generator.config) # the case #2: the config with `user_choice_method` option self.context["config"]["users"] = {"user_choice_method": "foo"} user_generator = users.UserGenerator(self.context) self.assertEqual([foo_user], user_generator.existing_users) self.assertEqual({"user_choice_method": "foo"}, user_generator.config)
def test__delete_users_failure(self, mock_identity): identity_service = mock_identity.Identity.return_value identity_service.delete_user.side_effect = Exception() user_generator = users.UserGenerator(self.context) user1 = mock.MagicMock() user2 = mock.MagicMock() user_generator.context["users"] = [user1, user2] user_generator._delete_users() self.assertEqual(len(user_generator.context["users"]), 0)
def test__delete_users_failure(self, mock_keystone): wrapped_keystone = mock_keystone.wrap.return_value wrapped_keystone.delete_user.side_effect = Exception() user_generator = users.UserGenerator(self.context) user1 = mock.MagicMock() user2 = mock.MagicMock() user_generator.context["users"] = [user1, user2] user_generator._delete_users() self.assertEqual(len(user_generator.context["users"]), 0)
def test_users_and_tenants_in_context(self, mock_keystone): wrapped_keystone = mock.MagicMock() mock_keystone.wrap.return_value = wrapped_keystone endpoint = objects.Endpoint("foo_url", "foo", "foo_pass", https_insecure=True, https_cacert="cacert") tmp_context = dict(self.context) tmp_context["config"]["users"] = { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } tmp_context["admin"]["endpoint"] = endpoint endpoint_dict = endpoint.to_dict(False) user_list = [ mock.MagicMock(id="id_%d" % i) for i in range(self.users_num) ] wrapped_keystone.create_user.side_effect = user_list with users.UserGenerator(tmp_context) as ctx: ctx.generate_random_name = mock.Mock() ctx.setup() create_tenant_calls = [] for i, t in enumerate(ctx.context["tenants"]): create_tenant_calls.append( mock.call(ctx.generate_random_name.return_value, ctx.config["project_domain"])) for user in ctx.context["users"]: self.assertEqual(set(["id", "endpoint", "tenant_id"]), set(user.keys())) user_endpoint_dict = user["endpoint"].to_dict(False) excluded_keys = [ "auth_url", "username", "password", "tenant_name", "region_name", "project_domain_name", "admin_domain_name", "user_domain_name" ] for key in (set(endpoint_dict.keys()) - set(excluded_keys)): self.assertEqual(endpoint_dict[key], user_endpoint_dict[key]) tenants_ids = [] for t in ctx.context["tenants"].keys(): tenants_ids.append(t) for (user, tenant_id, orig_user) in zip(ctx.context["users"], tenants_ids, user_list): self.assertEqual(user["id"], orig_user.id) self.assertEqual(user["tenant_id"], tenant_id)
def test__create_users(self, mock_identity): self.context["config"]["users"]["users_per_tenant"] = 2 user_generator = users.UserGenerator(self.context) user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"}, "t2": {"id": "t2", "name": "t2"}} users_ = user_generator._create_users() self.assertEqual(4, len(users_)) for user in users_: self.assertIn("id", user) self.assertIn("credential", user)
def test__create_users(self, mock_keystone, mock_sleep): user_generator = users.UserGenerator(self.context) user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"}, "t2": {"id": "t2", "name": "t2"}} user_generator.config["users_per_tenant"] = 2 users_ = user_generator._create_users() self.assertEqual(4, len(users_)) for user in users_: self.assertIn("id", user) self.assertIn("endpoint", user)
def test_users_and_tenants_in_context(self, mock_identity): identity_service = mock_identity.Identity.return_value credential = oscredential.OpenStackCredential("foo_url", "foo", "foo_pass", https_insecure=True, https_cacert="cacert") tmp_context = dict(self.context) tmp_context["config"]["users"] = { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } tmp_context["admin"]["credential"] = credential credential_dict = credential.to_dict() user_list = [ mock.MagicMock(id="id_%d" % i) for i in range(self.users_num) ] identity_service.create_user.side_effect = user_list with users.UserGenerator(tmp_context) as ctx: ctx.generate_random_name = mock.Mock() ctx.setup() create_tenant_calls = [] for i, t in enumerate(ctx.context["tenants"]): create_tenant_calls.append( mock.call(ctx.generate_random_name.return_value, ctx.config["project_domain"])) for user in ctx.context["users"]: self.assertEqual(set(["id", "credential", "tenant_id"]), set(user.keys())) user_credential_dict = user["credential"].to_dict() excluded_keys = [ "auth_url", "username", "password", "tenant_name", "region_name", "project_domain_name", "user_domain_name" ] for key in (set(credential_dict.keys()) - set(excluded_keys)): self.assertEqual(credential_dict[key], user_credential_dict[key]) tenants_ids = [] for t in ctx.context["tenants"].keys(): tenants_ids.append(t) for (user, tenant_id, orig_user) in zip(ctx.context["users"], tenants_ids, user_list): self.assertEqual(orig_user.id, user["id"]) self.assertEqual(tenant_id, user["tenant_id"])
def test_setup_and_cleanup_with_error_during_create_user( self, mock_identity, mock_log_warning): identity_service = mock_identity.Identity.return_value identity_service.create_user.side_effect = Exception() with users.UserGenerator(self.context) as ctx: self.assertRaises(exceptions.ContextSetupFailure, ctx.setup) mock_log_warning.assert_called_with( "Failed to consume a task from the queue: ") # Ensure that tenants get deleted anyway self.assertEqual(0, len(ctx.context["tenants"]))
def test_setup_and_cleanup(self, mock_identity): with users.UserGenerator(self.context) as ctx: ctx.setup() self.assertEqual(len(ctx.context["users"]), self.users_num) self.assertEqual(len(ctx.context["tenants"]), self.tenants_num) # Cleanup (called by content manager) self.assertEqual(len(ctx.context["users"]), 0) self.assertEqual(len(ctx.context["tenants"]), 0)
def test_setup_and_cleanup(self, mock_identity): with users.UserGenerator(self.context) as ctx: ctx.setup() self.assertEqual(self.users_num, len(ctx.context["users"])) self.assertEqual(self.tenants_num, len(ctx.context["tenants"])) self.assertEqual("random", ctx.context["user_choice_method"]) # Cleanup (called by content manager) self.assertEqual(0, len(ctx.context["users"])) self.assertEqual(0, len(ctx.context["tenants"]))
def test_setup_and_cleanup(self, mock_keystone): wrapped_keystone = mock.MagicMock() mock_keystone.wrap.return_value = wrapped_keystone with users.UserGenerator(self.context) as ctx: ctx.setup() self.assertEqual(len(ctx.context["users"]), self.users_num) self.assertEqual(len(ctx.context["tenants"]), self.tenants_num) # Cleanup (called by content manager) self.assertEqual(len(ctx.context["users"]), 0) self.assertEqual(len(ctx.context["tenants"]), 0)
def test__delete_tenants(self, mock_keystone): user_generator = users.UserGenerator(self.context) user_generator.context["tenants"] = { "t1": { "id": "t1", "name": "t1" }, "t2": { "id": "t2", "name": "t2" } } user_generator._delete_tenants() self.assertEqual(len(user_generator.context["tenants"]), 0)
def test___init__for_new_users(self): deployment = self.deployment_get.return_value deployment.get_credentials_for.return_value = {"users": []} self.context["config"]["users"] = { "tenants": 1, "users_per_tenant": 1, "resource_management_workers": 1 } user_generator = users.UserGenerator(self.context) self.assertEqual([], user_generator.existing_users) self.assertEqual(self.admin_cred.project_domain_name, user_generator.config["project_domain"]) self.assertEqual(self.admin_cred.user_domain_name, user_generator.config["user_domain"]) self.deployment_get.assert_called_once_with(self.deployment_uuid) deployment.get_credentials_for.assert_called_once_with("openstack") self.deployment_get.reset_mock() deployment.get_credentials_for.reset_mock() # the case #2 - existing users are presented in deployment but # the user forces to create new ones deployment.get_credentials_for.return_value = {"users": [mock.Mock()]} user_generator = users.UserGenerator(self.context) self.assertEqual([], user_generator.existing_users) self.assertEqual(self.admin_cred.project_domain_name, user_generator.config["project_domain"]) self.assertEqual(self.admin_cred.user_domain_name, user_generator.config["user_domain"]) self.deployment_get.assert_called_once_with(self.deployment_uuid) deployment.get_credentials_for.assert_called_once_with("openstack")
def test_use_existing_users(self, mock_clients, mock_open_stack_credential): user1 = {"tenant_name": "proj", "username": "******", "password": "******", "auth_url": "https://example.com"} user2 = {"tenant_name": "proj", "username": "******", "password": "******", "auth_url": "https://example.com"} user3 = {"tenant_name": "proj", "username": "******", "password": "******", "auth_url": "https://example.com"} user_list = [user1, user2, user3] class AuthRef(object): USER_ID_COUNT = 0 PROJECT_ID_COUNT = 0 @property def user_id(self): self.USER_ID_COUNT += 1 return "u%s" % self.USER_ID_COUNT @property def project_id(self): self.PROJECT_ID_COUNT += 1 return "p%s" % (self.PROJECT_ID_COUNT % 2) auth_ref = AuthRef() mock_clients.return_value.keystone.auth_ref = auth_ref self.platforms["openstack"]["users"] = user_list user_generator = users.UserGenerator(self.context) user_generator.setup() self.assertIn("users", self.context) self.assertIn("tenants", self.context) self.assertIn("user_choice_method", self.context) self.assertEqual("random", self.context["user_choice_method"]) creds = mock_open_stack_credential.return_value self.assertEqual( [{"id": "u1", "credential": creds, "tenant_id": "p1"}, {"id": "u2", "credential": creds, "tenant_id": "p0"}, {"id": "u3", "credential": creds, "tenant_id": "p1"}], self.context["users"] ) self.assertEqual({"p0": {"id": "p0", "name": creds.tenant_name}, "p1": {"id": "p1", "name": creds.tenant_name}}, self.context["tenants"])
def test___init__for_new_users(self): self.context["config"]["users"] = { "tenants": 1, "users_per_tenant": 1, "resource_management_workers": 1} user_generator = users.UserGenerator(self.context) self.assertEqual([], user_generator.existing_users) self.assertEqual(self.admin_cred["project_domain_name"], user_generator.config["project_domain"]) self.assertEqual(self.admin_cred["user_domain_name"], user_generator.config["user_domain"]) # the case #2 - existing users are presented in deployment but # the user forces to create new ones self.platforms["openstack"]["users"] = [mock.Mock()] user_generator = users.UserGenerator(self.context) self.assertEqual([], user_generator.existing_users) self.assertEqual(self.admin_cred["project_domain_name"], user_generator.config["project_domain"]) self.assertEqual(self.admin_cred["user_domain_name"], user_generator.config["user_domain"])
def test__remove_default_security_group( self, mock_check_service_status, mock_network, mock_iterate_per_tenants): net_wrapper = mock.Mock(SERVICE_IMPL=consts.Service.NEUTRON) net_wrapper.supports_extension.return_value = (True, None) mock_network.wrap.return_value = net_wrapper user_generator = users.UserGenerator(self.context) admin_clients = mock.Mock() admin_clients.services.return_value = { "compute": consts.Service.NOVA, "neutron": consts.Service.NEUTRON} user1 = mock.Mock() user1.neutron.return_value.list_security_groups.return_value = { "security_groups": [{"id": "id-1", "name": "default"}, {"id": "id-2", "name": "not-default"}]} user2 = mock.Mock() user2.neutron.return_value.list_security_groups.return_value = { "security_groups": [{"id": "id-3", "name": "default"}, {"id": "id-4", "name": "not-default"}]} user_clients = [user1, user2] self.osclients.Clients.side_effect = [admin_clients] + user_clients mock_iterate_per_tenants.return_value = [ (mock.MagicMock(), "t1"), (mock.MagicMock(), "t2")] user_generator._remove_default_security_group() mock_network.wrap.assert_called_once_with(admin_clients, user_generator) mock_iterate_per_tenants.assert_called_once_with( user_generator.context["users"]) expected = [mock.call(user_generator.credential)] + [ mock.call(u["credential"]) for u, t in mock_iterate_per_tenants.return_value] self.osclients.Clients.assert_has_calls(expected, any_order=True) user_net = user1.neutron.return_value user_net.list_security_groups.assert_called_once_with(tenant_id="t1") user_net = user2.neutron.return_value user_net.list_security_groups.assert_called_once_with(tenant_id="t2") admin_neutron = admin_clients.neutron.return_value self.assertEqual( [mock.call("id-1"), mock.call("id-3")], admin_neutron.delete_security_group.call_args_list)
def test__remove_default_security_group(self, mock_check_service_status, mock_network, mock_iterate_per_tenants): net_wrapper = mock.Mock(SERVICE_IMPL=consts.Service.NEUTRON) net_wrapper.supports_extension.return_value = (True, None) mock_network.wrap.return_value = net_wrapper user_generator = users.UserGenerator(self.context) admin_clients = mock.Mock() admin_clients.services.return_value = { "compute": consts.Service.NOVA, "neutron": consts.Service.NEUTRON } user_clients = [mock.Mock(), mock.Mock()] self.osclients.Clients.side_effect = [admin_clients] + user_clients mock_iterate_per_tenants.return_value = [(mock.MagicMock(), "t1"), (mock.MagicMock(), "t2")] user_generator._remove_default_security_group() mock_network.wrap.assert_called_once_with(admin_clients, self.context["task"]) mock_iterate_per_tenants.assert_called_once_with( user_generator.context["users"]) expected = [mock.call(user_generator.endpoint)] + [ mock.call(u["endpoint"]) for u, t in mock_iterate_per_tenants.return_value ] self.osclients.Clients.assert_has_calls(expected, any_order=True) expected_deletes = [] for clients in user_clients: user_nova = clients.nova.return_value user_nova.security_groups.find.assert_called_once_with( name="default") expected_deletes.append( mock.call(user_nova.security_groups.find.return_value.id)) nova_admin = admin_clients.neutron.return_value nova_admin.delete_security_group.assert_has_calls(expected_deletes, any_order=True)
def test__remove_default_security_group_neutron_no_sg(self, mock_wrap): net_wrapper = mock.Mock(SERVICE_IMPL=consts.Service.NEUTRON) net_wrapper.supports_extension.return_value = (False, None) mock_wrap.return_value = net_wrapper user_generator = users.UserGenerator(self.context) admin_clients = mock.Mock() admin_clients.services.return_value = { "compute": consts.Service.NOVA, "neutron": consts.Service.NEUTRON} user_clients = [mock.Mock(), mock.Mock()] self.osclients.Clients.side_effect = [admin_clients] + user_clients user_generator._remove_default_security_group() mock_wrap.assert_called_once_with(admin_clients, self.context["task"]) net_wrapper.supports_extension.assert_called_once_with( "security-group")
def test_users_contains_default_endpoint_type(self, mock_keystone): endpoint = objects.Credential("foo_url", "foo", "foo_pass") config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "admin": {"endpoint": endpoint}, "task": {"uuid": "task_id"} } user_generator = users.UserGenerator(config) users_ = user_generator._create_users() for user in users_: self.assertEqual("public", user["endpoint"].endpoint_type)
def test_users_contains_default_endpoint_type(self, mock_identity): credential = oscredential.OpenStackCredential( "foo_url", "foo", "foo_pass") config = { "config": { "users": { "tenants": 1, "users_per_tenant": 2, "resource_management_workers": 1 } }, "env": {"platforms": {"openstack": {"admin": credential, "users": []}}}, "task": {"uuid": "task_id", "deployment_uuid": "deployment_id"} } user_generator = users.UserGenerator(config) users_ = user_generator._create_users() for user in users_: self.assertEqual("public", user["credential"].endpoint_type)