def test__delete_keypair(self, mock_clients): nova_scenario = utils.NovaScenario() nova_scenario._delete_keypair(self.keypair) mock_clients("nova").keypairs.delete.assert_called_once_with( self.keypair) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.delete_keypair")
def test__delete_floating_ip(self, mock_clients): nova_scenario = utils.NovaScenario() nova_scenario._delete_floating_ip(self.floating_ip) mock_clients("nova").floating_ips.delete.assert_called_once_with( self.floating_ip) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.delete_floating_ip')
def test__dissociate_floating_ip(self): nova_scenario = utils.NovaScenario() nova_scenario._dissociate_floating_ip(self.server, self.floating_ip) self.server.remove_floating_ip.assert_called_once_with( self.floating_ip) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.dissociate_floating_ip")
def test__find_host_to_migrate(self, mock_clients): fake_server = self.server fake_host = {"nova-compute": {"available": True}} nova_client = mock.MagicMock() mock_clients.return_value = nova_client nova_client.servers.get.return_value = fake_server nova_client.availability_zones.list.return_value = [ mock.MagicMock(zoneName="a", hosts={ "a1": fake_host, "a2": fake_host, "a3": fake_host }), mock.MagicMock(zoneName="b", hosts={ "b1": fake_host, "b2": fake_host, "b3": fake_host }), mock.MagicMock(zoneName="c", hosts={ "c1": fake_host, "c2": fake_host, "c3": fake_host }) ] setattr(fake_server, "OS-EXT-SRV-ATTR:host", "b2") setattr(fake_server, "OS-EXT-AZ:availability_zone", "b") nova_scenario = utils.NovaScenario(admin_clients=fakes.FakeClients()) self.assertIn(nova_scenario._find_host_to_migrate(fake_server), ["b1", "b3"])
def test__check_ip_address(self): nova_scenario = utils.NovaScenario() fake_server = fakes.FakeServerManager().create("test_server", "image_id_01", "flavor_id_01") fake_server.addresses = { "private": [ { "version": 4, "addr": "1.2.3.4" }, ] } floating_ip = fakes.FakeFloatingIP() floating_ip.ip = "10.20.30.40" # Also test function check_ip_address accept a string as attr self.assertFalse( nova_scenario.check_ip_address(floating_ip.ip)(fake_server)) self.assertTrue( nova_scenario.check_ip_address(floating_ip.ip, must_exist=False)(fake_server)) fake_server.addresses["private"].append({ "version": 4, "addr": floating_ip.ip }) # Also test function check_ip_address accept an object with attr ip self.assertTrue( nova_scenario.check_ip_address(floating_ip)(fake_server)) self.assertFalse( nova_scenario.check_ip_address(floating_ip, must_exist=False)(fake_server))
def test__create_keypair(self, mock_clients): (mock_clients("nova").keypairs.create.return_value.name) = self.keypair nova_scenario = utils.NovaScenario() return_keypair = nova_scenario._create_keypair() self.assertEqual(self.keypair, return_keypair) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.create_keypair")
def test__associate_floating_ip(self): nova_scenario = utils.NovaScenario() nova_scenario._associate_floating_ip(self.server, self.floating_ip) self.server.add_floating_ip.assert_called_once_with(self.floating_ip, fixed_address=None) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.associate_floating_ip")
def test__boot_server_with_similar_sec_group(self, mock_clients, mock_generate_random_name): mock_clients("nova").servers.create.return_value = self.server nova_scenario = utils.NovaScenario( context={"user": { "secgroup": { "name": "test1" } }}) return_server = nova_scenario._boot_server("image_id", "flavor_id", security_groups=["test1"]) self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_boot_poll_interval, CONF.benchmark.nova_server_boot_timeout) self.res_is.mock.assert_has_calls([mock.call("ACTIVE")]) self.assertEqual(self.wait_for.mock(), return_server) mock_clients("nova").servers.create.assert_called_once_with( "foo_server_name", "image_id", "flavor_id", security_groups=["test1"]) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.boot_server")
def setup(self): image = self.config["image"] flavor = self.config["flavor"] servers_per_tenant = self.config["servers_per_tenant"] clients = osclients.Clients(self.context["users"][0]["endpoint"]) image_id = types.ImageResourceType.transform(clients=clients, resource_config=image) flavor_id = types.FlavorResourceType.transform(clients=clients, resource_config=flavor) for user, tenant_id in rutils.iterate_per_tenants( self.context["users"]): LOG.debug("Booting servers for user tenant %s " % (user["tenant_id"])) clients = osclients.Clients(user["endpoint"]) nova_scenario = nova_utils.NovaScenario(clients=clients) server_name_prefix = nova_scenario._generate_random_name( prefix="ctx_rally_server_") LOG.debug("Calling _boot_servers with server_name_prefix=%s " "image_id=%s flavor_id=%s servers_per_tenant=%s" % (server_name_prefix, image_id, flavor_id, flavor_id)) servers = nova_scenario._boot_servers(server_name_prefix, image_id, flavor_id, servers_per_tenant) 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_floating_ip(self, mock_clients): (mock_clients("nova").floating_ips.create.return_value ) = self.floating_ip nova_scenario = utils.NovaScenario() return_floating_ip = nova_scenario._create_floating_ip("public") self.assertEqual(self.floating_ip, return_floating_ip) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.create_floating_ip')
def test__list_floating_ips(self, mock_clients): floating_ips_list = [] mock_clients("nova").floating_ips.list.return_value = floating_ips_list nova_scenario = utils.NovaScenario() return_floating_ips_list = nova_scenario._list_floating_ips() self.assertEqual(floating_ips_list, return_floating_ips_list) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.list_floating_ips')
def test__delete_floating_ips_bulk(self, mock_clients): fake_cidr = "10.2.0.0/24" nova_scenario = utils.NovaScenario() nova_scenario._delete_floating_ips_bulk(fake_cidr) mock_clients("nova").floating_ips_bulk.delete.assert_called_once_with( fake_cidr) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.delete_floating_ips_bulk")
def test__list_servers(self, mock_clients): servers_list = [] mock_clients("nova").servers.list.return_value = servers_list nova_scenario = utils.NovaScenario() return_servers_list = nova_scenario._list_servers(True) self.assertEqual(servers_list, return_servers_list) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_servers")
def test__list_keypairs(self, mock_clients): keypairs_list = ["foo_keypair"] mock_clients("nova").keypairs.list.return_value = keypairs_list nova_scenario = utils.NovaScenario() return_keypairs_list = nova_scenario._list_keypairs() self.assertEqual(keypairs_list, return_keypairs_list) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_keypairs")
def test__list_networks(self, mock_clients): network_list = [] mock_clients("nova").networks.list.return_value = network_list nova_scenario = utils.NovaScenario() return_network_list = nova_scenario._list_networks() self.assertEqual(network_list, return_network_list) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_networks")
def test__list_floating_ips_bulk(self, mock_clients): floating_ips_bulk_list = ["foo_floating_ips_bulk"] mock_clients("nova").floating_ips_bulk.list.return_value = ( floating_ips_bulk_list) nova_scenario = utils.NovaScenario() 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__boot_server_with_network_exception(self, mock_clients): mock_clients("nova").servers.create.return_value = self.server mock_clients("nova").networks.list.return_value = None nova_scenario = utils.NovaScenario(context={}) self.assertRaises(TypeError, nova_scenario._boot_server, 'server_name', 'image_id', 'flavor_id', auto_assign_nic=True)
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__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__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__rescue_server(self): nova_scenario = utils.NovaScenario() nova_scenario._rescue_server(self.server) self.server.rescue.assert_called_once_with() self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_rescue_poll_interval, CONF.benchmark.nova_server_rescue_timeout) self.res_is.mock.assert_has_calls(mock.call('RESCUE')) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.rescue_server')
def test__boot_server_with_network_exception(self, mock_clients): mock_clients("nova").servers.create.return_value = self.server nova_scenario = utils.NovaScenario( context={"tenant": { "networks": None }}) self.assertRaises(TypeError, nova_scenario._boot_server, "image_id", "flavor_id", auto_assign_nic=True)
def test__suspend_server(self): nova_scenario = utils.NovaScenario() nova_scenario._suspend_server(self.server) self.server.suspend.assert_called_once_with() self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_suspend_poll_interval, CONF.benchmark.nova_server_suspend_timeout) self.res_is.mock.assert_has_calls([mock.call("SUSPENDED")]) self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.suspend_server")
def test__delete_server(self): nova_scenario = utils.NovaScenario() nova_scenario._delete_server(self.server) self.server.delete.assert_called_once_with() self.wait_for_delete.mock.assert_called_once_with( self.server, update_resource=self.gfm(), check_interval=CONF.benchmark.nova_server_delete_poll_interval, timeout=CONF.benchmark.nova_server_delete_timeout) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.delete_server')
def test__list_security_groups(self): clients = mock.MagicMock() nova_scenario = utils.NovaScenario() nova_scenario.clients = clients nova_scenario._list_security_groups() clients.assert_called_once_with("nova") clients().security_groups.list.assert_called_once_with() self._test_atomic_action_timer(nova_scenario.atomic_actions(), "nova.list_security_groups")
def test__create_image(self, mock_clients): mock_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__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__suspend_server(self): nova_scenario = utils.NovaScenario() nova_scenario._suspend_server(self.server) self.server.suspend.assert_called_once_with() self.wait_for.mock.assert_called_once_with( self.server, update_resource=self.gfm(), is_ready=self.res_is.mock(), check_interval=CONF.benchmark.nova_server_suspend_poll_interval, timeout=CONF.benchmark.nova_server_suspend_timeout) self.res_is.mock.assert_has_calls(mock.call('SUSPENDED')) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.suspend_server')
def test__boot_server_with_ssh(self, mock_clients): mock_clients("nova").servers.create.return_value = self.server nova_scenario = utils.NovaScenario(context={"allow_ssh": "test"}) return_server = nova_scenario._boot_server('server_name', 'image_id', 'flavor_id') self._test_assert_called_once_with( self.wait_for.mock, self.server, CONF.benchmark.nova_server_boot_poll_interval, CONF.benchmark.nova_server_boot_timeout) self.res_is.mock.assert_has_calls(mock.call('ACTIVE')) self.assertEqual(self.wait_for.mock(), return_server) self._test_atomic_action_timer(nova_scenario.atomic_actions(), 'nova.boot_server')
def test__reboot_server(self): nova_scenario = utils.NovaScenario() nova_scenario._reboot_server(self.server) self.server.reboot.assert_called_once_with(reboot_type='SOFT') self.wait_for.mock.assert_called_once_with( self.server, update_resource=self.gfm(), is_ready=self.res_is.mock(), check_interval=CONF.benchmark.nova_server_reboot_poll_interval, timeout=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.reboot_server')