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__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_create_and_list_keypairs(self):
fake_nova_client = fakes.FakeNovaClient()
fake_nova_client.keypairs.create("keypair")
fake_keypair = list(fake_nova_client.keypairs.cache.values())[0]
scenario = keypairs.CreateAndListKeypairs(self.context)
scenario._create_keypair = mock.MagicMock()
scenario._list_keypairs = mock.MagicMock()
scenario._list_keypairs.return_value = [fake_keypair] * 3
# Positive case:
scenario._create_keypair.return_value = fake_keypair.id
scenario.run(fakearg="fakearg")
scenario._create_keypair.assert_called_once_with(fakearg="fakearg")
scenario._list_keypairs.assert_called_once_with()
# Negative case1: keypair isn't created
scenario._create_keypair.return_value = None
self.assertRaises(exceptions.RallyAssertionError,
scenario.run,
fakearg="fakearg")
scenario._create_keypair.assert_called_with(fakearg="fakearg")
# Negative case2: new keypair not in the list of keypairs
scenario._create_keypair.return_value = "fake_keypair"
self.assertRaises(exceptions.RallyAssertionError,
scenario.run,
fakearg="fakearg")
scenario._create_keypair.assert_called_with(fakearg="fakearg")
scenario._list_keypairs.assert_called_with()
def test_nova(self):
fake_nova = fakes.FakeNovaClient()
mock_nova = mock.MagicMock()
mock_nova.client.Client.return_value = fake_nova
self.assertNotIn("nova", self.clients.cache)
with mock.patch.dict("sys.modules", {"novaclient": mock_nova}):
client = self.clients.nova()
self.assertEqual(fake_nova, client)
self.service_catalog.url_for.assert_called_once_with(
service_type="compute",
endpoint_type=consts.EndpointType.PUBLIC,
region_name=self.credential.region_name)
mock_nova.client.Client.assert_called_once_with(
"2",
auth_token=self.fake_keystone.auth_token,
http_log_debug=False,
timeout=cfg.CONF.openstack_client_http_timeout,
insecure=False,
cacert=None,
username=self.credential.username,
api_key=self.credential.password,
project_id=self.credential.tenant_name,
auth_url=self.credential.auth_url)
client.set_management_url.assert_called_once_with(
self.service_catalog.url_for.return_value)
self.assertEqual(fake_nova, self.clients.cache["nova"])
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 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 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 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 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_prep_ssh_sec_group(self, mock_osclients):
fake_nova = fakes.FakeNovaClient()
self.assertEqual(len(fake_nova.security_groups.list()), 1)
mock_cl = mock.MagicMock()
mock_cl.nova.return_value = fake_nova
mock_osclients.return_value = mock_cl
secgroup._prepare_open_secgroup('endpoint')
self.assertEqual(len(fake_nova.security_groups.list()), 2)
self.assertTrue(secgroup.SSH_GROUP_NAME in
[sg.name for sg in fake_nova.security_groups.list()])
# run prep again, check that another security group is not created
secgroup._prepare_open_secgroup('endpoint')
self.assertEqual(len(fake_nova.security_groups.list()), 2)
def test__prepare_open_secgroup(self, mock_osclients):
fake_nova = fakes.FakeNovaClient()
self.assertEqual(len(fake_nova.security_groups.list()), 1)
mock_cl = mock.MagicMock()
mock_cl.nova.return_value = fake_nova
mock_osclients.return_value = mock_cl
ret = secgroup._prepare_open_secgroup("endpoint", self.secgroup_name)
self.assertEqual(self.secgroup_name, ret["name"])
self.assertEqual(2, len(fake_nova.security_groups.list()))
self.assertIn(self.secgroup_name,
[sg.name for sg in fake_nova.security_groups.list()])
# run prep again, check that another security group is not created
secgroup._prepare_open_secgroup("endpoint", self.secgroup_name)
self.assertEqual(2, len(fake_nova.security_groups.list()))
def test__prepare_open_secgroup_rules(self, mock_osclients):
fake_nova = fakes.FakeNovaClient()
# NOTE(hughsaunders) Default security group is precreated
self.assertEqual(1, len(fake_nova.security_groups.list()))
mock_cl = mock.MagicMock()
mock_cl.nova.return_value = fake_nova
mock_osclients.return_value = mock_cl
secgroup._prepare_open_secgroup("endpoint", self.secgroup_name)
self.assertEqual(2, len(fake_nova.security_groups.list()))
rally_open = fake_nova.security_groups.find(self.secgroup_name)
self.assertEqual(3, len(rally_open.rules))
# run prep again, check that extra rules are not created
secgroup._prepare_open_secgroup("endpoint", self.secgroup_name)
rally_open = fake_nova.security_groups.find(self.secgroup_name)
self.assertEqual(3, len(rally_open.rules))
def test_prep_ssh_sec_group_rules(self, mock_osclients):
fake_nova = fakes.FakeNovaClient()
# NOTE(hughsaunders) Default security group is precreated
self.assertEqual(len(fake_nova.security_groups.list()), 1)
mock_cl = mock.MagicMock()
mock_cl.nova.return_value = fake_nova
mock_osclients.return_value = mock_cl
secgroup._prepare_open_secgroup('endpoint')
self.assertEqual(len(fake_nova.security_groups.list()), 2)
rally_open = fake_nova.security_groups.find(secgroup.SSH_GROUP_NAME)
self.assertEqual(len(rally_open.rules), 3)
# run prep again, check that extra rules are not created
secgroup._prepare_open_secgroup('endpoint')
rally_open = fake_nova.security_groups.find(secgroup.SSH_GROUP_NAME)
self.assertEqual(len(rally_open.rules), 3)
def setUp(self):
super(ShowCommandsTestCase, self).setUp()
self.show = show.ShowCommands()
self.admin_credential = {
"username": "******",
"password": "******",
"tenant_name": "admin",
"auth_url": "http://fake.auth.url"
}
self.user_credentials = {
"username": "******",
"password": "******",
"tenant_name": "user3",
"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 test_nova(self):
with mock.patch("rally.osclients.nova") as mock_nova:
fake_nova = fakes.FakeNovaClient()
mock_nova.Client = mock.MagicMock(return_value=fake_nova)
self.assertTrue("nova" not in self.clients.cache)
client = self.clients.nova()
self.assertEqual(client, fake_nova)
self.service_catalog.url_for.assert_called_once_with(
service_type='compute',
endpoint_type=consts.EndpointType.PUBLIC,
region_name=self.endpoint.region_name)
mock_nova.Client.assert_called_once_with(
"2",
auth_token=self.fake_keystone.auth_token,
http_log_debug=False,
timeout=cfg.CONF.openstack_client_http_timeout,
insecure=False,
cacert=None)
client.set_management_url.assert_called_once_with(
self.service_catalog.url_for.return_value)
self.assertEqual(self.clients.cache["nova"], fake_nova)
def test__boot_server_with_network(self, mock_clients):
mock_clients("nova").servers.create.return_value = self.server
nova = fakes.FakeNovaClient()
networks = [
nova.networks.create('net-1'),
nova.networks.create('net-2')
]
mock_clients("nova").networks.list.return_value = networks
nova_scenario = utils.NovaScenario(context={})
return_server = nova_scenario._boot_server('server_name',
'image_id',
'flavor_id',
auto_assign_nic=True)
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_nova(self, mock_nova__get_endpoint):
fake_nova = fakes.FakeNovaClient()
mock_nova__get_endpoint.return_value = "http://fake.to:2/fake"
mock_nova = mock.MagicMock()
mock_nova.client.Client.return_value = fake_nova
mock_keystoneauth1 = mock.MagicMock()
self.assertNotIn("nova", self.clients.cache)
with mock.patch.dict("sys.modules",
{"novaclient": mock_nova,
"keystoneauth1": mock_keystoneauth1}):
mock_keystoneauth1.discover.Discover.return_value = (
mock.Mock(version_data=mock.Mock(return_value=[
{"version": (2, 0)}]))
)
client = self.clients.nova()
self.assertEqual(fake_nova, client)
kw = {
"version": "2",
"session": mock_keystoneauth1.session.Session(),
"endpoint_override": mock_nova__get_endpoint.return_value}
mock_nova.client.Client.assert_called_once_with(**kw)
self.assertEqual(fake_nova, self.clients.cache["nova"])
def test_boot_server_no_nics(self, mock_osclients, mock_nova_clients):
mock_nova_clients.return_value = fakes.FakeNovaClient()
self._verify_boot_server(mock_osclients=mock_osclients,
nic=None,
assert_nic=False)
