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