def test__list_hypervisors(self): nova_scenario = utils.NovaScenario() result = nova_scenario._list_hypervisors(detailed=False) self.assertEqual( self.admin_clients("nova").hypervisors.list.return_value, result) self.admin_clients("nova").hypervisors.list.assert_called_once_with( False) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_hypervisors")
def test__list_flavors(self): nova_scenario = utils.NovaScenario() result = nova_scenario._list_flavors(detailed=True, fakearg="fakearg") self.assertEqual(self.clients("nova").flavors.list.return_value, result) self.clients("nova").flavors.list.assert_called_once_with( True, fakearg="fakearg") self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_flavors")
def test__delete_network(self): nova_scenario = utils.NovaScenario() result = nova_scenario._delete_network("fake_net_id") self.assertEqual( self.admin_clients("nova").networks.delete.return_value, result) self.admin_clients("nova").networks.delete.assert_called_once_with( "fake_net_id") self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.delete_network")
def test__list_floating_ips_bulk(self): floating_ips_bulk_list = ["foo_floating_ips_bulk"] self.admin_clients("nova").floating_ips_bulk.list.return_value = ( floating_ips_bulk_list) nova_scenario = utils.NovaScenario(context=self.context) return_floating_ips_bulk_list = nova_scenario._list_floating_ips_bulk() self.assertEqual(floating_ips_bulk_list, return_floating_ips_bulk_list) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_floating_ips_bulk")
def test__list_flavor_access(self): nova_scenario = utils.NovaScenario() result = nova_scenario._list_flavor_access("foo_id") self.assertEqual( self.admin_clients("nova").flavor_access.list.return_value, result) self.admin_clients("nova").flavor_access.list.assert_called_once_with( flavor="foo_id") self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_flavor_access")
def test__boot_server_with_network_exception(self): self.clients("nova").servers.create.return_value = self.server nova_scenario = utils.NovaScenario( context=self._context_with_networks(None)) self.assertRaises(TypeError, nova_scenario._boot_server, "image_id", "flavor_id", auto_assign_nic=True)
def test__detach_volume_no_attach(self): self.clients("nova").volumes.delete_server_volume.return_value = None nova_scenario = utils.NovaScenario(context=self.context) nova_scenario._detach_volume(self.server, self.volume, None) (self.clients( "nova").volumes.delete_server_volume.assert_called_once_with( self.server.id, self.volume.id)) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.detach_volume")
def test__list_services(self, host=None, binary=None): nova_scenario = utils.NovaScenario() result = nova_scenario._list_services(host=host, binary=binary) self.assertEqual( self.admin_clients("nova").services.list.return_value, result) self.admin_clients("nova").services.list.assert_called_once_with( host, binary) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_services")
def test__list_agents(self, hypervisor=None): nova_scenario = utils.NovaScenario() result = nova_scenario._list_agents(hypervisor) self.assertEqual( self.admin_clients("nova").agents.list.return_value, result) self.admin_clients("nova").agents.list.assert_called_once_with( hypervisor) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_agents")
def test__boot_servers(self, image_id="image", flavor_id="flavor", requests=1, name_prefix=None, instances_amount=1, auto_assign_nic=False, **kwargs): servers = [mock.Mock() for i in range(instances_amount)] self.clients("nova").servers.list.return_value = servers scenario = utils.NovaScenario(context=self.context) scenario._generate_random_name = mock.Mock() scenario._pick_random_nic = mock.Mock() scenario._boot_servers(image_id, flavor_id, requests, name_prefix=name_prefix, instances_amount=instances_amount, auto_assign_nic=auto_assign_nic, **kwargs) expected_kwargs = dict(kwargs) if auto_assign_nic and "nics" not in kwargs: expected_kwargs["nics"] = scenario._pick_random_nic.return_value if name_prefix is None: name_prefix = scenario._generate_random_name.return_value create_calls = [ mock.call("%s_%d" % (name_prefix, i), image_id, flavor_id, min_count=instances_amount, max_count=instances_amount, **expected_kwargs) for i in range(requests) ] self.clients("nova").servers.create.assert_has_calls(create_calls) wait_for_calls = [ mock.call( servers[i], is_ready=self.mock_resource_is.mock.return_value, update_resource=self.mock_get_from_manager.mock.return_value, check_interval=CONF.benchmark.nova_server_boot_poll_interval, timeout=CONF.benchmark.nova_server_boot_timeout) for i in range(instances_amount) ] self.mock_wait_for.mock.assert_has_calls(wait_for_calls) self.mock_resource_is.mock.assert_has_calls( [mock.call("ACTIVE") for i in range(instances_amount)]) self.mock_get_from_manager.mock.assert_has_calls( [mock.call() for i in range(instances_amount)]) self._test_atomic_action_timer(scenario.atomic_actions(), "nova.boot_servers")
def test__pick_random_nic(self): context = {"tenant": {"networks": [{"id": "net_id_1"}, {"id": "net_id_2"}]}, "iteration": 0} nova_scenario = utils.NovaScenario(context=context) nic1 = nova_scenario._pick_random_nic() self.assertEqual(nic1, [{"net-id": "net_id_1"}]) context["iteration"] = 1 nova_scenario = utils.NovaScenario(context=context) nic2 = nova_scenario._pick_random_nic() # balance to net 2 self.assertEqual(nic2, [{"net-id": "net_id_2"}]) context["iteration"] = 2 nova_scenario = utils.NovaScenario(context=context) nic3 = nova_scenario._pick_random_nic() # balance again, get net 1 self.assertEqual(nic3, [{"net-id": "net_id_1"}])
def test__list_availability_zones(self): nova_scenario = utils.NovaScenario() result = nova_scenario._list_availability_zones(detailed=True) self.assertEqual( self.admin_clients("nova").availability_zones.list.return_value, result) avail_zones_client = self.admin_clients("nova").availability_zones avail_zones_client.list.assert_called_once_with(True) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_availbility_zones")
def test__unrescue_server(self): nova_scenario = utils.NovaScenario() nova_scenario._unrescue_server(self.server) self.server.unrescue.assert_called_once_with() self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_unrescue_poll_interval, CONF.benchmark.nova_server_unrescue_timeout) self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.unrescue_server")
def test__rebuild_server(self): nova_scenario = utils.NovaScenario() nova_scenario._rebuild_server(self.server, "img", fakearg="fakearg") self.server.rebuild.assert_called_once_with("img", fakearg="fakearg") self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_rebuild_poll_interval, CONF.benchmark.nova_server_rebuild_timeout) self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.rebuild_server")
def test__soft_reboot_server(self): nova_scenario = utils.NovaScenario() nova_scenario._soft_reboot_server(self.server) self.server.reboot.assert_called_once_with(reboot_type="SOFT") self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_reboot_poll_interval, CONF.benchmark.nova_server_reboot_timeout) self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.soft_reboot_server")
def test__shelve_server(self): nova_scenario = utils.NovaScenario() nova_scenario._shelve_server(self.server) self.server.shelve.assert_called_once_with() self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_shelve_poll_interval, CONF.benchmark.nova_server_shelve_timeout) self.res_is.mock.assert_has_calls([mock.call("SHELVED_OFFLOADED")]) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.shelve_server")
def test__update_security_groups(self): nova_scenario = utils.NovaScenario(context=self.context) fake_secgroups = [fakes.FakeSecurityGroup(None, None, 1, "uuid1"), fakes.FakeSecurityGroup(None, None, 2, "uuid2")] nova_scenario._update_security_groups(fake_secgroups) self.assertEqual( len(fake_secgroups), self.clients("nova").security_groups.update.call_count) self._test_atomic_action_timer( nova_scenario.atomic_actions(), "nova.update_%s_security_groups" % len(fake_secgroups))
def setup(self): image = self.config["image"] flavor = self.config["flavor"] auto_nic = self.config["auto_assign_nic"] servers_per_tenant = self.config["servers_per_tenant"] kwargs = {} if self.config.get("nics"): if isinstance(self.config["nics"][0], dict): # it is a format that Nova API expects kwargs["nics"] = list(self.config["nics"]) else: kwargs["nics"] = [{ "net-id": nic } for nic in self.config["nics"]] clients = osclients.Clients(self.context["users"][0]["credential"]) image_id = types.GlanceImage.transform(clients=clients, resource_config=image) flavor_id = types.Flavor.transform(clients=clients, resource_config=flavor) for iter_, (user, tenant_id) in enumerate( rutils.iterate_per_tenants(self.context["users"])): LOG.debug("Booting servers for user tenant %s ", (user["tenant_id"])) tmp_context = { "user": user, "tenant": self.context["tenants"][tenant_id], "task": self.context["task"], "owner_id": self.context["owner_id"], "iteration": iter_ } nova_scenario = nova_utils.NovaScenario(tmp_context) LOG.debug( "Calling _boot_servers with image_id=%(image_id)s " "flavor_id=%(flavor_id)s " "servers_per_tenant=%(servers_per_tenant)s", { "image_id": image_id, "flavor_id": flavor_id, "servers_per_tenant": servers_per_tenant }) servers = nova_scenario._boot_servers(image_id, flavor_id, requests=servers_per_tenant, auto_assign_nic=auto_nic, **kwargs) current_servers = [server.id for server in servers] LOG.debug("Adding booted servers %s to context", current_servers) self.context["tenants"][tenant_id]["servers"] = current_servers
def test__create_keypair(self): nova_scenario = utils.NovaScenario() nova_scenario.generate_random_name = mock.Mock( return_value="rally_nova_keypair_fake") result = nova_scenario._create_keypair(fakeargs="fakeargs") self.assertEqual( self.clients("nova").keypairs.create.return_value.name, result) self.clients("nova").keypairs.create.assert_called_once_with( "rally_nova_keypair_fake", fakeargs="fakeargs") self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.create_keypair")
def test__delete_image(self): nova_scenario = utils.NovaScenario() nova_scenario._delete_image(self.image) self.image.delete.assert_called_once_with() self._test_assert_called_once_with( self.wait_for_delete.mock, self.image, CONF.benchmark.nova_server_image_delete_poll_interval, CONF.benchmark.nova_server_image_delete_timeout, is_ready=None) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.delete_image")
def test__force_delete_server(self): nova_scenario = utils.NovaScenario(context=self.context) nova_scenario._delete_server(self.server, force=True) self.server.force_delete.assert_called_once_with() self.mock_wait_for_delete.mock.assert_called_once_with( self.server, update_resource=self.mock_get_from_manager.mock.return_value, check_interval=CONF.benchmark.nova_server_delete_poll_interval, timeout=CONF.benchmark.nova_server_delete_timeout) self.mock_get_from_manager.mock.assert_called_once_with() self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.force_delete_server")
def test__create_image(self): self.clients("nova").images.get.return_value = self.image nova_scenario = utils.NovaScenario() return_image = nova_scenario._create_image(self.server) self._test_assert_called_once_with( self.wait_for.mock, self.image, CONF.benchmark.nova_server_image_create_poll_interval, CONF.benchmark.nova_server_image_create_timeout) self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) self.assertEqual(self.wait_for.mock(), return_image) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.create_image")
def test__create_flavor(self): nova_scenario = utils.NovaScenario() random_name = "random_name" nova_scenario.generate_random_name = mock.Mock( return_value=random_name) result = nova_scenario._create_flavor(500, 1, 1, fakearg="fakearg") self.assertEqual( self.admin_clients("nova").flavors.create.return_value, result) self.admin_clients("nova").flavors.create.assert_called_once_with( random_name, 500, 1, 1, fakearg="fakearg") self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.create_flavor")
def test__unrescue_server(self): nova_scenario = utils.NovaScenario(context=self.context) nova_scenario._unrescue_server(self.server) self.server.unrescue.assert_called_once_with() self.mock_wait_for.mock.assert_called_once_with( self.server, ready_statuses=["ACTIVE"], update_resource=self.mock_get_from_manager.mock.return_value, check_interval=CONF.benchmark.nova_server_unrescue_poll_interval, timeout=CONF.benchmark.nova_server_unrescue_timeout) self.mock_get_from_manager.mock.assert_called_once_with() self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.unrescue_server")
def test__attach_volume(self): expect_attach = mock.MagicMock() device = None (self.clients("nova").volumes.create_server_volume.return_value ) = expect_attach nova_scenario = utils.NovaScenario(context=self.context) attach = nova_scenario._attach_volume(self.server, self.volume, device) (self.clients( "nova").volumes.create_server_volume.assert_called_once_with( self.server.id, self.volume.id, device)) self.assertEqual(expect_attach, attach) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.attach_volume")
def test__create_floating_ips_bulk(self, mock_generate_cidr): fake_cidr = "10.2.0.0/24" fake_pool = "test1" fake_floating_ips_bulk = mock.MagicMock() fake_floating_ips_bulk.ip_range = fake_cidr fake_floating_ips_bulk.pool = fake_pool self.admin_clients("nova").floating_ips_bulk.create.return_value = ( fake_floating_ips_bulk) nova_scenario = utils.NovaScenario(context=self.context) return_iprange = nova_scenario._create_floating_ips_bulk(fake_cidr) mock_generate_cidr.assert_called_once_with(start_cidr=fake_cidr) self.assertEqual(return_iprange, fake_floating_ips_bulk) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.create_floating_ips_bulk")
def test__stop_server(self): nova_scenario = utils.NovaScenario(context=self.context) nova_scenario._stop_server(self.server) self.server.stop.assert_called_once_with() self.mock_wait_for.mock.assert_called_once_with( self.server, is_ready=self.mock_resource_is.mock.return_value, update_resource=self.mock_get_from_manager.mock.return_value, check_interval=CONF.benchmark.nova_server_stop_poll_interval, timeout=CONF.benchmark.nova_server_stop_timeout) self.mock_resource_is.mock.assert_called_once_with("SHUTOFF") self.mock_get_from_manager.mock.assert_called_once_with() self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.stop_server")
def test__rebuild_server(self): nova_scenario = utils.NovaScenario(context=self.context) nova_scenario._rebuild_server(self.server, "img", fakearg="fakearg") self.server.rebuild.assert_called_once_with("img", fakearg="fakearg") self.mock_wait_for.mock.assert_called_once_with( self.server, is_ready=self.mock_resource_is.mock.return_value, update_resource=self.mock_get_from_manager.mock.return_value, check_interval=CONF.benchmark.nova_server_rebuild_poll_interval, timeout=CONF.benchmark.nova_server_rebuild_timeout) self.mock_resource_is.mock.assert_called_once_with("ACTIVE") self.mock_get_from_manager.mock.assert_called_once_with() self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.rebuild_server")
def delete_one_image(self, user, custom_image): """Delete the image created for the user and tenant.""" clients = osclients.Clients(user["credential"]) nova_scenario = nova_utils.NovaScenario( context=self.context, clients=clients) with logging.ExceptionLogger( LOG, _("Unable to delete image %s") % custom_image["id"]): custom_image = nova_scenario.clients("nova").images.get( custom_image["id"]) nova_scenario._delete_image(custom_image)
def test__delete_security_groups(self): nova_scenario = utils.NovaScenario(context=self.context) fake_secgroups = [fakes.FakeSecurityGroup(None, None, 1, "uuid1"), fakes.FakeSecurityGroup(None, None, 2, "uuid2")] nova_scenario._delete_security_groups(fake_secgroups) self.assertSequenceEqual( map(lambda x: mock.call(x.id), fake_secgroups), self.clients("nova").security_groups.delete.call_args_list) self._test_atomic_action_timer( nova_scenario.atomic_actions(), "nova.delete_%s_security_groups" % len(fake_secgroups))