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))
