def test_client_attach_to_instance(self):
clt = self.client
vol = self.volume
inst = fakes.FakeServer()
mp = utils.random_name()
vol.attach_to_instance = Mock()
clt.attach_to_instance(vol, inst, mp)
vol.attach_to_instance.assert_called_once_with(inst, mp)
def test_attach_to_instance_fail(self):
vol = self.volume
inst = fakes.FakeServer()
mp = utils.random_name()
vol._nova_volumes.create_server_volume = Mock(
side_effect=Exception("test"))
self.assertRaises(exc.VolumeAttachmentFailed, vol.attach_to_instance,
inst, mp)
def test_attach_to_instance(self):
vol = self.volume
inst = fakes.FakeServer()
mp = utils.random_name()
vol._nova_volumes.create_server_volume = Mock(return_value=vol)
vol.attach_to_instance(inst, mp)
vol._nova_volumes.create_server_volume.assert_called_once_with(
inst.id, vol.id, mp)
def test_check_network(self):
vm_scenario = utils.VMScenario()
fake_server = fakes.FakeServer()
fake_server.addresses = {}
self.assertRaises(ValueError, vm_scenario.check_network, fake_server,
"private")
fake_server.addresses["private_1"] = {"version": 4, "addr": "1.2.3.4"}
vm_scenario.check_network(fake_server, "private_1")
def test_boot_runcommand_delete_valueerror_fails(self, mock_json_loads):
# Setup mocks
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_server.addresses = dict(
private=[dict(
version=4,
addr="1.2.3.4"
)]
)
mock_json_loads.side_effect = ValueError
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
fake_floating_ip = fakes.FakeFloatingIP()
fake_floating_ip.ip = "4.3.2.1"
scenario._create_floating_ip = mock.MagicMock(
return_value=fake_floating_ip)
scenario._associate_floating_ip = mock.MagicMock()
scenario._release_server_floating_ip = mock.MagicMock()
fake_floating_ip_pool = fakes.FakeFloatingIPPool()
fake_floating_ip_pool.name = "public"
scenario._list_floating_ip_pools = mock.MagicMock(
return_value=[fake_floating_ip_pool])
scenario.run_command = mock.MagicMock()
scenario.run_command.return_value = (0, 'stdout', 'stderr')
scenario._delete_server = mock.MagicMock()
# Run scenario
self.assertRaises(exceptions.ScriptError,
scenario.boot_runcommand_delete,
"image_id", "flavour_id", "script_path",
"interpreter", fixed_network='private',
floating_network='public', username="******",
ip_version=4, port=22, use_floatingip=True,
fakearg="f")
# Assertions
scenario._boot_server.assert_called_once_with(
'name', 'image_id', "flavour_id", key_name="rally_ssh_key",
fakearg="f")
scenario._create_floating_ip.assert_called_once_with(
fake_floating_ip_pool.name)
scenario._associate_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario.run_command.assert_called_once_with(
fake_floating_ip.ip, 22, 'username',
"interpreter", "script_path")
def test_boot_and_show_server(self):
server = fakes.FakeServer()
image = fakes.FakeImage()
flavor = fakes.FakeFlavor()
scenario = servers.NovaServers(self.context)
scenario._boot_server = mock.MagicMock(return_value=server)
scenario._show_server = mock.MagicMock()
scenario.boot_and_show_server(image, flavor, fakearg="fakearg")
scenario._boot_server.assert_called_once_with(image, flavor,
fakearg="fakearg")
scenario._show_server.assert_called_once_with(server)
def test_boot_server_and_list_interfaces(self):
server = fakes.FakeServer()
image = fakes.FakeImage()
flavor = fakes.FakeFlavor()
scenario = servers.BootServerAndListInterfaces(self.context)
scenario._boot_server = mock.MagicMock(return_value=server)
scenario._list_interfaces = mock.MagicMock()
scenario.run(image, flavor, fakearg="fakearg")
scenario._boot_server.assert_called_once_with(image, flavor,
fakearg="fakearg")
scenario._list_interfaces.assert_called_once_with(server)
def test_boot_and_get_console_server(self, length):
server = fakes.FakeServer()
image = fakes.FakeImage()
flavor = fakes.FakeFlavor()
kwargs = {"fakearg": "fakearg"}
scenario = servers.BootAndGetConsoleOutput(self.context)
scenario._boot_server = mock.MagicMock(return_value=server)
scenario._get_server_console_output = mock.MagicMock()
scenario.run(image, flavor, length, **kwargs)
scenario._boot_server.assert_called_once_with(image, flavor, **kwargs)
scenario._get_server_console_output.assert_called_once_with(
server, length)
def test_boot_and_get_console_url(self):
server = fakes.FakeServer()
image = fakes.FakeImage()
flavor = fakes.FakeFlavor()
kwargs = {"fakearg": "fakearg"}
scenario = servers.BootAndGetConsoleUrl(self.context)
scenario._boot_server = mock.MagicMock(return_value=server)
scenario._get_console_url_server = mock.MagicMock()
scenario.run(image, flavor, console_type="novnc", **kwargs)
scenario._boot_server.assert_called_once_with(image, flavor, **kwargs)
scenario._get_console_url_server.assert_called_once_with(
server, "novnc")
def test__release_server_floating_ip(self):
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_floating_ip = fakes.FakeFloatingIP()
scenario._dissociate_floating_ip = mock.MagicMock()
scenario._delete_floating_ip = mock.MagicMock()
scenario.check_ip_address = mock.MagicMock(
return_value=mock.MagicMock(return_value=True))
scenario._release_server_floating_ip(fake_server, fake_floating_ip)
scenario._dissociate_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario._delete_floating_ip.assert_called_once_with(fake_floating_ip)
def test_boot_lock_unlock_and_delete(self):
server = fakes.FakeServer()
image = fakes.FakeImage()
flavor = fakes.FakeFlavor()
scenario = servers.NovaServers(self.context)
scenario._boot_server = mock.Mock(return_value=server)
scenario._lock_server = mock.Mock(side_effect=lambda s: s.lock())
scenario._unlock_server = mock.Mock(side_effect=lambda s: s.unlock())
scenario._delete_server = mock.Mock(
side_effect=lambda s, **kwargs:
self.assertFalse(getattr(s, "OS-EXT-STS:locked", False)))
scenario.boot_lock_unlock_and_delete(image, flavor, fakearg="fakearg")
scenario._boot_server.assert_called_once_with(image, flavor,
fakearg="fakearg")
scenario._lock_server.assert_called_once_with(server)
scenario._unlock_server.assert_called_once_with(server)
scenario._delete_server.assert_called_once_with(server, force=False)
def test_boot_runcommand_delete_no_floating_ip(self, mock_json_loads):
# Setup mocks
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_server.addresses = dict(
private=[dict(
version=4,
addr="1.2.3.4"
)]
)
scenario._boot_server = mock.MagicMock(return_value=fake_server)
scenario._generate_random_name = mock.MagicMock(return_value="name")
scenario.run_command = mock.MagicMock()
scenario.run_command.return_value = (0, 'stdout', 'stderr')
scenario._delete_server = mock.MagicMock()
# Run scenario
scenario.boot_runcommand_delete(
"image_id", "flavour_id", "script_path", "interpreter",
fixed_network='private', floating_network='public',
username="******", ip_version=4,
port=22, use_floatingip=False, fakearg="f")
# Assertions
scenario._boot_server.assert_called_once_with(
'name', 'image_id', "flavour_id", key_name="rally_ssh_key",
fakearg="f")
scenario.run_command.assert_called_once_with(
fake_server.addresses['private'][0]['addr'], 22, 'username',
"interpreter", "script_path")
mock_json_loads.assert_called_once_with('stdout')
scenario._delete_server.assert_called_once_with(fake_server)
class ServerGeneratorTestCase(test.ScenarioTestCase):
def _gen_tenants(self, count):
tenants = {}
for id_ in range(count):
tenants[str(id_)] = {"name": str(id_)}
return tenants
def test_init(self):
tenants_count = 2
servers_per_tenant = 5
self.context.update({
"config": {
"servers": {
"servers_per_tenant": servers_per_tenant,
}
},
"tenants": self._gen_tenants(tenants_count)
})
inst = servers.ServerGenerator(self.context)
self.assertEqual({
"auto_assign_nic": False,
"servers_per_tenant": 5
}, inst.config)
@mock.patch("%s.nova.utils.NovaScenario._boot_servers" % SCN,
return_value=[
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid")
])
@mock.patch("%s.GlanceImage" % TYP)
@mock.patch("%s.Flavor" % TYP)
def test_setup(self, mock_flavor, mock_glance_image,
mock_nova_scenario__boot_servers):
tenants_count = 2
users_per_tenant = 5
servers_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = []
for id_ in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": mock.MagicMock()
})
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"servers": {
"auto_assign_nic": True,
"servers_per_tenant": 5,
"image": {
"name": "cirros-0.3.4-x86_64-uec",
},
"flavor": {
"name": "m1.tiny",
},
"nics": ["foo", "bar"]
},
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
new_context = copy.deepcopy(self.context)
for id_ in new_context["tenants"]:
new_context["tenants"][id_].setdefault("servers", [])
for i in range(servers_per_tenant):
new_context["tenants"][id_]["servers"].append("uuid")
servers_ctx = servers.ServerGenerator(self.context)
servers_ctx.setup()
self.assertEqual(new_context, self.context)
image_id = mock_glance_image.return_value.pre_process.return_value
flavor_id = mock_flavor.return_value.pre_process.return_value
servers_ctx_config = self.context["config"]["servers"]
expected_auto_nic = servers_ctx_config.get("auto_assign_nic", False)
expected_requests = servers_ctx_config.get("servers_per_tenant", False)
called_times = len(tenants)
mock_calls = [
mock.call(image_id,
flavor_id,
auto_assign_nic=expected_auto_nic,
nics=[{
"net-id": "foo"
}, {
"net-id": "bar"
}],
requests=expected_requests) for i in range(called_times)
]
mock_nova_scenario__boot_servers.assert_has_calls(mock_calls)
@mock.patch("%s.servers.resource_manager.cleanup" % CTX)
def test_cleanup(self, mock_cleanup):
tenants_count = 2
users_per_tenant = 5
servers_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = []
for id_ in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id_,
"credential": "credential"
})
tenants[id_].setdefault("servers", [])
for j in range(servers_per_tenant):
tenants[id_]["servers"].append("uuid")
self.context.update({
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"servers": {
"servers_per_tenant": 5,
"image": {
"name": "cirros-0.3.4-x86_64-uec",
},
"flavor": {
"name": "m1.tiny",
},
},
},
"admin": {
"credential": mock.MagicMock()
},
"users": users,
"tenants": tenants
})
servers_ctx = servers.ServerGenerator(self.context)
servers_ctx.cleanup()
mock_cleanup.assert_called_once_with(
names=["nova.servers"],
users=self.context["users"],
superclass=nova_utils.NovaScenario,
task_id=self.context["owner_id"])
class ServerGeneratorTestCase(test.TestCase):
def _gen_tenants(self, count):
tenants = dict()
for id in range(count):
tenants[str(id)] = dict(name=str(id))
return tenants
def test_init(self):
tenants_count = 2
servers_per_tenant = 5
context = {}
context["task"] = mock.MagicMock()
context["config"] = {
"servers": {
"servers_per_tenant": servers_per_tenant,
}
}
context["tenants"] = self._gen_tenants(tenants_count)
inst = servers.ServerGenerator(context)
self.assertEqual(context["config"]["servers"], inst.config)
@mock.patch("%s.nova.utils.NovaScenario._boot_servers" % SCN,
return_value=[
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid"),
fakes.FakeServer(id="uuid")
])
@mock.patch("%s.ImageResourceType.transform" % TYP,
return_value=mock.MagicMock())
@mock.patch("%s.FlavorResourceType.transform" % TYP,
return_value=mock.MagicMock())
@mock.patch("%s.servers.osclients" % CTX, return_value=fakes.FakeClients())
def test_setup(self, mock_osclients, mock_flavor_transform,
mock_image_transform, mock_boot_servers):
tenants_count = 2
users_per_tenant = 5
servers_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = list()
for id in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id,
"endpoint": "endpoint"
})
real_context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"servers": {
"servers_per_tenant": 5,
"image": {
"name": "cirros-0.3.2-x86_64-uec",
},
"flavor": {
"name": "m1.tiny",
},
},
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": users,
"tenants": tenants
}
new_context = copy.deepcopy(real_context)
for id in new_context["tenants"]:
new_context["tenants"][id].setdefault("servers", list())
for i in range(servers_per_tenant):
new_context["tenants"][id]["servers"].append("uuid")
servers_ctx = servers.ServerGenerator(real_context)
servers_ctx.setup()
self.assertEqual(new_context, real_context)
@mock.patch("%s.servers.osclients" % CTX)
@mock.patch("%s.servers.resource_manager.cleanup" % CTX)
def test_cleanup(self, mock_cleanup, mock_osclients):
tenants_count = 2
users_per_tenant = 5
servers_per_tenant = 5
tenants = self._gen_tenants(tenants_count)
users = list()
for id in tenants.keys():
for i in range(users_per_tenant):
users.append({
"id": i,
"tenant_id": id,
"endpoint": "endpoint"
})
tenants[id].setdefault("servers", list())
for j in range(servers_per_tenant):
tenants[id]["servers"].append("uuid")
context = {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10,
},
"servers": {
"servers_per_tenant": 5,
"image": {
"name": "cirros-0.3.2-x86_64-uec",
},
"flavor": {
"name": "m1.tiny",
},
},
},
"admin": {
"endpoint": mock.MagicMock()
},
"task": mock.MagicMock(),
"users": users,
"tenants": tenants
}
servers_ctx = servers.ServerGenerator(context)
servers_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["nova.servers"],
users=context["users"])
class EC2ServerGeneratorTestCase(test.TestCase):
def _gen_tenants_and_users(self, tenants_count, users_per_tenant):
tenants = {}
for id in range(tenants_count):
tenants[str(id)] = dict(name=str(id))
users = []
for tenant_id in tenants.keys():
for i in range(users_per_tenant):
users.append({"id": i, "tenant_id": tenant_id,
"endpoint": "endpoint"})
return tenants, users
def _get_context(self, users, tenants):
return {
"config": {
"users": {
"tenants": 2,
"users_per_tenant": 5,
"concurrent": 10},
"ec2_servers": {
"servers_per_tenant": 5,
"image": {"name": "foo_image"},
"flavor": {"name": "foo_flavor"}
}
},
"admin": {"endpoint": mock.MagicMock()},
"task": mock.MagicMock(),
"users": users,
"tenants": tenants
}
@mock.patch("%s.ec2.utils.EC2Scenario._boot_servers" % SCN,
return_value=[fakes.FakeServer(id=str(i)) for i in range(5)])
@mock.patch("%s.EC2ImageResourceType.transform" % TYP,
return_value=mock.MagicMock())
@mock.patch("%s.servers.osclients" % CTX, return_value=fakes.FakeClients())
def test_setup(self, mock_osclients,
mock_ec2_image_resource_type_transform,
mock_ec2_scenario__boot_servers):
tenants_count = 2
users_per_tenant = 5
servers_per_tenant = 5
tenants, users = self._gen_tenants_and_users(tenants_count,
users_per_tenant)
real_context = self._get_context(users, tenants)
new_context = copy.deepcopy(real_context)
for tenant_id in new_context["tenants"]:
new_context["tenants"][tenant_id].setdefault("ec2_servers", [])
for i in range(servers_per_tenant):
new_context["tenants"][tenant_id]["ec2_servers"].append(str(i))
servers_ctx = servers.EC2ServerGenerator(real_context)
servers_ctx.setup()
self.assertEqual(new_context, servers_ctx.context)
@mock.patch("%s.servers.osclients" % CTX)
@mock.patch("%s.servers.resource_manager.cleanup" % CTX)
def test_cleanup(self, mock_cleanup, mock_osclients):
tenants_count = 2
users_per_tenant = 5
servers_per_tenant = 5
tenants, users = self._gen_tenants_and_users(tenants_count,
users_per_tenant)
for tenant_id in tenants.keys():
tenants[tenant_id].setdefault("ec2_servers", [])
for i in range(servers_per_tenant):
tenants[tenant_id]["ec2_servers"].append(str(i))
context = self._get_context(users, tenants)
servers_ctx = servers.EC2ServerGenerator(context)
servers_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["ec2.servers"],
users=context["users"])
def test_boot_runcommand_delete(self, mock_json_loads):
# Setup mocks
scenario = vmtasks.VMTasks()
fake_server = fakes.FakeServer()
fake_server.addresses = dict(
private=[dict(
version=4,
addr="1.2.3.4"
)]
)
scenario._boot_server = mock.MagicMock(return_value=fake_server)
fake_volume = fakes.FakeVolumeManager().create()
fake_volume.id = "volume_id"
scenario._create_volume = mock.MagicMock(return_value=fake_volume)
scenario._generate_random_name = mock.MagicMock(return_value="name")
fake_floating_ip = fakes.FakeFloatingIP()
fake_floating_ip.ip = "4.3.2.1"
scenario._create_floating_ip = mock.MagicMock(
return_value=fake_floating_ip)
scenario._associate_floating_ip = mock.MagicMock()
scenario._release_server_floating_ip = mock.MagicMock()
fake_floating_ip_pool = fakes.FakeFloatingIPPool()
fake_floating_ip_pool.name = "public"
scenario._list_floating_ip_pools = mock.MagicMock(
return_value=[fake_floating_ip_pool])
scenario.run_command = mock.MagicMock()
scenario.run_command.return_value = (0, 'stdout', 'stderr')
scenario._delete_server = mock.MagicMock()
# Run scenario
scenario.boot_runcommand_delete(
"image_id", "flavour_id", "script_path", "interpreter",
fixed_network='private', floating_network='public',
volume_args={'size': 10}, username="******", ip_version=4,
port=22, use_floatingip=True, fakearg="f")
# Assertions
scenario._boot_server.assert_called_once_with(
'name', 'image_id', "flavour_id", key_name="rally_ssh_key",
fakearg="f", block_device_mapping={'vda': 'volume_id:::1'})
scenario._create_volume.assert_called_once_with(10, imageRef=None)
scenario._create_floating_ip.assert_called_once_with(
fake_floating_ip_pool.name)
scenario._associate_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario.run_command.assert_called_once_with(
fake_floating_ip.ip, 22, 'username',
"interpreter", "script_path")
mock_json_loads.assert_called_once_with('stdout')
scenario._release_server_floating_ip.assert_called_once_with(
fake_server, fake_floating_ip)
scenario._delete_server.assert_called_once_with(fake_server)
