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 = objects.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 setUp(self):
super(EC2ImageTestCase, self).setUp()
self.clients = fakes.FakeClients()
image1 = fakes.FakeResource(name="cirros-0.3.4-uec", id="100")
self.clients.glance().images._cache(image1)
image2 = fakes.FakeResource(name="cirros-0.3.4-uec-ramdisk", id="102")
self.clients.glance().images._cache(image2)
image3 = fakes.FakeResource(name="cirros-0.3.4-uec-ramdisk-copy",
id="102")
self.clients.glance().images._cache(image3)
image4 = fakes.FakeResource(name="cirros-0.3.4-uec-ramdisk-copy",
id="103")
self.clients.glance().images._cache(image4)
ec2_image1 = fakes.FakeResource(name="cirros-0.3.4-uec", id="200")
ec2_image2 = fakes.FakeResource(name="cirros-0.3.4-uec-ramdisk",
id="201")
ec2_image3 = fakes.FakeResource(name="cirros-0.3.4-uec-ramdisk-copy",
id="202")
ec2_image4 = fakes.FakeResource(name="cirros-0.3.4-uec-ramdisk-copy",
id="203")
self.clients.ec2().get_all_images = mock.Mock(
return_value=[ec2_image1, ec2_image2, ec2_image3, ec2_image4])
self.type_cls = types.EC2Image(
context={"admin": {
"credential": mock.Mock()
}})
self.type_cls._clients = self.clients
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 test_delete_heat_resources(self):
heat = fakes.FakeClients().heat()
heat.stacks.create("dummy")
total = lambda heat: (len(heat.stacks.list()))
self.assertEqual(total(heat), 1)
utils.delete_heat_resources(heat)
self.assertEqual(total(heat), 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_delete_ceilometer_resources(self):
ceilometer = fakes.FakeClients().ceilometer()
ceilometer.alarms.create()
total = lambda ceilometer: (len(ceilometer.alarms.list()))
self.assertEqual(total(ceilometer), 1)
utils.delete_ceilometer_resources(ceilometer, "dummy")
self.assertEqual(total(ceilometer), 0)
def test_delete_admin_quotas(self):
tenant1 = {'id': 1}
tenant2 = {'id': 2}
client = fakes.FakeClients()
utils.delete_admin_quotas(client, [tenant1, tenant2])
self.assertFalse(client.nova().quotas.list())
self.assertFalse(client.cinder().quotas.list())
def test_delete_designate_resources(self):
designate = fakes.FakeClients().designate()
designate.domains.create("dummy")
total = lambda designate: (len(designate.domains.list()))
self.assertEqual(total(designate), 1)
utils.delete_designate_resources(designate)
self.assertEqual(total(designate), 0)
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 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 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_remove_role(self, mock_osclients):
fc = fakes.FakeClients()
mock_osclients.Clients.return_value = fc
self.create_default_roles_and_patch_add_remove_functions(fc)
ctx = roles.RoleGenerator(self.context)
ctx.context["roles"] = {"r1": "test_role1", "r2": "test_role2"}
ctx.context["users"] = [{
"id": "u1",
"tenant_id": "t1",
"assigned_roles": ["r1", "r2"]
}, {
"id": "u2",
"tenant_id": "t2",
"assigned_roles": ["r1", "r2"]
}]
ctx.credential = mock.MagicMock()
ctx.cleanup()
calls = [
mock.call(user="******", role="r1", tenant="t1"),
mock.call(user="******", role="r1", tenant="t2"),
mock.call(user="******", role="r2", tenant="t1"),
mock.call(user="******", role="r2", tenant="t2")
]
fc.keystone().roles.remove_user_role.assert_has_calls(calls,
any_order=True)
def test_get_constant_runner(self, mock_osclients, mock_base):
mock_osclients.Clients.return_value = fakes.FakeClients()
runner = base.ScenarioRunner.get_runner(
mock.MagicMock(), {"type": consts.RunnerType.CONSTANT})
self.assertIsNotNone(runner)
def test__update_quotas_fn(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)
mock_quota = mock.Mock(return_value=quotas)
result = scenario._update_quotas("nova",
tenant_id,
quota_update_fn=mock_quota)
self.assertEqual(quotas, result)
self._test_atomic_action_timer(scenario.atomic_actions(),
"quotas.update_quotas")
def test_delete_neutron_resources(self):
neutron = fakes.FakeClients().neutron()
scenario = scenarios.neutron.utils.NeutronScenario()
scenario.context = mock.Mock(return_value={"iteration": 1})
scenario.clients = lambda ins: neutron
network1 = scenario._create_network({})
subnet1 = scenario._create_subnet(network1, 1, {})
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, 1, {})
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_delete_glance_resources(self):
glance = fakes.FakeClients().glance()
glance.images.create("dummy", None, None, None)
total = lambda glance: (len(glance.images.list()))
self.assertEqual(total(glance), 1)
utils.delete_glance_resources(glance, "dummy")
self.assertEqual(total(glance), 0)
def test__generate_quota_values_neutron(self):
max_quota = 1024
scenario = utils.QuotasScenario(admin_clients=fakes.FakeClients())
quotas = scenario._generate_quota_values(max_quota, "neutron")
for v in six.itervalues(quotas):
for v1 in six.itervalues(v):
for v2 in six.itervalues(v1):
self.assertTrue(-1 <= v2 <= max_quota)
def setUp(self):
super(NeutronNetworkResourceTypeTestCase, self).setUp()
self.clients = fakes.FakeClients()
net1_data = {"network": {
"name": "net1"
}}
network1 = self.clients.neutron().create_network(net1_data)
self.net1_id = network1["network"]["id"]
def test_delete_keystone_resources(self, mock_wrap):
keystone = fakes.FakeClients().keystone()
mock_wrap.return_value = keystone
keystone.users.create("rally_keystone_dummy", None, None, None)
total = lambda keystone: (len(keystone.users.list()))
self.assertEqual(total(keystone), 1)
utils.delete_keystone_resources(keystone)
self.assertEqual(total(keystone), 0)
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_with()
self._test_atomic_action_timer(scenario.atomic_actions(),
'keystone.list_tenants')
def setUp(self):
super(WatcherGoalTestCase, self).setUp()
self.clients = fakes.FakeClients()
self.goal = self.clients.watcher().goal._cache(
fakes.FakeResource(name="dummy", id="1"))
self.type_cls = types.WatcherGoal(
context={"admin": {
"credential": mock.Mock()
}})
self.type_cls._clients = self.clients
def test_delete_nova_resources(self):
nova = fakes.FakeClients().nova()
nova.servers.create("dummy", None, None)
nova.keypairs.create("dummy")
nova.security_groups.create("dummy")
total = lambda nova: (len(nova.servers.list()) + len(
nova.keypairs.list()) + len(nova.security_groups.list()))
self.assertEqual(total(nova), 4)
utils.delete_nova_resources(nova)
self.assertEqual(total(nova), 1)
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 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_deployment_id = "7f6e88e0-897e-45c0-947c-595ce2437bee"
self.fake_clients = fakes.FakeClients()
self.fake_glance_client = fakes.FakeGlanceClient()
self.fake_nova_client = fakes.FakeNovaClient()
def setUp(self):
super(FlavorTestCase, 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"))
self.clients.nova().flavors._cache(fakes.FakeResource(name="m1.large",
id="44"))
self.clients.nova().flavors._cache(fakes.FakeResource(name="m1.large",
id="45"))
def setUp(self):
super(NeutronNetworkTestCase, self).setUp()
self.clients = fakes.FakeClients()
net1_data = {"network": {"name": "net1"}}
network1 = self.clients.neutron().create_network(net1_data)
self.net1_id = network1["network"]["id"]
self.type_cls = types.NeutronNetwork(
context={"admin": {
"credential": mock.Mock()
}})
self.type_cls._clients = self.clients
def setUp(self):
super(EC2FlavorResourceTypeTestCase, 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="2"))
self.clients.nova().flavors._cache(fakes.FakeResource(name="m1.large",
id="3"))
self.clients.nova().flavors._cache(fakes.FakeResource(name="m1.xlarge",
id="3"))
def test_delete_zaqar_resources(self):
zaqar = fakes.FakeClients().zaqar()
messages = [{'body': {'id': idx}, 'ttl': 360} for idx in range(20)]
queue = zaqar.queue("fizbit")
queue.post_message(messages)
messages_no = lambda queue: (len(queue.messages.list()))
queues_no = lambda zaqar: (len(zaqar.queues.list()))
self.assertEqual(messages_no(queue), 20)
self.assertEqual(queues_no(zaqar), 1)
utils.delete_zaqar_resources(zaqar)
self.assertEqual(messages_no(queue), 0)
self.assertEqual(queues_no(zaqar), 0)
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)
