def _prepare_boot(self, mock_osclients, nic=None, assert_nic=False): fake_server = mock.MagicMock() fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc nova = fakes.FakeNovaClient() fc.nova = lambda: nova user_endpoint = endpoint.Endpoint("url", "user", "password", "tenant") clients = osclients.Clients(user_endpoint) scenario = servers.NovaServers(clients=clients) scenario._boot_server = mock.MagicMock(return_value=fake_server) scenario._generate_random_name = mock.MagicMock(return_value="name") kwargs = {'fakearg': 'f'} expected_kwargs = {'fakearg': 'f'} assert_nic = nic or assert_nic if nic: kwargs['nics'] = nic if assert_nic: nova.networks.create('net-1') expected_kwargs['nics'] = nic or [{'net-id': 'net-2'}] print(kwargs) print(expected_kwargs) return scenario, kwargs, expected_kwargs
def test__update_quotas(self): tenant_id = 'fake_tenant' quotas = { 'metadata_items': 10, 'key_pairs': 10, 'injected_file_content_bytes': 1024, 'injected_file_path_bytes': 1024, 'ram': 5120, 'instances': 10, 'injected_files': 10, 'cores': 10, } fake_nova = fakes.FakeNovaClient() fake_nova.quotas.update = mock.MagicMock(return_value=quotas) fake_clients = fakes.FakeClients() fake_clients._nova = fake_nova scenario = utils.QuotasScenario(admin_clients=fake_clients) scenario._generate_quota_values = mock.MagicMock(return_value=quotas) result = scenario._update_quotas('nova', tenant_id) self.assertEqual(quotas, result) fake_nova.quotas.update.assert_called_once_with(tenant_id, **quotas) self._test_atomic_action_timer(scenario.atomic_actions(), 'quotas.update_quotas')
def setUp(self): super(FlavorResourceTypeTestCase, self).setUp() self.clients = fakes.FakeClients() self.clients.nova().flavors._cache( fakes.FakeResource(name='m1.tiny', id="1")) self.clients.nova().flavors._cache( fakes.FakeResource(name='m1.nano', id="42"))
def setUp(self): super(ImageResourceTypeTestCase, self).setUp() self.clients = fakes.FakeClients() image1 = fakes.FakeResource(name="cirros-0.3.1-uec", id="100") self.clients.glance().images._cache(image1) image2 = fakes.FakeResource(name="cirros-0.3.1-uec-ramdisk", id="101") self.clients.glance().images._cache(image2)
def test_delete_neutron_resources(self): neutron = fakes.FakeClients().neutron() scenario = scenarios.neutron.utils.NeutronScenario() scenario.clients = lambda ins: neutron network1 = scenario._create_network({}) subnet1 = scenario._create_subnet(network1, {}) router1 = scenario._create_router({}) # This also creates a port neutron.add_interface_router(router1["router"]["id"], {"subnet_id": subnet1["subnet"]["id"]}) network2 = scenario._create_network({}) scenario._create_subnet(network2, {}) scenario._create_router({}) scenario._create_port(network2, {}) total = lambda neutron: (len(neutron.list_networks()[ "networks"]) + len( neutron.list_subnets()["subnets"]) + len(neutron.list_routers( )["routers"]) + len(neutron.list_ports()["ports"])) self.assertEqual(total(neutron), 8) utils.delete_neutron_resources(neutron, network1["network"]["tenant_id"]) self.assertEqual(total(neutron), 0)
def test_create_image_and_boot_instances(self, mock_osclients, mock_create_image, mock_boot_servers, mock_random_name): glance_scenario = images.GlanceImages() nova_scenario = servers.NovaServers() fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc fake_glance = fakes.FakeGlanceClient() fc.glance = lambda: fake_glance fake_nova = fakes.FakeNovaClient() fc.nova = lambda: fake_nova user_endpoint = endpoint.Endpoint("url", "user", "password", "tenant") nova_scenario._clients = osclients.Clients(user_endpoint) fake_image = fakes.FakeImage() fake_servers = [object() for i in range(5)] mock_create_image.return_value = fake_image mock_boot_servers.return_value = fake_servers mock_random_name.return_value = "random_name" kwargs = {'fakearg': 'f'} with mock.patch("rally.benchmark.scenarios.glance.utils.time.sleep"): glance_scenario.\ create_image_and_boot_instances("cf", "url", "df", "fid", 5, **kwargs) mock_create_image.assert_called_once_with("random_name", "cf", "url", "df", **kwargs) mock_boot_servers.assert_called_once_with("random_name", "image-id-0", "fid", 5, **kwargs)
def test_keystone(self, mock_osclients): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc scenario = authenticate.Authenticate(admin_clients=mock_osclients, clients=mock_osclients) scenario.keystone() self.assertEqual(scenario._clients.keystone.call_count, 1)
def test_list_tenants(self): fake_keystone = fakes.FakeKeystoneClient() fake_keystone.tenants.list = mock.MagicMock() fake_clients = fakes.FakeClients() fake_clients._keystone = fake_keystone scenario = utils.KeystoneScenario(admin_clients=fake_clients) scenario._list_tenants() fake_keystone.tenants.list.assert_called_once() self._test_atomic_action_timer(scenario.atomic_actions(), 'keystone.list_tenants')
def test_get_periodic_runner(self, mock_osclients, mock_base): FakeScenario = mock.MagicMock() FakeScenario.init = mock.MagicMock(return_value={}) mock_osclients.Clients.return_value = fakes.FakeClients() runner = base.ScenarioRunner.get_runner( mock.MagicMock(), self.fake_endpoints, {"type": consts.RunnerType.PERIODIC}) self.assertTrue(runner is not None)
def test_validate_neutron(self, mock_admin_clients, mock_users_clients): fc = fakes.FakeClients() mock_admin_clients.clients.return_value = fc mock_users_clients.clients.return_value = fc scenario = authenticate.Authenticate(admin_clients=mock_admin_clients, clients=mock_users_clients) scenario._clients.neutron.get_auth_info = mock.MagicMock() with base.AtomicAction(scenario, "authenticate.validate_neutron"): scenario.validate_neutron(5) self.assertEqual(scenario._clients.neutron().get_auth_info.call_count, 5)
def test_validate_nova(self, mock_admin_clients, mock_users_clients): flavors_list = [mock.Mock(), mock.Mock()] fc = fakes.FakeClients() mock_admin_clients.clients.return_value = fc mock_users_clients.clients.return_value = fc scenario = authenticate.Authenticate(admin_clients=mock_admin_clients, clients=mock_users_clients) scenario._clients.nova.flavors.list = mock.MagicMock( return_value=flavors_list) with base.AtomicAction(scenario, "authenticate.validate_nova"): scenario.validate_nova(5) self.assertEqual(scenario._clients.nova().flavors.list.call_count, 5)
def test_validate_cinder(self, mock_admin_clients, mock_users_clients): volume_types_list = [mock.Mock(), mock.Mock()] fc = fakes.FakeClients() mock_admin_clients.clients.return_value = fc mock_users_clients.clients.return_value = fc scenario = authenticate.Authenticate(admin_clients=mock_admin_clients, clients=mock_users_clients) scenario._clients.cinder.volume_types.list = mock.MagicMock( return_value=volume_types_list) with base.AtomicAction(scenario, "authenticate.validate_cinder"): scenario.validate_cinder(5) self.assertEqual( scenario._clients.cinder().volume_types.list.call_count, 5)
def test_add_role_which_does_not_exist(self, mock_osclients): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc self.create_default_roles_and_patch_add_remove_fuinctions(fc) ctx = roles.RoleGenerator(self.context) ctx.context["users"] = [{"id": "u1", "tenant_id": "t1"}, {"id": "u2", "tenant_id": "t2"}] ex = self.assertRaises(Exception, ctx._add_role, mock.MagicMock(), "unknown_role") expected = "Role 'unknown_role' does not exist in the list of roles" self.assertEqual(expected, str(ex))
def test_add_role(self, mock_osclients): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc self.create_default_roles_and_patch_add_remove_fuinctions(fc) ctx = roles.RoleGenerator(self.context) ctx.context["users"] = [{"id": "u1", "tenant_id": "t1"}, {"id": "u2", "tenant_id": "t2"}] result = ctx._add_role(mock.MagicMock(), self.context["config"]["roles"][0]) expected = {"id": "r1", "name": "test_role1"} self.assertEqual(expected, result)
def test_delete_sahara_resources(self): sahara = fakes.FakeClients().sahara() utils.delete_sahara_resources(sahara) sahara.job_executions.delete.assert_called_once_with(42) sahara.jobs.delete.assert_called_once_with(42) sahara.job_binaries.delete.assert_called_once_with(42) sahara.data_sources.delete.assert_called_once_with(42) sahara.clusters.delete.assert_called_once_with(42) sahara.cluster_templates.delete.assert_called_once_with(42) sahara.node_group_templates.delete.assert_called_once_with(42)
def setUp(self): super(ShowCommandsTestCase, self).setUp() self.show = show.ShowCommands() self.fake_endpoint = { 'username': '******', 'password': '******', 'tenant_name': 'fake_tenant_name', 'auth_url': 'http://fake.auth.url' } self.fake_deploy_id = str(uuid.uuid4) self.fake_clients = fakes.FakeClients() self.fake_glance_client = fakes.FakeGlanceClient() self.fake_nova_client = fakes.FakeNovaClient()
def test_validate_heat(self, mock_admin_clients, mock_users_clients): stacks_list = [mock.Mock(), mock.Mock()] fc = fakes.FakeClients() mock_admin_clients.clients.return_value = fc mock_users_clients.clients.return_value = fc scenario = authenticate.Authenticate(admin_clients=mock_admin_clients, clients=mock_users_clients) scenario._clients.heat.stacks.list = mock.MagicMock( return_value=stacks_list) with base.AtomicAction(scenario, "authenticate.validate_heat"): scenario.validate_heat(5) scenario._clients.heat().stacks.list.assert_called_with(limit=0) self.assertEqual(scenario._clients.heat().stacks.list.call_count, 5)
def setUp(self): super(ShowCommandsTestCase, self).setUp() self.show = show.ShowCommands() self.fake_endpoint = { 'username': '******', 'password': '******', 'tenant_name': 'fake_tenant_name', 'auth_url': 'http://fake.auth.url' } self.fake_deploy_id = '7f6e88e0-897e-45c0-947c-595ce2437bee' self.fake_clients = fakes.FakeClients() self.fake_glance_client = fakes.FakeGlanceClient() self.fake_nova_client = fakes.FakeNovaClient()
def test__delete_quotas(self): tenant_id = 'fake_tenant' fake_nova = fakes.FakeNovaClient() fake_nova.quotas.delete = mock.MagicMock() fake_clients = fakes.FakeClients() fake_clients._nova = fake_nova scenario = utils.QuotasScenario(admin_clients=fake_clients) scenario._delete_quotas('nova', tenant_id) fake_nova.quotas.delete.assert_called_once_with(tenant_id) self._test_atomic_action_timer(scenario.atomic_actions(), 'quotas.delete_quotas')
def test_start_task(self, mock_task_create, mock_task_update, mock_task_result_create, mock_deploy_get, mock_utils_runner, mock_osclients, mock_validate_names, mock_validate_syntax, mock_validate_semantic): mock_task_create.return_value = self.task mock_task_update.return_value = self.task mock_deploy_get.return_value = self.deployment mock_utils_runner.return_value = mock_runner = mock.Mock() mock_runner.run.return_value = ['fake_result'] mock_osclients.Clients.return_value = fakes.FakeClients() api.start_task(self.deploy_uuid, self.task_config) mock_deploy_get.assert_called_once_with(self.deploy_uuid) mock_task_create.assert_called_once_with({ 'deployment_uuid': self.deploy_uuid, }) mock_task_update.assert_has_calls([ mock.call(self.task_uuid, {'status': consts.TaskStatus.VERIFYING}), mock.call(self.task_uuid, {'status': consts.TaskStatus.RUNNING}), mock.call(self.task_uuid, {'status': consts.TaskStatus.FINISHED}) ]) # NOTE(akscram): It looks really awful, but checks degradation. mock_task_result_create.assert_called_once_with( self.task_uuid, { 'kw': { 'args': {}, 'runner': { 'type': 'constant', 'timeout': 10000, 'times': 3, 'concurrency': 2, }, 'context': { 'users': { 'tenants': 5, 'users_per_tenant': 6, } } }, 'name': 'FakeScenario.fake', 'pos': 0, }, { 'raw': ['fake_result'] } )
def test_users_and_tenants_in_context(self, mock_osclients): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc task = {"uuid": "abcdef"} config = { "config": { "users": { "tenants": 2, "users_per_tenant": 2, "concurrent": 1 } }, "admin": { "endpoint": mock.MagicMock() }, "task": task } with users.UserGenerator(config) as ctx: ctx.setup() tenants = [] for i, t in enumerate(fc.keystone().tenants.list()): pattern = users.UserGenerator.PATTERN_TENANT tenants.append({ "id": t.id, "name": pattern % { "task_id": task["uuid"], "iter": i } }) self.assertEqual(ctx.context["tenants"], tenants) for user in ctx.context["users"]: self.assertEqual(set(["id", "endpoint", "tenant_id"]), set(user.keys())) tenants_ids = [] for t in tenants: tenants_ids.extend([t["id"], t["id"]]) users_ids = [user.id for user in fc.keystone().users.list()] for (user, tenant_id, user_id) in zip(ctx.context["users"], tenants_ids, users_ids): self.assertEqual(user["id"], user_id) self.assertEqual(user["tenant_id"], tenant_id)
def test_validate_glance(self, mock_admin_clients, mock_users_clients): images_list = [mock.Mock(), mock.Mock()] fc = fakes.FakeClients() mock_admin_clients.Clients.return_value = fc mock_users_clients.Clients.return_value = fc scenario = authenticate.Authenticate(admin_clients=mock_admin_clients, clients=mock_users_clients) scenario._clients.glance.images.list = mock.MagicMock( return_value=images_list) image_name = "__intentionally_non_existent_image___" with base.AtomicAction(scenario, "authenticate.validate_glance"): scenario.validate_glance(5) scenario._clients.glance().images.list.assert_called_with( name=image_name) self.assertEqual(scenario._clients.glance().images.list.call_count, 5)
def test_tenant_create(self, mock_gen_name): name = "abc" mock_gen_name.return_value = name tenant = {} fake_keystone = fakes.FakeKeystoneClient() fake_keystone.tenants.create = mock.MagicMock(return_value=tenant) fake_clients = fakes.FakeClients() fake_clients._keystone = fake_keystone scenario = utils.KeystoneScenario(admin_clients=fake_clients) result = scenario._tenant_create() self.assertEqual(tenant, result) fake_keystone.tenants.create.assert_called_once_with(name) self._test_atomic_action_timer(scenario.atomic_actions(), 'keystone.create_tenant')
def test_user_create(self, mock_gen_name): name = "abc" mock_gen_name.return_value = name user = {} fake_keystone = fakes.FakeKeystoneClient() fake_keystone.users.create = mock.MagicMock(return_value=user) fake_clients = fakes.FakeClients() fake_clients._keystone = fake_keystone scenario = utils.KeystoneScenario(admin_clients=fake_clients) result = scenario._user_create() self.assertEqual(user, result) fake_keystone.users.create.assert_called_once_with( name, name, name + "@rally.me") self._test_atomic_action_timer(scenario.atomic_actions(), 'keystone.create_user')
def test_setup(self, mock_osclients, mock_image_create): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc image_list = ["uuid"] * 5 image_key = [{ 'image_id': image_list, 'endpoint': 'endpoint', 'tenant_id': i } for i in range(2)] user_key = [{ 'id': i, 'tenant_id': j, 'endpoint': 'endpoint' } for j in range(2) for i in range(5)] real_context = { "config": { "users": { "tenants": 2, "users_per_tenant": 5, "concurrent": 10, }, "images": { "image_url": "mock_url", "image_type": "qcow2", "image_container": "bare", "images_per_tenant": 5, } }, "admin": { "endpoint": mock.MagicMock() }, "task": mock.MagicMock(), "users": user_key, } new_context = copy.deepcopy(real_context) new_context["images"] = image_key images_ctx = images.ImageGenerator(real_context) images_ctx.setup() self.assertEqual(new_context, real_context)
def test_tenant_create_with_users(self, mock_gen_name): name = "abc" mock_gen_name.return_value = name tenant = mock.MagicMock() fake_keystone = fakes.FakeKeystoneClient() fake_keystone.users.create = mock.MagicMock() fake_clients = fakes.FakeClients() fake_clients._keystone = fake_keystone scenario = utils.KeystoneScenario(admin_clients=fake_clients) scenario._users_create(tenant, users_per_tenant=1, name_length=10) fake_keystone.users.create.assert_called_once_with(name, name, name + "@rally.me", tenant_id=tenant.id) self._test_atomic_action_timer(scenario.atomic_actions(), 'keystone.create_users')
def test_setup_and_cleanup(self, mock_osclients): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc with users.UserGenerator(self.context) as ctx: self.assertEqual(len(fc.keystone().users.list()), 0) self.assertEqual(len(fc.keystone().tenants.list()), 0) ctx.setup() self.assertEqual(len(ctx.context["users"]), self.users_num) self.assertEqual(len(fc.keystone().users.list()), self.users_num) self.assertEqual(len(ctx.context["tenants"]), self.tenants_num) self.assertEqual(len(fc.keystone().tenants.list()), self.tenants_num) # Cleanup (called by content manager) self.assertEqual(len(fc.keystone().users.list()), 0) self.assertEqual(len(fc.keystone().tenants.list()), 0)
def test_setup_and_cleanup(self, mock_osclients): fc = fakes.FakeClients() mock_osclients.Clients.return_value = fc self.create_default_roles_and_patch_add_remove_functions(fc) with roles.RoleGenerator(self.context) as ctx: ctx.context["users"] = [{ "id": "u1", "tenant_id": "t1" }, { "id": "u2", "tenant_id": "t2" }] ctx.setup() calls = [ mock.call("u1", "r1", tenant="t1"), mock.call("u2", "r1", tenant="t2"), mock.call("u1", "r2", tenant="t1"), mock.call("u2", "r2", tenant="t2") ] fc.keystone().roles.add_user_role.assert_has_calls(calls) self.assertEqual(4, fc.keystone().roles.add_user_role.call_count) self.assertEqual(0, fc.keystone().roles.remove_user_role.call_count) self.assertEqual(2, len(ctx.context["roles"])) self.assertEqual(2, len(fc.keystone().roles.list())) # Cleanup (called by content manager) self.assertEqual(2, len(fc.keystone().roles.list())) self.assertEqual(4, fc.keystone().roles.add_user_role.call_count) self.assertEqual(4, fc.keystone().roles.remove_user_role.call_count) calls = [ mock.call("u1", "r1", tenant="t1"), mock.call("u2", "r1", tenant="t2"), mock.call("u1", "r2", tenant="t1"), mock.call("u2", "r2", tenant="t2") ] fc.keystone().roles.remove_user_role.assert_has_calls(calls)
def test_validate_semantic(self): users = [fakes.FakeClients()] images.ImageGenerator.validate_semantic(None, None, users, None)
def test_admin_clients(self): clients = fakes.FakeClients() scenario = base.Scenario(admin_clients=clients) self.assertEqual(clients.nova(), scenario.admin_clients("nova")) self.assertEqual(clients.glance(), scenario.admin_clients("glance"))