def test_image_valid_on_flavor_flavor_not_exist(self, mock_osclients):
fakegclient = fakes.FakeGlanceClient()
mock_osclients.glance.return_value = fakegclient
fakenclient = fakes.FakeNovaClient()
fakenclient.flavors = mock.MagicMock()
fakenclient.flavors.get.side_effect = nova_exc.NotFound(code=404)
mock_osclients.nova.return_value = fakenclient
validator = validation.image_valid_on_flavor("flavor", "image")
test_img_id = "test_image_id"
test_flavor_id = 101
config = {
"args": {
"flavor": {
"id": test_flavor_id
},
"image": {
"id": test_img_id
}
}
}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.flavors.get.assert_called_once_with(flavor=test_flavor_id)
self.assertFalse(result.is_valid)
self.assertEqual(result.msg, "Flavor with id '101' not found")
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_image_valid_on_flavor_fail(self, mock_osclients):
fakegclient = fakes.FakeGlanceClient()
image = fakes.FakeImage()
image.min_ram = 1
image.size = 1
image.min_disk = 1
fakegclient.images.get = mock.MagicMock(return_value=image)
mock_osclients.glance.return_value = fakegclient
fakenclient = fakes.FakeNovaClient()
flavor = fakes.FakeFlavor()
flavor.ram = 0
flavor.disk = 0
fakenclient.flavors.get = mock.MagicMock(return_value=flavor)
mock_osclients.nova.return_value = fakenclient
validator = validation.image_valid_on_flavor("flavor", "image")
result = validator(clients=mock_osclients,
flavor={"id": flavor.id},
image={"id": image.id})
fakenclient.flavors.get.assert_called_once_with(flavor=flavor.id)
fakegclient.images.get.assert_called_once_with(image=image.id)
self.assertFalse(result.is_valid)
self.assertIsNotNone(result.msg)
def test_image_valid_on_missing_flavor_disk(self, mock_osclients):
fakegclient = fakes.FakeGlanceClient()
image = fakes.FakeImage()
image.min_ram = 0
image.size = 0
image.min_disk = 100
fakegclient.images.get = mock.MagicMock(return_value=image)
mock_osclients.glance.return_value = fakegclient
fakenclient = fakes.FakeNovaClient()
flavor = fakes.FakeFlavor()
flavor.ram = 1
fakenclient.flavors.get = mock.MagicMock(return_value=flavor)
mock_osclients.nova.return_value = fakenclient
validator = validation.image_valid_on_flavor("flavor", "image")
config = {
"args": {
"image": {
"id": image.id
},
"flavor": {
"id": flavor.id
}
}
}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.flavors.get.assert_called_once_with(flavor=flavor.id)
fakegclient.images.get.assert_called_once_with(image=image.id)
self.assertTrue(result.is_valid)
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__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_flavor_exists(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fakenclient.flavors = mock.MagicMock()
mock_osclients.nova.return_value = fakenclient
validator = validation.flavor_exists("flavor_id")
test_flavor_id = 1
result = validator(clients=mock_osclients, flavor_id=test_flavor_id)
fakenclient.flavors.get.assert_called_once_with(flavor=test_flavor_id)
self.assertTrue(result.is_valid)
self.assertIsNone(result.msg)
def test_flavor_exists_fail(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fakenclient.flavors = mock.MagicMock()
fakenclient.flavors.get.side_effect = nova_exc.NotFound(code=404)
mock_osclients.nova.return_value = fakenclient
validator = validation.flavor_exists("flavor_id")
test_flavor_id = 101
result = validator(clients=mock_osclients, flavor_id=test_flavor_id)
fakenclient.flavors.get.assert_called_once_with(flavor=test_flavor_id)
self.assertFalse(result.is_valid)
self.assertIsNotNone(result.msg)
def test_flavor_exists(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fakenclient.flavors = mock.MagicMock()
mock_osclients.nova.return_value = fakenclient
validator = validation.flavor_exists("flavor")
test_flavor_id = 1
resource = {"id": test_flavor_id}
config = {"args": {"flavor": resource}}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.flavors.get.assert_called_once_with(flavor=test_flavor_id)
self.assertTrue(result.is_valid)
self.assertIsNone(result.msg)
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 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_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_network_exists(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fake_network = fakes.FakeNetwork()
fake_network.label = "private"
fake_network.id = "net_id_1234"
fakenclient.networks.list = mock.MagicMock(return_value=[fake_network])
mock_osclients.nova.return_value = fakenclient
validator = validation.network_exists("fixed_network")
network_name = "private"
config = {"args": {"fixed_network": network_name}}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.networks.list.assert_called_once_with()
self.assertTrue(result.is_valid)
self.assertIsNone(result.msg)
def test_external_network_exists(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fake_pool = fakes.FakeFloatingIPPool()
fake_pool.name = "floating"
fakenclient.floating_ip_pools.list = mock.MagicMock(
return_value=[fake_pool])
mock_osclients.nova.return_value = fakenclient
validator = validation.external_network_exists("floating_network",
"use_floatingip")
network_name = "floating"
config = {"args": {"floating_network": network_name}}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.floating_ip_pools.list.assert_called_once_with()
self.assertTrue(result.is_valid)
self.assertIsNone(result.msg)
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 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)
mock_nova.Client.assert_called_once_with(
"2",
self.endpoint.username,
self.endpoint.password,
self.endpoint.tenant_name,
auth_url=self.endpoint.auth_url,
region_name=self.endpoint.region_name,
service_type="compute",
http_log_debug=False,
timeout=cfg.CONF.openstack_client_http_timeout,
insecure=False,
cacert=None)
self.assertEqual(self.clients.cache["nova"], fake_nova)
def test_network_exists_fail(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fake_network = fakes.FakeNetwork()
fake_network.label = "private"
fake_network.id = "net_id_1234"
fakenclient.networks.list = mock.MagicMock(return_value=[fake_network])
mock_osclients.nova.return_value = fakenclient
validator = validation.network_exists("fixed_network")
network_name = "foo"
config = {"args": {"fixed_network": network_name}}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.networks.list.assert_called_once_with()
self.assertFalse(result.is_valid)
self.assertEqual(
result.msg, "Network with name foo not found. "
"Available networks: ['private']")
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):
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='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_external_network_exists_fail(self, mock_osclients):
fakenclient = fakes.FakeNovaClient()
fake_pool = fakes.FakeFloatingIPPool()
fake_pool.name = "floating"
fakenclient.floating_ip_pools.list = mock.MagicMock(
return_value=[fake_pool])
mock_osclients.nova.return_value = fakenclient
validator = validation.external_network_exists("floating_network",
"use_floatingip")
network_name = "foo"
config = {"args": {"floating_network": network_name}}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.floating_ip_pools.list.assert_called_once_with()
self.assertFalse(result.is_valid)
self.assertEqual(
result.msg, "External (floating) network with name "
"foo not found. "
"Available networks: ['floating']")
def test_image_invalid_on_size(self, mock_osclients):
fakegclient = fakes.FakeGlanceClient()
image = fakes.FakeImage()
image.min_ram = 0
image.size = 0
image.min_disk = 100
fakegclient.images.get = mock.MagicMock(return_value=image)
mock_osclients.glance.return_value = fakegclient
fakenclient = fakes.FakeNovaClient()
flavor = fakes.FakeFlavor()
flavor.ram = 1
flavor.disk = 99
fakenclient.flavors.get = mock.MagicMock(return_value=flavor)
mock_osclients.nova.return_value = fakenclient
validator = validation.image_valid_on_flavor("flavor", "image")
config = {
"args": {
"image": {
"id": image.id
},
"flavor": {
"id": flavor.id
}
}
}
result = validator(config, clients=mock_osclients, task=None)
fakenclient.flavors.get.assert_called_once_with(flavor=flavor.id)
fakegclient.images.get.assert_called_once_with(image=image.id)
self.assertFalse(result.is_valid)
self.assertEqual(
result.msg,
_("The disk size for flavor 'flavor-id-0'"
" is too small for requested image 'image-id-0'"))
def test_image_valid_on_flavor_image_not_exist(self, mock_osclients):
fakegclient = fakes.FakeGlanceClient()
fakegclient.images.get = mock.MagicMock()
fakegclient.images.get.side_effect = glance_exc.HTTPNotFound
mock_osclients.glance.return_value = fakegclient
fakenclient = fakes.FakeNovaClient()
flavor = fakes.FakeFlavor()
fakenclient.flavors.get = mock.MagicMock(return_value=flavor)
mock_osclients.nova.return_value = fakenclient
validator = validation.image_valid_on_flavor("flavor", "image")
test_img_id = "test_image_id"
result = validator(clients=mock_osclients,
flavor={"id": flavor.id},
image={"id": test_img_id})
fakenclient.flavors.get.assert_called_once_with(flavor=flavor.id)
fakegclient.images.get.assert_called_once_with(image=test_img_id)
self.assertFalse(result.is_valid)
self.assertEqual(result.msg, "Image with id 'test_image_id' not found")
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)
