openstack/rally-openstack
Code Issues Proposed changes

Merge "unit-tests: fix mocks' naming"

Browse Source
This commit is contained in:
Jenkins 2015-06-22 19:56:33 +00:00 committed by Gerrit Code Review
commit c072b9a8cd
30 changed files with 627 additions and 595 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
tests/unit/doc/test_task_samples.py
View File

@ -34,7 +34,8 @@ class TaskSampleTestCase(test.TestCase):
@mock.patch("rally.benchmark.engine.BenchmarkEngine" @mock.patch("rally.benchmark.engine.BenchmarkEngine"
"._validate_config_semantic") "._validate_config_semantic")
def test_schema_is_valid(self, mock_semantic): def test_schema_is_valid(self,
mock_benchmark_engine__validate_config_semantic):
scenarios = set() scenarios = set()
for dirname, dirnames, filenames in os.walk(self.samples_path): for dirname, dirnames, filenames in os.walk(self.samples_path):

12
tests/unit/plugins/openstack/context/quotas/test_cinder_quotas.py
View File

@ -22,8 +22,8 @@ class CinderQuotasTestCase(test.TestCase):
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_update(self, client_mock): def test_update(self, mock_clients):
cinder_quo = cinder_quotas.CinderQuotas(client_mock) cinder_quo = cinder_quotas.CinderQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
quotas_values = { quotas_values = {
"volumes": 10, "volumes": 10,
@ -31,13 +31,13 @@ class CinderQuotasTestCase(test.TestCase):
"gigabytes": 1000 "gigabytes": 1000
} }
cinder_quo.update(tenant_id, **quotas_values) cinder_quo.update(tenant_id, **quotas_values)
client_mock.cinder().quotas.update.assert_called_once_with( mock_clients.cinder().quotas.update.assert_called_once_with(
tenant_id, **quotas_values) tenant_id, **quotas_values)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_delete(self, client_mock): def test_delete(self, mock_clients):
cinder_quo = cinder_quotas.CinderQuotas(client_mock) cinder_quo = cinder_quotas.CinderQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
cinder_quo.delete(tenant_id) cinder_quo.delete(tenant_id)
client_mock.cinder().quotas.delete.assert_called_once_with(tenant_id) mock_clients.cinder().quotas.delete.assert_called_once_with(tenant_id)

12
tests/unit/plugins/openstack/context/quotas/test_designate_quotas.py
View File

@ -22,8 +22,8 @@ class DesignateQuotasTestCase(test.TestCase):
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_update(self, client_mock): def test_update(self, mock_clients):
quotas = designate_quotas.DesignateQuotas(client_mock) quotas = designate_quotas.DesignateQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
quotas_values = { quotas_values = {
"domains": 5, "domains": 5,
@ -32,14 +32,14 @@ class DesignateQuotasTestCase(test.TestCase):
"recordset_records": 20, "recordset_records": 20,
} }
quotas.update(tenant_id, **quotas_values) quotas.update(tenant_id, **quotas_values)
client_mock.designate().quotas.update.assert_called_once_with( mock_clients.designate().quotas.update.assert_called_once_with(
tenant_id, quotas_values) tenant_id, quotas_values)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_delete(self, client_mock): def test_delete(self, mock_clients):
quotas = designate_quotas.DesignateQuotas(client_mock) quotas = designate_quotas.DesignateQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
quotas.delete(tenant_id) quotas.delete(tenant_id)
client_mock.designate().quotas.reset.assert_called_once_with( mock_clients.designate().quotas.reset.assert_called_once_with(
tenant_id) tenant_id)

14
tests/unit/plugins/openstack/context/quotas/test_neutron_quotas.py
View File

@ -22,8 +22,8 @@ class NeutronQuotasTestCase(test.TestCase):
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_update(self, client_mock): def test_update(self, mock_clients):
neutron_quotas = quotas.NeutronQuotas(client_mock) neutron_quotas = quotas.NeutronQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
quotas_values = { quotas_values = {
"network": 20, "network": 20,
@ -36,13 +36,13 @@ class NeutronQuotasTestCase(test.TestCase):
} }
neutron_quotas.update(tenant_id, **quotas_values) neutron_quotas.update(tenant_id, **quotas_values)
body = {"quota": quotas_values} body = {"quota": quotas_values}
client_mock.neutron().update_quota.assert_called_once_with(tenant_id, mock_clients.neutron().update_quota.assert_called_once_with(tenant_id,
body=body) body=body)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_delete(self, client_mock): def test_delete(self, mock_clients):
neutron_quotas = quotas.NeutronQuotas(client_mock) neutron_quotas = quotas.NeutronQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
neutron_quotas.delete(tenant_id) neutron_quotas.delete(tenant_id)
client_mock.neutron().delete_quota.assert_called_once_with(tenant_id) mock_clients.neutron().delete_quota.assert_called_once_with(tenant_id)

12
tests/unit/plugins/openstack/context/quotas/test_nova_quotas.py
View File

@ -22,8 +22,8 @@ class NovaQuotasTestCase(test.TestCase):
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_update(self, client_mock): def test_update(self, mock_clients):
nova_quotas = quotas.NovaQuotas(client_mock) nova_quotas = quotas.NovaQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
quotas_values = { quotas_values = {
"instances": 10, "instances": 10,
@ -40,13 +40,13 @@ class NovaQuotasTestCase(test.TestCase):
"security_group_rules": 50 "security_group_rules": 50
} }
nova_quotas.update(tenant_id, **quotas_values) nova_quotas.update(tenant_id, **quotas_values)
client_mock.nova().quotas.update.assert_called_once_with( mock_clients.nova().quotas.update.assert_called_once_with(
tenant_id, **quotas_values) tenant_id, **quotas_values)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
def test_delete(self, client_mock): def test_delete(self, mock_clients):
nova_quotas = quotas.NovaQuotas(client_mock) nova_quotas = quotas.NovaQuotas(mock_clients)
tenant_id = mock.MagicMock() tenant_id = mock.MagicMock()
nova_quotas.delete(tenant_id) nova_quotas.delete(tenant_id)
client_mock.nova().quotas.delete.assert_called_once_with(tenant_id) mock_clients.nova().quotas.delete.assert_called_once_with(tenant_id)

38
tests/unit/plugins/openstack/context/quotas/test_quotas.py
View File

@ -139,7 +139,7 @@ class QuotasTestCase(test.TestCase):
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.cinder_quotas.CinderQuotas") "quotas.cinder_quotas.CinderQuotas")
def test_cinder_quotas(self, mock_quotas, mock_osclients): def test_cinder_quotas(self, mock_cinder_quotas, mock_clients):
ctx = copy.deepcopy(self.context) ctx = copy.deepcopy(self.context)
ctx["config"]["quotas"] = { ctx["config"]["quotas"] = {
"cinder": { "cinder": {
@ -158,19 +158,21 @@ class QuotasTestCase(test.TestCase):
expected_setup_calls.append(mock.call() expected_setup_calls.append(mock.call()
.update(tenant, .update(tenant,
**cinder_quotas)) **cinder_quotas))
mock_quotas.assert_has_calls(expected_setup_calls, any_order=True) mock_cinder_quotas.assert_has_calls(
mock_quotas.reset_mock() expected_setup_calls, any_order=True)
mock_cinder_quotas.reset_mock()
expected_cleanup_calls = [] expected_cleanup_calls = []
for tenant in tenants: for tenant in tenants:
expected_cleanup_calls.append(mock.call().delete(tenant)) expected_cleanup_calls.append(mock.call().delete(tenant))
mock_quotas.assert_has_calls(expected_cleanup_calls, any_order=True) mock_cinder_quotas.assert_has_calls(
expected_cleanup_calls, any_order=True)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.nova_quotas.NovaQuotas") "quotas.nova_quotas.NovaQuotas")
def test_nova_quotas(self, mock_quotas, mock_osclients): def test_nova_quotas(self, mock_nova_quotas, mock_clients):
ctx = copy.deepcopy(self.context) ctx = copy.deepcopy(self.context)
ctx["config"]["quotas"] = { ctx["config"]["quotas"] = {
@ -198,19 +200,21 @@ class QuotasTestCase(test.TestCase):
expected_setup_calls.append(mock.call() expected_setup_calls.append(mock.call()
.update(tenant, .update(tenant,
**nova_quotas)) **nova_quotas))
mock_quotas.assert_has_calls(expected_setup_calls, any_order=True) mock_nova_quotas.assert_has_calls(
mock_quotas.reset_mock() expected_setup_calls, any_order=True)
mock_nova_quotas.reset_mock()
expected_cleanup_calls = [] expected_cleanup_calls = []
for tenant in ctx["tenants"]: for tenant in ctx["tenants"]:
expected_cleanup_calls.append(mock.call().delete(tenant)) expected_cleanup_calls.append(mock.call().delete(tenant))
mock_quotas.assert_has_calls(expected_cleanup_calls, any_order=True) mock_nova_quotas.assert_has_calls(
expected_cleanup_calls, any_order=True)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.neutron_quotas.NeutronQuotas") "quotas.neutron_quotas.NeutronQuotas")
def test_neutron_quotas(self, mock_quotas, mock_osclients): def test_neutron_quotas(self, mock_neutron_quotas, mock_clients):
ctx = copy.deepcopy(self.context) ctx = copy.deepcopy(self.context)
ctx["config"]["quotas"] = { ctx["config"]["quotas"] = {
@ -233,13 +237,15 @@ class QuotasTestCase(test.TestCase):
expected_setup_calls.append(mock.call() expected_setup_calls.append(mock.call()
.update(tenant, .update(tenant,
**neutron_quotas)) **neutron_quotas))
mock_quotas.assert_has_calls(expected_setup_calls, any_order=True) mock_neutron_quotas.assert_has_calls(
mock_quotas.reset_mock() expected_setup_calls, any_order=True)
mock_neutron_quotas.reset_mock()
expected_cleanup_calls = [] expected_cleanup_calls = []
for tenant in ctx["tenants"]: for tenant in ctx["tenants"]:
expected_cleanup_calls.append(mock.call().delete(tenant)) expected_cleanup_calls.append(mock.call().delete(tenant))
mock_quotas.assert_has_calls(expected_cleanup_calls, any_order=True) mock_neutron_quotas.assert_has_calls(
expected_cleanup_calls, any_order=True)
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.quotas.osclients.Clients") "quotas.quotas.osclients.Clients")
@ -249,8 +255,8 @@ class QuotasTestCase(test.TestCase):
"quotas.cinder_quotas.CinderQuotas") "quotas.cinder_quotas.CinderQuotas")
@mock.patch("rally.plugins.openstack.context." @mock.patch("rally.plugins.openstack.context."
"quotas.neutron_quotas.NeutronQuotas") "quotas.neutron_quotas.NeutronQuotas")
def test_no_quotas(self, mock_neutron_quota, mock_cinder_quotas, def test_no_quotas(self, mock_neutron_quotas, mock_cinder_quotas,
mock_nova_quotas, mock_osclients): mock_nova_quotas, mock_clients):
ctx = copy.deepcopy(self.context) ctx = copy.deepcopy(self.context)
if "quotas" in ctx["config"]: if "quotas" in ctx["config"]:
del ctx["config"]["quotas"] del ctx["config"]["quotas"]
@ -259,11 +265,11 @@ class QuotasTestCase(test.TestCase):
quotas_ctx.setup() quotas_ctx.setup()
self.assertFalse(mock_cinder_quotas.update.called) self.assertFalse(mock_cinder_quotas.update.called)
self.assertFalse(mock_nova_quotas.update.called) self.assertFalse(mock_nova_quotas.update.called)
self.assertFalse(mock_neutron_quota.update.called) self.assertFalse(mock_neutron_quotas.update.called)
self.assertFalse(mock_cinder_quotas.delete.called) self.assertFalse(mock_cinder_quotas.delete.called)
self.assertFalse(mock_nova_quotas.delete.called) self.assertFalse(mock_nova_quotas.delete.called)
self.assertFalse(mock_neutron_quota.delete.called) self.assertFalse(mock_neutron_quotas.delete.called)
@ddt.data( @ddt.data(
{"quotas_ctxt": {"nova": {"cpu": 1}}, {"quotas_ctxt": {"nova": {"cpu": 1}},

11
tests/unit/plugins/openstack/context/sahara/test_sahara_cluster.py
View File

@ -71,8 +71,9 @@ class SaharaClusterTestCase(test.TestCase):
@mock.patch("%s.sahara_cluster.utils.SaharaScenario._launch_cluster" % CTX, @mock.patch("%s.sahara_cluster.utils.SaharaScenario._launch_cluster" % CTX,
return_value=mock.MagicMock(id=42)) return_value=mock.MagicMock(id=42))
@mock.patch("%s.sahara_cluster.osclients" % CTX) @mock.patch("%s.sahara_cluster.osclients" % CTX)
def test_setup_and_cleanup(self, mock_osclients, def test_setup_and_cleanup(
mock_launch, mock_cleanup): self, mock_osclients, mock_sahara_scenario__launch_cluster,
mock_cleanup):
mock_sahara = mock_osclients.Clients(mock.MagicMock()).sahara() mock_sahara = mock_osclients.Clients(mock.MagicMock()).sahara()
@ -104,7 +105,8 @@ class SaharaClusterTestCase(test.TestCase):
mock.MagicMock(status="active")] mock.MagicMock(status="active")]
sahara_ctx.setup() sahara_ctx.setup()
mock_launch.assert_has_calls(launch_cluster_calls) mock_sahara_scenario__launch_cluster.assert_has_calls(
launch_cluster_calls)
sahara_ctx.cleanup() sahara_ctx.cleanup()
mock_cleanup.assert_called_once_with(names=["sahara.clusters"], mock_cleanup.assert_called_once_with(names=["sahara.clusters"],
users=ctx["users"]) users=ctx["users"])
@ -112,7 +114,8 @@ class SaharaClusterTestCase(test.TestCase):
@mock.patch("%s.sahara_cluster.utils.SaharaScenario._launch_cluster" % CTX, @mock.patch("%s.sahara_cluster.utils.SaharaScenario._launch_cluster" % CTX,
return_value=mock.MagicMock(id=42)) return_value=mock.MagicMock(id=42))
@mock.patch("%s.sahara_cluster.osclients" % CTX) @mock.patch("%s.sahara_cluster.osclients" % CTX)
def test_setup_and_cleanup_error(self, mock_osclients, mock_launch): def test_setup_and_cleanup_error(
self, mock_osclients, mock_sahara_scenario__launch_cluster):
mock_sahara = mock_osclients.Clients(mock.MagicMock()).sahara() mock_sahara = mock_osclients.Clients(mock.MagicMock()).sahara()

25
tests/unit/plugins/openstack/context/sahara/test_sahara_image.py
View File

@ -89,8 +89,9 @@ class SaharaImageTestCase(test.TestCase):
return_value=mock.MagicMock(id=42)) return_value=mock.MagicMock(id=42))
@mock.patch("%s.osclients" % CTX) @mock.patch("%s.osclients" % CTX)
@mock.patch("%s.resource_manager.cleanup" % CTX) @mock.patch("%s.resource_manager.cleanup" % CTX)
def test_setup_and_cleanup_url_image(self, mock_cleanup, mock_osclients, def test_setup_and_cleanup_url_image(
mock_image_generator, mock_uuid): self, mock_cleanup, mock_osclients,
mock_glance_scenario__create_image, mock_generate_random_name):
ctx = self.url_image_context ctx = self.url_image_context
sahara_ctx = sahara_image.SaharaImage(ctx) sahara_ctx = sahara_image.SaharaImage(ctx)
@ -115,7 +116,7 @@ class SaharaImageTestCase(test.TestCase):
new_tags=["test_plugin", "test_version"])) new_tags=["test_plugin", "test_version"]))
sahara_ctx.setup() sahara_ctx.setup()
mock_image_generator.assert_has_calls(glance_calls) mock_glance_scenario__create_image.assert_has_calls(glance_calls)
mock_osclients.Clients( mock_osclients.Clients(
mock.MagicMock()).sahara().images.update_image.assert_has_calls( mock.MagicMock()).sahara().images.update_image.assert_has_calls(
sahara_update_image_calls) sahara_update_image_calls)
@ -131,11 +132,11 @@ class SaharaImageTestCase(test.TestCase):
return_value=mock.MagicMock(id=42)) return_value=mock.MagicMock(id=42))
@mock.patch("%s.resource_manager.cleanup" % CTX) @mock.patch("%s.resource_manager.cleanup" % CTX)
@mock.patch("%s.osclients" % CTX) @mock.patch("%s.osclients" % CTX)
def test_setup_and_cleanup_existing_image(self, mock_os_clients, def test_setup_and_cleanup_existing_image(
mock_cleanup, self, mock_osclients, mock_cleanup,
mock_image_generator): mock_glance_scenario__create_image):
clients = mock_os_clients.Clients(mock.MagicMock()) clients = mock_osclients.Clients(mock.MagicMock())
clients.glance().images.get.return_value = mock.MagicMock( clients.glance().images.get.return_value = mock.MagicMock(
is_public=True) is_public=True)
@ -147,24 +148,24 @@ class SaharaImageTestCase(test.TestCase):
image_id = sahara_ctx.context["tenants"][tenant_id]["sahara_image"] image_id = sahara_ctx.context["tenants"][tenant_id]["sahara_image"]
self.assertEqual("some_id", image_id) self.assertEqual("some_id", image_id)
self.assertEqual(False, mock_image_generator.called) self.assertEqual(False, mock_glance_scenario__create_image.called)
sahara_ctx.cleanup() sahara_ctx.cleanup()
self.assertEqual(False, mock_cleanup.called) self.assertEqual(False, mock_cleanup.called)
@mock.patch("%s.osclients" % CTX) @mock.patch("%s.osclients" % CTX)
def test_check_existing_image(self, mock_os_clients): def test_check_existing_image(self, mock_osclients):
ctx = self.existing_image_context ctx = self.existing_image_context
sahara_ctx = sahara_image.SaharaImage(ctx) sahara_ctx = sahara_image.SaharaImage(ctx)
sahara_ctx.setup() sahara_ctx.setup()
mock_os_clients.glance().images.get.asser_called_once_with("some_id") mock_osclients.glance().images.get.asser_called_once_with("some_id")
@mock.patch("%s.osclients" % CTX) @mock.patch("%s.osclients" % CTX)
def test_check_existing_image_fail(self, mock_os_clients): def test_check_existing_image_fail(self, mock_osclients):
clients = mock_os_clients.Clients(mock.MagicMock()) clients = mock_osclients.Clients(mock.MagicMock())
clients.glance().images.get.return_value = mock.MagicMock( clients.glance().images.get.return_value = mock.MagicMock(
is_public=False) is_public=False)

30
tests/unit/plugins/openstack/context/vm/test_custom_image.py
View File

@ -68,16 +68,16 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
return_value="image") return_value="image")
@mock.patch("%s.types.FlavorResourceType.transform" % BASE, @mock.patch("%s.types.FlavorResourceType.transform" % BASE,
return_value="flavor") return_value="flavor")
def test_create_one_image(self, mock_flavor_transform, def test_create_one_image(
mock_image_transform, mock_osclients, self, mock_flavor_resource_type_transform,
mock_vmtasks): mock_image_resource_type_transform, mock_clients, mock_vm_tasks):
ip = {"ip": "foo_ip", "id": "foo_id", "is_floating": True} ip = {"ip": "foo_ip", "id": "foo_id", "is_floating": True}
fake_server = mock.Mock() fake_server = mock.Mock()
fake_image = mock.MagicMock( fake_image = mock.MagicMock(
to_dict=mock.MagicMock(return_value={"id": "image"})) to_dict=mock.MagicMock(return_value={"id": "image"}))
mock_vm_scenario = mock_vmtasks.return_value = mock.MagicMock( mock_vm_scenario = mock_vm_tasks.return_value = mock.MagicMock(
_create_image=mock.MagicMock(return_value=fake_image), _create_image=mock.MagicMock(return_value=fake_image),
_boot_server_with_fip=mock.MagicMock( _boot_server_with_fip=mock.MagicMock(
return_value=(fake_server, ip)), return_value=(fake_server, ip)),
@ -96,14 +96,14 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
custom_image = generator_ctx.create_one_image(user, custom_image = generator_ctx.create_one_image(user,
foo_arg="foo_value") foo_arg="foo_value")
mock_flavor_transform.assert_called_once_with( mock_flavor_resource_type_transform.assert_called_once_with(
clients=mock_osclients.return_value, clients=mock_clients.return_value,
resource_config={"name": "flavor"}) resource_config={"name": "flavor"})
mock_image_transform.assert_called_once_with( mock_image_resource_type_transform.assert_called_once_with(
clients=mock_osclients.return_value, clients=mock_clients.return_value,
resource_config={"name": "image"}) resource_config={"name": "image"})
mock_vmtasks.assert_called_once_with( mock_vm_tasks.assert_called_once_with(
self.context, clients=mock_osclients.return_value) self.context, clients=mock_clients.return_value)
mock_vm_scenario._boot_server_with_fip.assert_called_once_with( mock_vm_scenario._boot_server_with_fip.assert_called_once_with(
image="image", flavor="flavor", image="image", flavor="flavor",
@ -124,16 +124,16 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
self.assertEqual({"id": "image"}, custom_image) self.assertEqual({"id": "image"}, custom_image)
@mock.patch("%s.osclients.Clients" % BASE) @mock.patch("%s.osclients.Clients" % BASE)
def test_make_image_public(self, mock_osclients): def test_make_image_public(self, mock_clients):
fc = mock.MagicMock() fc = mock.MagicMock()
mock_osclients.return_value = fc mock_clients.return_value = fc
generator_ctx = TestImageGenerator(self.context) generator_ctx = TestImageGenerator(self.context)
custom_image = {"id": "image"} custom_image = {"id": "image"}
generator_ctx.make_image_public(custom_image=custom_image) generator_ctx.make_image_public(custom_image=custom_image)
mock_osclients.assert_called_once_with( mock_clients.assert_called_once_with(
self.context["admin"]["endpoint"]) self.context["admin"]["endpoint"])
fc.glance.assert_called_once_with() fc.glance.assert_called_once_with()
@ -143,7 +143,7 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
@mock.patch("%s.nova_utils.NovaScenario" % BASE) @mock.patch("%s.nova_utils.NovaScenario" % BASE)
@mock.patch("%s.osclients.Clients" % BASE) @mock.patch("%s.osclients.Clients" % BASE)
def test_delete_one_image(self, mock_osclients, mock_nova_scenario): def test_delete_one_image(self, mock_clients, mock_nova_scenario):
nova_scenario = mock_nova_scenario.return_value = mock.MagicMock() nova_scenario = mock_nova_scenario.return_value = mock.MagicMock()
nova_client = nova_scenario.clients.return_value nova_client = nova_scenario.clients.return_value
nova_client.images.get.return_value = "image_obj" nova_client.images.get.return_value = "image_obj"
@ -156,7 +156,7 @@ class BaseCustomImageContextVMTestCase(test.TestCase):
generator_ctx.delete_one_image(user, custom_image) generator_ctx.delete_one_image(user, custom_image)
mock_nova_scenario.assert_called_once_with( mock_nova_scenario.assert_called_once_with(
context=self.context, clients=mock_osclients.return_value) context=self.context, clients=mock_clients.return_value)
nova_scenario.clients.assert_called_once_with("nova") nova_scenario.clients.assert_called_once_with("nova")
nova_client.images.get.assert_called_once_with("image") nova_client.images.get.assert_called_once_with("image")

98
tests/unit/plugins/openstack/scenarios/designate/test_basic.py
View File

@ -27,119 +27,131 @@ class DesignateBasicTestCase(test.TestCase):
@mock.patch(DESIGNATE_BASIC + "._list_domains") @mock.patch(DESIGNATE_BASIC + "._list_domains")
@mock.patch(DESIGNATE_BASIC + "._create_domain") @mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_list_domains(self, mock_create, mock_list): def test_create_and_list_domains(self, mock_designate_basic__create_domain,
mock_designate_basic__list_domains):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
# Default options # Default options
scenario.create_and_list_domains() scenario.create_and_list_domains()
mock_create.assert_called_once_with() mock_designate_basic__create_domain.assert_called_once_with()
mock_list.assert_called_once_with() mock_designate_basic__list_domains.assert_called_once_with()
@mock.patch(DESIGNATE_BASIC + "._delete_domain") @mock.patch(DESIGNATE_BASIC + "._delete_domain")
@mock.patch(DESIGNATE_BASIC + "._create_domain") @mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_delete_domain(self, mock_create, mock_delete): def test_create_and_delete_domain(
self, mock_designate_basic__create_domain,
mock_designate_basic__delete_domain):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
mock_create.return_value = {"id": "123"} mock_designate_basic__create_domain.return_value = {"id": "123"}
# Default options # Default options
scenario.create_and_delete_domain() scenario.create_and_delete_domain()
mock_create.assert_called_once_with() mock_designate_basic__create_domain.assert_called_once_with()
mock_delete.assert_called_once_with("123") mock_designate_basic__delete_domain.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._list_domains") @mock.patch(DESIGNATE_BASIC + "._list_domains")
def test_list_domains(self, mock_list): def test_list_domains(self, mock_designate_basic__list_domains):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
# Default options # Default options
scenario.list_domains() scenario.list_domains()
mock_list.assert_called_once_with() mock_designate_basic__list_domains.assert_called_once_with()
@mock.patch(DESIGNATE_BASIC + "._list_records") @mock.patch(DESIGNATE_BASIC + "._list_records")
@mock.patch(DESIGNATE_BASIC + "._create_record") @mock.patch(DESIGNATE_BASIC + "._create_record")
@mock.patch(DESIGNATE_BASIC + "._create_domain") @mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_list_records(self, def test_create_and_list_records(
mock_create_domain, self, mock_designate_basic__create_domain,
mock_create_record, mock_designate_basic__create_record,
mock_list): mock_designate_basic__list_records):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
domain = { domain = {
"name": "zone.name", "name": "zone.name",
"email": "email@zone.name", "email": "email@zone.name",
"id": "123"} "id": "123"}
mock_create_domain.return_value = domain mock_designate_basic__create_domain.return_value = domain
records_per_domain = 5 records_per_domain = 5
scenario.create_and_list_records( scenario.create_and_list_records(
records_per_domain=records_per_domain) records_per_domain=records_per_domain)
mock_create_domain.assert_called_once_with() mock_designate_basic__create_domain.assert_called_once_with()
self.assertEqual(mock_create_record.mock_calls, self.assertEqual(
[mock.call(domain, atomic_action=False)] mock_designate_basic__create_record.mock_calls,
* records_per_domain) [mock.call(domain, atomic_action=False)]
mock_list.assert_called_once_with(domain["id"]) * records_per_domain)
mock_designate_basic__list_records.assert_called_once_with(
domain["id"])
@mock.patch(DESIGNATE_BASIC + "._delete_record") @mock.patch(DESIGNATE_BASIC + "._delete_record")
@mock.patch(DESIGNATE_BASIC + "._create_record") @mock.patch(DESIGNATE_BASIC + "._create_record")
@mock.patch(DESIGNATE_BASIC + "._create_domain") @mock.patch(DESIGNATE_BASIC + "._create_domain")
def test_create_and_delete_records(self, def test_create_and_delete_records(
mock_create_domain, self, mock_designate_basic__create_domain,
mock_create_record, mock_designate_basic__create_record,
mock_delete): mock_designate_basic__delete_record):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
domain = { domain = {
"name": "zone.name", "name": "zone.name",
"email": "email@zone.name", "email": "email@zone.name",
"id": "123"} "id": "123"}
mock_create_domain.return_value = domain mock_designate_basic__create_domain.return_value = domain
mock_create_record.return_value = {"id": "321"} mock_designate_basic__create_record.return_value = {"id": "321"}
records_per_domain = 5 records_per_domain = 5
scenario.create_and_delete_records( scenario.create_and_delete_records(
records_per_domain=records_per_domain) records_per_domain=records_per_domain)
mock_create_domain.assert_called_once_with() mock_designate_basic__create_domain.assert_called_once_with()
self.assertEqual(mock_create_record.mock_calls, self.assertEqual(
[mock.call(domain, atomic_action=False)] mock_designate_basic__create_record.mock_calls,
* records_per_domain) [mock.call(domain, atomic_action=False)]
self.assertEqual(mock_delete.mock_calls, * records_per_domain)
[mock.call(domain["id"], "321", atomic_action=False)] self.assertEqual(
* records_per_domain) mock_designate_basic__delete_record.mock_calls,
[mock.call(domain["id"], "321", atomic_action=False)]
* records_per_domain)
@mock.patch(DESIGNATE_BASIC + "._list_records") @mock.patch(DESIGNATE_BASIC + "._list_records")
def test_list_records(self, mock_list): def test_list_records(self, mock_designate_basic__list_records):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
# Default options # Default options
scenario.list_records("123") scenario.list_records("123")
mock_list.assert_called_once_with("123") mock_designate_basic__list_records.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._list_servers") @mock.patch(DESIGNATE_BASIC + "._list_servers")
@mock.patch(DESIGNATE_BASIC + "._create_server") @mock.patch(DESIGNATE_BASIC + "._create_server")
def test_create_and_list_servers(self, mock_create, mock_list): def test_create_and_list_servers(
self, mock_designate_basic__create_server,
mock_designate_basic__list_servers):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
# Default options # Default options
scenario.create_and_list_servers() scenario.create_and_list_servers()
mock_create.assert_called_once_with() mock_designate_basic__create_server.assert_called_once_with()
mock_list.assert_called_once_with() mock_designate_basic__list_servers.assert_called_once_with()
@mock.patch(DESIGNATE_BASIC + "._delete_server") @mock.patch(DESIGNATE_BASIC + "._delete_server")
@mock.patch(DESIGNATE_BASIC + "._create_server") @mock.patch(DESIGNATE_BASIC + "._create_server")
def test_create_and_delete_server(self, mock_create, mock_delete): def test_create_and_delete_server(
self, mock_designate_basic__create_server,
mock_designate_basic__delete_server):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
mock_create.return_value = {"id": "123"} mock_designate_basic__create_server.return_value = {"id": "123"}
# Default options # Default options
scenario.create_and_delete_server() scenario.create_and_delete_server()
mock_create.assert_called_once_with() mock_designate_basic__create_server.assert_called_once_with()
mock_delete.assert_called_once_with("123") mock_designate_basic__delete_server.assert_called_once_with("123")
@mock.patch(DESIGNATE_BASIC + "._list_servers") @mock.patch(DESIGNATE_BASIC + "._list_servers")
def test_list_servers(self, mock_list): def test_list_servers(self, mock_designate_basic__list_servers):
scenario = basic.DesignateBasic() scenario = basic.DesignateBasic()
# Default options # Default options
scenario.list_servers() scenario.list_servers()
mock_list.assert_called_once_with() mock_designate_basic__list_servers.assert_called_once_with()

18
tests/unit/plugins/openstack/scenarios/designate/test_utils.py
View File

@ -29,15 +29,15 @@ class DesignateScenarioTestCase(test.ClientsTestCase):
self.domain = mock.Mock() self.domain = mock.Mock()
self.server = mock.Mock() self.server = mock.Mock()
@mock.patch(DESIGNATE_UTILS + "DesignateScenario._generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_domain(self, mock_random_name): def test_create_domain(self, mock_generate_random_name):
scenario = utils.DesignateScenario() scenario = utils.DesignateScenario()
random_name = "foo" random_name = "foo"
explicit_name = "bar.io." explicit_name = "bar.io."
email = "root@zone.name" email = "root@zone.name"
mock_random_name.return_value = random_name mock_generate_random_name.return_value = random_name
self.clients("designate").domains.create.return_value = self.domain self.clients("designate").domains.create.return_value = self.domain
# Check that the defaults / randoms are used if nothing is specified # Check that the defaults / randoms are used if nothing is specified
@ -72,15 +72,15 @@ class DesignateScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"designate.delete_domain") "designate.delete_domain")
@mock.patch(DESIGNATE_UTILS + "DesignateScenario._generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_record(self, mock_random_name): def test_create_record(self, mock_generate_random_name):
scenario = utils.DesignateScenario() scenario = utils.DesignateScenario()
random_name = "foo" random_name = "foo"
domain_name = "zone.name." domain_name = "zone.name."
random_record_name = "%s.%s" % (random_name, domain_name) random_record_name = "%s.%s" % (random_name, domain_name)
mock_random_name.return_value = random_name mock_generate_random_name.return_value = random_name
domain = {"name": domain_name, "id": "123"} domain = {"name": domain_name, "id": "123"}
@ -125,14 +125,14 @@ class DesignateScenarioTestCase(test.ClientsTestCase):
self.clients("designate").records.delete.assert_called_once_with( self.clients("designate").records.delete.assert_called_once_with(
domain_id, record_id) domain_id, record_id)
@mock.patch(DESIGNATE_UTILS + "DesignateScenario._generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_server(self, mock_random_name): def test_create_server(self, mock_generate_random_name):
scenario = utils.DesignateScenario() scenario = utils.DesignateScenario()
random_name = "foo" random_name = "foo"
explicit_name = "bar.io." explicit_name = "bar.io."
mock_random_name.return_value = random_name mock_generate_random_name.return_value = random_name
self.admin_clients( self.admin_clients(
"designate").servers.create.return_value = self.server "designate").servers.create.return_value = self.server

11
tests/unit/plugins/openstack/scenarios/ec2/test_servers.py
View File

@ -28,7 +28,8 @@ class EC2ServersTestCase(test.ClientsTestCase):
@mock.patch(UTILS + "ec2_resource_is", return_value="foo_state") @mock.patch(UTILS + "ec2_resource_is", return_value="foo_state")
@mock.patch(UTILS + "time") @mock.patch(UTILS + "time")
@mock.patch(UTILS + "CONF") @mock.patch(UTILS + "CONF")
def test_boot_server(self, mock_conf, mock_time, mock_is, mock_wait): def test_boot_server(self, mock_conf, mock_time, mock_ec2_resource_is,
mock_wait_for):
mock_conf.benchmark.ec2_server_boot_prepoll_delay = "foo_delay" mock_conf.benchmark.ec2_server_boot_prepoll_delay = "foo_delay"
mock_conf.benchmark.ec2_server_boot_timeout = "foo_timeout" mock_conf.benchmark.ec2_server_boot_timeout = "foo_timeout"
mock_conf.benchmark.ec2_server_boot_poll_interval = "foo_interval" mock_conf.benchmark.ec2_server_boot_poll_interval = "foo_interval"
@ -39,9 +40,9 @@ class EC2ServersTestCase(test.ClientsTestCase):
self.clients("ec2").run_instances.return_value = mock_instances self.clients("ec2").run_instances.return_value = mock_instances
server = scenario._boot_server("foo_image", "foo_flavor", foo="bar") server = scenario._boot_server("foo_image", "foo_flavor", foo="bar")
mock_wait.assert_called_once_with("foo_inst", is_ready="foo_state", mock_wait_for.assert_called_once_with("foo_inst", is_ready="foo_state",
update_resource="foo_update", update_resource="foo_update",
timeout="foo_timeout", timeout="foo_timeout",
check_interval="foo_interval") check_interval="foo_interval")
mock_time.sleep.assert_called_once_with("foo_delay") mock_time.sleep.assert_called_once_with("foo_delay")
self.assertEqual(server, "running_server") self.assertEqual(server, "running_server")

49
tests/unit/plugins/openstack/scenarios/glance/test_images.py
View File

@ -27,55 +27,56 @@ class GlanceImagesTestCase(test.TestCase):
@mock.patch(GLANCE_IMAGES + "._generate_random_name") @mock.patch(GLANCE_IMAGES + "._generate_random_name")
@mock.patch(GLANCE_IMAGES + "._list_images") @mock.patch(GLANCE_IMAGES + "._list_images")
@mock.patch(GLANCE_IMAGES + "._create_image") @mock.patch(GLANCE_IMAGES + "._create_image")
def test_create_and_list_image(self, mock_create, mock_list, def test_create_and_list_image(self, mock__create_image,
mock_random_name): mock__list_images,
mock__generate_random_name):
glance_scenario = images.GlanceImages() glance_scenario = images.GlanceImages()
mock_random_name.return_value = "test-rally-image" mock__generate_random_name.return_value = "test-rally-image"
glance_scenario.create_and_list_image("cf", "url", "df", glance_scenario.create_and_list_image("cf", "url", "df",
fakearg="f") fakearg="f")
mock_create.assert_called_once_with("cf", "url", "df", mock__create_image.assert_called_once_with(
fakearg="f") "cf", "url", "df", fakearg="f")
mock_list.assert_called_once_with() mock__list_images.assert_called_once_with()
@mock.patch(GLANCE_IMAGES + "._list_images") @mock.patch(GLANCE_IMAGES + "._list_images")
def test_list_images(self, mock_list): def test_list_images(self, mock__list_images):
glance_scenario = images.GlanceImages() glance_scenario = images.GlanceImages()
glance_scenario.list_images() glance_scenario.list_images()
mock_list.assert_called_once_with() mock__list_images.assert_called_once_with()
@mock.patch(GLANCE_IMAGES + "._generate_random_name") @mock.patch(GLANCE_IMAGES + "._generate_random_name")
@mock.patch(GLANCE_IMAGES + "._delete_image") @mock.patch(GLANCE_IMAGES + "._delete_image")
@mock.patch(GLANCE_IMAGES + "._create_image") @mock.patch(GLANCE_IMAGES + "._create_image")
def test_create_and_delete_image(self, mock_create, mock_delete, def test_create_and_delete_image(
mock_random_name): self, mock__create_image, mock__delete_image,
mock__generate_random_name):
glance_scenario = images.GlanceImages() glance_scenario = images.GlanceImages()
fake_image = object() fake_image = object()
mock_create.return_value = fake_image mock__create_image.return_value = fake_image
mock_random_name.return_value = "test-rally-image" mock__generate_random_name.return_value = "test-rally-image"
glance_scenario.create_and_delete_image("cf", "url", "df", glance_scenario.create_and_delete_image("cf", "url", "df",
fakearg="f") fakearg="f")
mock_create.assert_called_once_with("cf", mock__create_image.assert_called_once_with(
"url", "df", fakearg="f") "cf", "url", "df", fakearg="f")
mock_delete.assert_called_once_with(fake_image) mock__delete_image.assert_called_once_with(fake_image)
@mock.patch(GLANCE_IMAGES + "._boot_servers") @mock.patch(GLANCE_IMAGES + "._boot_servers")
@mock.patch(GLANCE_IMAGES + "._create_image") @mock.patch(GLANCE_IMAGES + "._create_image")
def test_create_image_and_boot_instances(self, def test_create_image_and_boot_instances(
mock_create_image, self, mock__create_image, mock__boot_servers):
mock_boot_servers):
glance_scenario = images.GlanceImages() glance_scenario = images.GlanceImages()
fake_image = fakes.FakeImage() fake_image = fakes.FakeImage()
fake_servers = [mock.Mock() for i in range(5)] fake_servers = [mock.Mock() for i in range(5)]
mock_create_image.return_value = fake_image mock__create_image.return_value = fake_image
mock_boot_servers.return_value = fake_servers mock__boot_servers.return_value = fake_servers
kwargs = {"fakearg": "f"} kwargs = {"fakearg": "f"}
with mock.patch("rally.plugins.openstack.scenarios." with mock.patch("rally.plugins.openstack.scenarios."
"glance.utils.time.sleep"): "glance.utils.time.sleep"):
glance_scenario.create_image_and_boot_instances("cf", "url", glance_scenario.create_image_and_boot_instances("cf", "url",
"df", "fid", "df", "fid",
5, **kwargs) 5, **kwargs)
mock_create_image.assert_called_once_with("cf", mock__create_image.assert_called_once_with(
"url", "df") "cf", "url", "df")
mock_boot_servers.assert_called_once_with("image-id-0", mock__boot_servers.assert_called_once_with(
"fid", 5, **kwargs) "image-id-0", "fid", 5, **kwargs)

122
tests/unit/plugins/openstack/scenarios/heat/test_stacks.py
View File

@ -33,26 +33,25 @@ class HeatStacksTestCase(test.ClientsTestCase):
@mock.patch(HEAT_STACKS + "._generate_random_name") @mock.patch(HEAT_STACKS + "._generate_random_name")
@mock.patch(HEAT_STACKS + "._list_stacks") @mock.patch(HEAT_STACKS + "._list_stacks")
@mock.patch(HEAT_STACKS + "._create_stack") @mock.patch(HEAT_STACKS + "._create_stack")
def test_create_and_list_stack(self, mock_create, mock_list, def test_create_and_list_stack(self, mock__create_stack, mock__list_stacks,
mock_random_name): mock__generate_random_name):
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
mock_random_name.return_value = "test-rally-stack" mock__generate_random_name.return_value = "test-rally-stack"
heat_scenario.create_and_list_stack( heat_scenario.create_and_list_stack(
template_path=self.default_template, template_path=self.default_template,
parameters=self.default_parameters, parameters=self.default_parameters,
files=self.default_files, files=self.default_files,
environment=self.default_environment environment=self.default_environment
) )
mock_create.assert_called_once_with(self.default_template, mock__create_stack.assert_called_once_with(
self.default_parameters, self.default_template, self.default_parameters, self.default_files,
self.default_files, self.default_environment)
self.default_environment) mock__list_stacks.assert_called_once_with()
mock_list.assert_called_once_with()
@mock.patch(HEAT_STACKS + "._list_stacks") @mock.patch(HEAT_STACKS + "._list_stacks")
def test_list_stack_and_resources(self, mock_list_stack): def test_list_stack_and_resources(self, mock__list_stacks):
stack = mock.Mock() stack = mock.Mock()
mock_list_stack.return_value = [stack] mock__list_stacks.return_value = [stack]
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
heat_scenario.list_stacks_and_resources() heat_scenario.list_stacks_and_resources()
self.clients("heat").resources.list.assert_called_once_with(stack.id) self.clients("heat").resources.list.assert_called_once_with(stack.id)
@ -60,9 +59,9 @@ class HeatStacksTestCase(test.ClientsTestCase):
heat_scenario.atomic_actions(), "heat.list_resources_of_1_stacks") heat_scenario.atomic_actions(), "heat.list_resources_of_1_stacks")
@mock.patch(HEAT_STACKS + "._list_stacks") @mock.patch(HEAT_STACKS + "._list_stacks")
def test_list_stack_and_events(self, mock_list_stack): def test_list_stack_and_events(self, mock__list_stacks):
stack = mock.Mock() stack = mock.Mock()
mock_list_stack.return_value = [stack] mock__list_stacks.return_value = [stack]
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
heat_scenario.list_stacks_and_events() heat_scenario.list_stacks_and_events()
self.clients("heat").events.list.assert_called_once_with(stack.id) self.clients("heat").events.list.assert_called_once_with(stack.id)
@ -72,12 +71,13 @@ class HeatStacksTestCase(test.ClientsTestCase):
@mock.patch(HEAT_STACKS + "._generate_random_name") @mock.patch(HEAT_STACKS + "._generate_random_name")
@mock.patch(HEAT_STACKS + "._delete_stack") @mock.patch(HEAT_STACKS + "._delete_stack")
@mock.patch(HEAT_STACKS + "._create_stack") @mock.patch(HEAT_STACKS + "._create_stack")
def test_create_and_delete_stack(self, mock_create, mock_delete, def test_create_and_delete_stack(
mock_random_name): self, mock__create_stack, mock__delete_stack,
mock__generate_random_name):
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
fake_stack = object() fake_stack = object()
mock_create.return_value = fake_stack mock__create_stack.return_value = fake_stack
mock_random_name.return_value = "test-rally-stack" mock__generate_random_name.return_value = "test-rally-stack"
heat_scenario.create_and_delete_stack( heat_scenario.create_and_delete_stack(
template_path=self.default_template, template_path=self.default_template,
parameters=self.default_parameters, parameters=self.default_parameters,
@ -85,42 +85,44 @@ class HeatStacksTestCase(test.ClientsTestCase):
environment=self.default_environment environment=self.default_environment
) )
mock_create.assert_called_once_with(self.default_template, mock__create_stack.assert_called_once_with(
self.default_parameters, self.default_template,
self.default_files, self.default_parameters,
self.default_environment) self.default_files,
mock_delete.assert_called_once_with(fake_stack) self.default_environment)
mock__delete_stack.assert_called_once_with(fake_stack)
@mock.patch(HEAT_STACKS + "._delete_stack") @mock.patch(HEAT_STACKS + "._delete_stack")
@mock.patch(HEAT_STACKS + "._check_stack") @mock.patch(HEAT_STACKS + "._check_stack")
@mock.patch(HEAT_STACKS + "._create_stack") @mock.patch(HEAT_STACKS + "._create_stack")
def test_create_check_delete_stack(self, mock_create, mock_check, def test_create_check_delete_stack(
mock_delete): self, mock__create_stack, mock__check_stack, mock__delete_stack):
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
mock_create.return_value = "fake_stack_create_check_delete"
heat_scenario.create_check_delete_stack( heat_scenario.create_check_delete_stack(
template_path=self.default_template, template_path=self.default_template,
parameters=self.default_parameters, parameters=self.default_parameters,
files=self.default_files, files=self.default_files,
environment=self.default_environment environment=self.default_environment
) )
mock_create.assert_called_once_with(self.default_template, mock__create_stack.assert_called_once_with(
self.default_parameters, self.default_template, self.default_parameters, self.default_files,
self.default_files, self.default_environment)
self.default_environment) mock__check_stack.assert_called_once_with(
mock_check.assert_called_once_with("fake_stack_create_check_delete") mock__create_stack.return_value)
mock_delete.assert_called_once_with("fake_stack_create_check_delete") mock__delete_stack.assert_called_once_with(
mock__create_stack.return_value)
@mock.patch(HEAT_STACKS + "._generate_random_name") @mock.patch(HEAT_STACKS + "._generate_random_name")
@mock.patch(HEAT_STACKS + "._delete_stack") @mock.patch(HEAT_STACKS + "._delete_stack")
@mock.patch(HEAT_STACKS + "._update_stack") @mock.patch(HEAT_STACKS + "._update_stack")
@mock.patch(HEAT_STACKS + "._create_stack") @mock.patch(HEAT_STACKS + "._create_stack")
def test_create_update_delete_stack(self, mock_create, mock_update, def test_create_update_delete_stack(
mock_delete, mock_random_name): self, mock__create_stack, mock__update_stack, mock__delete_stack,
mock__generate_random_name):
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
fake_stack = object() fake_stack = object()
mock_create.return_value = fake_stack mock__create_stack.return_value = fake_stack
mock_random_name.return_value = "test-rally-stack" mock__generate_random_name.return_value = "test-rally-stack"
heat_scenario.create_update_delete_stack( heat_scenario.create_update_delete_stack(
template_path=self.default_template, template_path=self.default_template,
parameters=self.default_parameters, parameters=self.default_parameters,
@ -129,27 +131,26 @@ class HeatStacksTestCase(test.ClientsTestCase):
environment=self.default_environment environment=self.default_environment
) )
mock_create.assert_called_once_with(self.default_template, mock__create_stack.assert_called_once_with(
self.default_parameters, self.default_template,
self.default_files, self.default_parameters,
self.default_environment) self.default_files,
mock_update.assert_called_once_with(fake_stack, self.default_template, self.default_environment)
self.default_parameters, mock__update_stack.assert_called_once_with(
self.default_files, fake_stack, self.default_template,
self.default_environment) self.default_parameters,
mock_delete.assert_called_once_with(fake_stack) self.default_files,
self.default_environment)
mock__delete_stack.assert_called_once_with(fake_stack)
@mock.patch(HEAT_STACKS + "._delete_stack") @mock.patch(HEAT_STACKS + "._delete_stack")
@mock.patch(HEAT_STACKS + "._resume_stack") @mock.patch(HEAT_STACKS + "._resume_stack")
@mock.patch(HEAT_STACKS + "._suspend_stack") @mock.patch(HEAT_STACKS + "._suspend_stack")
@mock.patch(HEAT_STACKS + "._create_stack") @mock.patch(HEAT_STACKS + "._create_stack")
def test_create_suspend_resume_delete_stack(self, def test_create_suspend_resume_delete_stack(
mock_create, self, mock__create_stack, mock__suspend_stack, mock__resume_stack,
mock_suspend, mock__delete_stack):
mock_resume,
mock_delete):
heat_scenario = stacks.HeatStacks() heat_scenario = stacks.HeatStacks()
mock_create.return_value = "fake_stack_create_suspend_resume_delete"
heat_scenario.create_suspend_resume_delete_stack( heat_scenario.create_suspend_resume_delete_stack(
template_path=self.default_template, template_path=self.default_template,
parameters=self.default_parameters, parameters=self.default_parameters,
@ -157,13 +158,16 @@ class HeatStacksTestCase(test.ClientsTestCase):
environment=self.default_environment environment=self.default_environment
) )
mock_create.assert_called_once_with(self.default_template, mock__create_stack.assert_called_once_with(
self.default_parameters, self.default_template,
self.default_files, self.default_parameters,
self.default_environment) self.default_files,
mock_suspend.assert_called_once_with( self.default_environment
"fake_stack_create_suspend_resume_delete") )
mock_resume.assert_called_once_with( mock__suspend_stack.assert_called_once_with(
"fake_stack_create_suspend_resume_delete") mock__create_stack.return_value)
mock_delete.assert_called_once_with( mock__resume_stack.assert_called_once_with(
"fake_stack_create_suspend_resume_delete") mock__create_stack.return_value)
mock__delete_stack.assert_called_once_with(
mock__create_stack.return_value
)

35
tests/unit/plugins/openstack/scenarios/keystone/test_basic.py
View File

@ -31,24 +31,22 @@ class KeystoneBasicTestCase(test.TestCase):
"tenant": {"id": "fake"} "tenant": {"id": "fake"}
} }
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_user(self, mock_gen_name): def test_create_user(self, mock_generate_random_name):
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeest"
scenario._user_create = mock.MagicMock() scenario._user_create = mock.MagicMock()
scenario.create_user(name_length=20, password="tttt", tenant_id="id") scenario.create_user(name_length=20, password="tttt", tenant_id="id")
scenario._user_create.assert_called_once_with(name_length=20, scenario._user_create.assert_called_once_with(name_length=20,
password="tttt", password="tttt",
tenant_id="id") tenant_id="id")
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_delete_user(self, mock_gen_name): def test_create_delete_user(self, mock_generate_random_name):
create_result = mock.MagicMock() create_result = mock.MagicMock()
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
scenario._user_create = mock.MagicMock(return_value=create_result) scenario._user_create = mock.MagicMock(return_value=create_result)
scenario._resource_delete = mock.MagicMock() scenario._resource_delete = mock.MagicMock()
mock_gen_name.return_value = "teeeest"
scenario.create_delete_user(name_length=30, email="abcd", enabled=True) scenario.create_delete_user(name_length=30, email="abcd", enabled=True)
@ -57,19 +55,17 @@ class KeystoneBasicTestCase(test.TestCase):
enabled=True) enabled=True)
scenario._resource_delete.assert_called_once_with(create_result) scenario._resource_delete.assert_called_once_with(create_result)
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_tenant(self, mock_gen_name): def test_create_tenant(self, mock_generate_random_name):
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeest"
scenario._tenant_create = mock.MagicMock() scenario._tenant_create = mock.MagicMock()
scenario.create_tenant(name_length=20, enabled=True) scenario.create_tenant(name_length=20, enabled=True)
scenario._tenant_create.assert_called_once_with(name_length=20, scenario._tenant_create.assert_called_once_with(name_length=20,
enabled=True) enabled=True)
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_tenant_with_users(self, mock_gen_name): def test_create_tenant_with_users(self, mock_generate_random_name):
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeest"
fake_tenant = mock.MagicMock() fake_tenant = mock.MagicMock()
scenario._tenant_create = mock.MagicMock(return_value=fake_tenant) scenario._tenant_create = mock.MagicMock(return_value=fake_tenant)
scenario._users_create = mock.MagicMock() scenario._users_create = mock.MagicMock()
@ -81,10 +77,9 @@ class KeystoneBasicTestCase(test.TestCase):
users_per_tenant=1, users_per_tenant=1,
name_length=20) name_length=20)
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_and_list_users(self, mock_gen_name): def test_create_and_list_users(self, mock_generate_random_name):
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeest"
scenario._user_create = mock.MagicMock() scenario._user_create = mock.MagicMock()
scenario._list_users = mock.MagicMock() scenario._list_users = mock.MagicMock()
scenario.create_and_list_users(name_length=20, password="tttt", scenario.create_and_list_users(name_length=20, password="tttt",
@ -94,10 +89,9 @@ class KeystoneBasicTestCase(test.TestCase):
tenant_id="id") tenant_id="id")
scenario._list_users.assert_called_once_with() scenario._list_users.assert_called_once_with()
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_and_list_tenants(self, mock_gen_name): def test_create_and_list_tenants(self, mock_generate_random_name):
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeest"
scenario._tenant_create = mock.MagicMock() scenario._tenant_create = mock.MagicMock()
scenario._list_tenants = mock.MagicMock() scenario._list_tenants = mock.MagicMock()
scenario.create_and_list_tenants(name_length=20, enabled=True) scenario.create_and_list_tenants(name_length=20, enabled=True)
@ -152,10 +146,9 @@ class KeystoneBasicTestCase(test.TestCase):
scenario._list_roles_for_user.assert_called_once_with(fake_user, scenario._list_roles_for_user.assert_called_once_with(fake_user,
fake_tenant) fake_tenant)
@mock.patch(BASIC + "_generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_get_entities(self, mock_gen_name): def test_get_entities(self, mock_generate_random_name):
scenario = basic.KeystoneBasic() scenario = basic.KeystoneBasic()
mock_gen_name.return_value = "teeeeest"
fake_tenant = mock.MagicMock() fake_tenant = mock.MagicMock()
fake_user = mock.MagicMock() fake_user = mock.MagicMock()
fake_role = mock.MagicMock() fake_role = mock.MagicMock()

34
tests/unit/plugins/openstack/scenarios/keystone/test_utils.py
View File

@ -48,31 +48,31 @@ class KeystoneUtilsTestCase(test.TestCase):
class KeystoneScenarioTestCase(test.ClientsTestCase): class KeystoneScenarioTestCase(test.ClientsTestCase):
@mock.patch(UTILS + "uuid.uuid4", return_value="pwd") @mock.patch(UTILS + "uuid.uuid4", return_value="pwd")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name", @mock.patch("rally.common.utils.generate_random_name",
return_value="abc") return_value="foobarov")
def test_user_create(self, mock_gen_name, mock_uuid4): def test_user_create(self, mock_generate_random_name, mock_uuid4):
scenario = utils.KeystoneScenario() scenario = utils.KeystoneScenario()
result = scenario._user_create() result = scenario._user_create()
self.assertEqual( self.assertEqual(
self.admin_clients("keystone").users.create.return_value, result) self.admin_clients("keystone").users.create.return_value, result)
self.admin_clients("keystone").users.create.assert_called_once_with( self.admin_clients("keystone").users.create.assert_called_once_with(
mock_gen_name.return_value, "foobarov",
password=mock_uuid4.return_value, password=mock_uuid4.return_value,
email=mock_gen_name.return_value + "@rally.me") email="foobarov@rally.me")
mock_uuid4.assert_called_with() mock_uuid4.assert_called_with()
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_user") "keystone.create_user")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_role_create(self, mock_gen_name): def test_role_create(self, mock_generate_random_name):
scenario = utils.KeystoneScenario() scenario = utils.KeystoneScenario()
result = scenario._role_create() result = scenario._role_create()
self.assertEqual( self.assertEqual(
self.admin_clients("keystone").roles.create.return_value, result) self.admin_clients("keystone").roles.create.return_value, result)
self.admin_clients("keystone").roles.create.assert_called_once_with( self.admin_clients("keystone").roles.create.assert_called_once_with(
mock_gen_name.return_value) mock_generate_random_name.return_value)
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_role") "keystone.create_role")
@ -129,21 +129,21 @@ class KeystoneScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.remove_role") "keystone.remove_role")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_tenant_create(self, mock_gen_name): def test_tenant_create(self, mock_generate_random_name):
scenario = utils.KeystoneScenario() scenario = utils.KeystoneScenario()
result = scenario._tenant_create() result = scenario._tenant_create()
self.assertEqual( self.assertEqual(
self.admin_clients("keystone").tenants.create.return_value, result) self.admin_clients("keystone").tenants.create.return_value, result)
self.admin_clients("keystone").tenants.create.assert_called_once_with( self.admin_clients("keystone").tenants.create.assert_called_once_with(
mock_gen_name.return_value) mock_generate_random_name.return_value)
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_tenant") "keystone.create_tenant")
def test_service_create(self): def test_service_create(self):
name = "abc" name = "abc"
service_type = name + "service_type" service_type = name + "_service_type"
description = name + "_description" description = name + "_description"
scenario = utils.KeystoneScenario() scenario = utils.KeystoneScenario()
@ -160,18 +160,16 @@ class KeystoneScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_service") "keystone.create_service")
@mock.patch(UTILS + "KeystoneScenario._generate_random_name") @mock.patch("rally.common.utils.generate_random_name",
def test_tenant_create_with_users(self, mock_gen_name): return_value="foobarov")
name = "abc" def test_tenant_create_with_users(self, mock_generate_random_name):
mock_gen_name.return_value = name
tenant = mock.MagicMock() tenant = mock.MagicMock()
scenario = utils.KeystoneScenario() scenario = utils.KeystoneScenario()
scenario._users_create(tenant, users_per_tenant=1, name_length=10) scenario._users_create(tenant, users_per_tenant=1, name_length=10)
self.admin_clients("keystone").users.create.assert_called_once_with( self.admin_clients("keystone").users.create.assert_called_once_with(
name, password=name, email=name + "@rally.me", "foobarov", password="foobarov", email="foobarov@rally.me",
tenant_id=tenant.id) tenant_id=tenant.id)
self._test_atomic_action_timer(scenario.atomic_actions(), self._test_atomic_action_timer(scenario.atomic_actions(),
"keystone.create_users") "keystone.create_users")

20
tests/unit/plugins/openstack/scenarios/mistral/test_workbooks.py
View File

@ -25,31 +25,33 @@ MISTRAL_WBS = ("rally.plugins.openstack.scenarios."
class MistralWorkbooksTestCase(test.TestCase): class MistralWorkbooksTestCase(test.TestCase):
@mock.patch(MISTRAL_WBS + "._list_workbooks") @mock.patch(MISTRAL_WBS + "._list_workbooks")
def test_list_workbooks(self, mock_list): def test_list_workbooks(self, mock__list_workbooks):
mistral_scenario = workbooks.MistralWorkbooks() mistral_scenario = workbooks.MistralWorkbooks()
mistral_scenario.list_workbooks() mistral_scenario.list_workbooks()
mock_list.assert_called_once_with() mock__list_workbooks.assert_called_once_with()
@mock.patch(MISTRAL_WBS + "._create_workbook") @mock.patch(MISTRAL_WBS + "._create_workbook")
def test_create_workbook(self, mock_create): def test_create_workbook(self, mock__create_workbook):
mistral_scenario = workbooks.MistralWorkbooks() mistral_scenario = workbooks.MistralWorkbooks()
definition = "---\nversion: \"2.0\"\nname: wb" definition = "---\nversion: \"2.0\"\nname: wb"
fake_wb = mock.MagicMock() fake_wb = mock.MagicMock()
fake_wb.name = "wb" fake_wb.name = "wb"
mock_create.return_value = fake_wb mock__create_workbook.return_value = fake_wb
mistral_scenario.create_workbook(definition) mistral_scenario.create_workbook(definition)
self.assertEqual(1, mock_create.called) self.assertEqual(1, mock__create_workbook.called)
@mock.patch(MISTRAL_WBS + "._delete_workbook") @mock.patch(MISTRAL_WBS + "._delete_workbook")
@mock.patch(MISTRAL_WBS + "._create_workbook") @mock.patch(MISTRAL_WBS + "._create_workbook")
def test_create_delete_workbook(self, mock_create, mock_delete): def test_create_delete_workbook(self,
mock__create_workbook,
mock__delete_workbook):
mistral_scenario = workbooks.MistralWorkbooks() mistral_scenario = workbooks.MistralWorkbooks()
definition = "---\nversion: \"2.0\"\nname: wb" definition = "---\nversion: \"2.0\"\nname: wb"
fake_wb = mock.MagicMock() fake_wb = mock.MagicMock()
fake_wb.name = "wb" fake_wb.name = "wb"
mock_create.return_value = fake_wb mock__create_workbook.return_value = fake_wb
mistral_scenario.create_workbook(definition, do_delete=True) mistral_scenario.create_workbook(definition, do_delete=True)
self.assertEqual(1, mock_create.called) self.assertEqual(1, mock__create_workbook.called)
mock_delete.assert_called_once_with(fake_wb.name) mock__delete_workbook.assert_called_once_with(fake_wb.name)

40
tests/unit/plugins/openstack/scenarios/murano/test_environments.py
View File

@ -44,40 +44,40 @@ class MuranoEnvironmentsTestCase(test.TestCase):
} }
@mock.patch(MURANO_SCENARIO + "._list_environments") @mock.patch(MURANO_SCENARIO + "._list_environments")
def test_list_environments(self, mock_list): def test_list_environments(self, mock__list_environments):
scenario = environments.MuranoEnvironments() scenario = environments.MuranoEnvironments()
scenario._list_environments() scenario._list_environments()
mock_list.assert_called_once_with() mock__list_environments.assert_called_once_with()
@mock.patch(MURANO_SCENARIO + "._create_session") @mock.patch(MURANO_SCENARIO + "._create_session")
@mock.patch(MURANO_SCENARIO + "._delete_environment") @mock.patch(MURANO_SCENARIO + "._delete_environment")
@mock.patch(MURANO_SCENARIO + "._create_environment") @mock.patch(MURANO_SCENARIO + "._create_environment")
@mock.patch(MURANO_SCENARIO + "._generate_random_name") @mock.patch(MURANO_SCENARIO + "._generate_random_name")
def test_create_and_delete_environment(self, mock_random_name, def test_create_and_delete_environment(
mock_create, mock_delete, self, mock__generate_random_name, mock__create_environment,
mock_session): mock__delete_environment, mock__create_session):
scenario = environments.MuranoEnvironments() scenario = environments.MuranoEnvironments()
fake_environment = mock.Mock(id="fake_id") fake_environment = mock.Mock(id="fake_id")
mock_create.return_value = fake_environment mock__create_environment.return_value = fake_environment
mock_random_name.return_value = "foo" mock__generate_random_name.return_value = "foo"
scenario.create_and_delete_environment() scenario.create_and_delete_environment()
mock_create.assert_called_once_with() mock__create_environment.assert_called_once_with()
mock_session.assert_called_once_with(fake_environment.id) mock__create_session.assert_called_once_with(fake_environment.id)
mock_delete.assert_called_once_with(fake_environment) mock__delete_environment.assert_called_once_with(fake_environment)
@mock.patch(MURANO_SCENARIO + "._create_environment") @mock.patch(MURANO_SCENARIO + "._create_environment")
@mock.patch(MURANO_SCENARIO + "._create_session") @mock.patch(MURANO_SCENARIO + "._create_session")
@mock.patch(MURANO_SCENARIO + "._create_service") @mock.patch(MURANO_SCENARIO + "._create_service")
@mock.patch(MURANO_SCENARIO + "._deploy_environment") @mock.patch(MURANO_SCENARIO + "._deploy_environment")
def test_create_and_deploy_environment(self, mock_deploy_env, def test_create_and_deploy_environment(
mock_create_service, mock_session, self, mock__deploy_environment, mock__create_service,
mock_environment): mock__create_session, mock__create_environment):
fake_environment = mock.MagicMock(id="fake_env_id") fake_environment = mock.MagicMock(id="fake_env_id")
mock_environment.return_value = fake_environment mock__create_environment.return_value = fake_environment
fake_session = mock.Mock(id="fake_session_id") fake_session = mock.Mock(id="fake_session_id")
mock_session.return_value = fake_session mock__create_session.return_value = fake_session
scenario = environments.MuranoEnvironments() scenario = environments.MuranoEnvironments()
scenario.context = self._get_context() scenario.context = self._get_context()
@ -89,9 +89,9 @@ class MuranoEnvironmentsTestCase(test.TestCase):
scenario.create_and_deploy_environment(1) scenario.create_and_deploy_environment(1)
mock_environment.assert_called_once_with() mock__create_environment.assert_called_once_with()
mock_session.assert_called_once_with(fake_environment.id) mock__create_session.assert_called_once_with(fake_environment.id)
mock_create_service.assert_called_once_with( mock__create_service.assert_called_once_with(
fake_environment, fake_session, "fake", atomic_action=False) fake_environment, fake_session, "fake", atomic_action=False)
mock_deploy_env.assert_called_once_with(fake_environment, mock__deploy_environment.assert_called_once_with(
fake_session) fake_environment, fake_session)

297
tests/unit/plugins/openstack/scenarios/neutron/test_network.py
View File

@ -26,25 +26,26 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_NETWORKS + "._list_networks") @mock.patch(NEUTRON_NETWORKS + "._list_networks")
@mock.patch(NEUTRON_NETWORKS + "._create_network") @mock.patch(NEUTRON_NETWORKS + "._create_network")
def test_create_and_list_networks(self, mock_create, mock_list): def test_create_and_list_networks(self, mock__create_network,
mock__list_networks):
neutron_scenario = network.NeutronNetworks() neutron_scenario = network.NeutronNetworks()
# Default options # Default options
network_create_args = {} network_create_args = {}
neutron_scenario.create_and_list_networks( neutron_scenario.create_and_list_networks(
network_create_args=network_create_args) network_create_args=network_create_args)
mock_create.assert_called_once_with(network_create_args) mock__create_network.assert_called_once_with(network_create_args)
mock_list.assert_called_once_with() mock__list_networks.assert_called_once_with()
mock_create.reset_mock() mock__create_network.reset_mock()
mock_list.reset_mock() mock__list_networks.reset_mock()
# Explicit network name is specified # Explicit network name is specified
network_create_args = {"name": "given-name"} network_create_args = {"name": "given-name"}
neutron_scenario.create_and_list_networks( neutron_scenario.create_and_list_networks(
network_create_args=network_create_args) network_create_args=network_create_args)
mock_create.assert_called_once_with(network_create_args) mock__create_network.assert_called_once_with(network_create_args)
mock_list.assert_called_once_with() mock__list_networks.assert_called_once_with()
@mock.patch(NEUTRON_NETWORKS + "._update_network") @mock.patch(NEUTRON_NETWORKS + "._update_network")
@mock.patch(NEUTRON_NETWORKS + "._create_network", return_value={ @mock.patch(NEUTRON_NETWORKS + "._create_network", return_value={
@ -55,8 +56,8 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
} }
}) })
def test_create_and_update_networks(self, def test_create_and_update_networks(self,
mock_create_network, mock__create_network,
mock_update_network): mock__update_network):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
network_update_args = {"name": "_updated", "admin_state_up": True} network_update_args = {"name": "_updated", "admin_state_up": True}
@ -65,13 +66,15 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
scenario.create_and_update_networks( scenario.create_and_update_networks(
network_update_args=network_update_args) network_update_args=network_update_args)
mock_create_network.assert_called_once_with({}) mock__create_network.assert_called_once_with({})
mock_update_network.assert_has_calls( mock__update_network.assert_has_calls(
[mock.call(mock_create_network.return_value, network_update_args)]) [mock.call(
mock__create_network.return_value, network_update_args
)])
mock_create_network.reset_mock() mock__create_network.reset_mock()
mock_update_network.reset_mock() mock__update_network.reset_mock()
# Explicit network name is specified # Explicit network name is specified
network_create_args = {"name": "network-name", "admin_state_up": False} network_create_args = {"name": "network-name", "admin_state_up": False}
@ -79,55 +82,54 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
scenario.create_and_update_networks( scenario.create_and_update_networks(
network_create_args=network_create_args, network_create_args=network_create_args,
network_update_args=network_update_args) network_update_args=network_update_args)
mock_create_network.assert_called_once_with(network_create_args) mock__create_network.assert_called_once_with(network_create_args)
mock_update_network.assert_has_calls( mock__update_network.assert_has_calls(
[mock.call(mock_create_network.return_value, network_update_args)]) [mock.call(mock__create_network.return_value,
network_update_args)])
@mock.patch(NEUTRON_NETWORKS + "._delete_network") @mock.patch(NEUTRON_NETWORKS + "._delete_network")
@mock.patch(NEUTRON_NETWORKS + "._create_network") @mock.patch(NEUTRON_NETWORKS + "._create_network")
def test_create_and_delete_networks(self, mock_create, mock_delete): def test_create_and_delete_networks(self, mock__create_network,
mock__delete_network):
neutron_scenario = network.NeutronNetworks() neutron_scenario = network.NeutronNetworks()
# Default options # Default options
network_create_args = {} network_create_args = {}
neutron_scenario.create_and_delete_networks() neutron_scenario.create_and_delete_networks()
mock_create.assert_called_once_with(network_create_args) mock__create_network.assert_called_once_with(network_create_args)
self.assertEqual(1, mock_delete.call_count) self.assertEqual(1, mock__delete_network.call_count)
mock_create.reset_mock() mock__create_network.reset_mock()
mock_delete.reset_mock() mock__delete_network.reset_mock()
# Explict network name is specified # Explict network name is specified
network_create_args = {"name": "given-name"} network_create_args = {"name": "given-name"}
neutron_scenario.create_and_delete_networks( neutron_scenario.create_and_delete_networks(
network_create_args=network_create_args) network_create_args=network_create_args)
mock_create.assert_called_once_with(network_create_args) mock__create_network.assert_called_once_with(network_create_args)
self.assertEqual(1, mock_delete.call_count) self.assertEqual(1, mock__delete_network.call_count)
@mock.patch(NEUTRON_NETWORKS + "._list_subnets") @mock.patch(NEUTRON_NETWORKS + "._list_subnets")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets") @mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
def test_create_and_list_subnets(self, def test_create_and_list_subnets(self,
mock_create_network_and_subnets, mock__create_network_and_subnets,
mock_list): mock__list_subnets):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
subnets_per_network = 4 subnets_per_network = 4
subnet_cidr_start = "default_cidr" subnet_cidr_start = "default_cidr"
mock_create_network_and_subnets.reset_mock()
mock_list.reset_mock()
# Default options # Default options
scenario.create_and_list_subnets( scenario.create_and_list_subnets(
subnets_per_network=subnets_per_network, subnets_per_network=subnets_per_network,
subnet_cidr_start=subnet_cidr_start) subnet_cidr_start=subnet_cidr_start)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {}, subnets_per_network, [mock.call({}, {}, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_list.assert_called_once_with() mock__list_subnets.assert_called_once_with()
mock_create_network_and_subnets.reset_mock() mock__create_network_and_subnets.reset_mock()
mock_list.reset_mock() mock__list_subnets.reset_mock()
# Custom options # Custom options
scenario.create_and_list_subnets( scenario.create_and_list_subnets(
@ -135,16 +137,16 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnet_cidr_start="custom_cidr", subnet_cidr_start="custom_cidr",
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {"allocation_pools": []}, [mock.call({}, {"allocation_pools": []},
subnets_per_network, "custom_cidr")]) subnets_per_network, "custom_cidr")])
mock_list.assert_called_once_with() mock__list_subnets.assert_called_once_with()
@mock.patch(NEUTRON_NETWORKS + "._update_subnet") @mock.patch(NEUTRON_NETWORKS + "._update_subnet")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets") @mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
def test_create_and_update_subnets(self, def test_create_and_update_subnets(self,
mock_create_network_and_subnets, mock__create_network_and_subnets,
mock_update_subnet): mock__update_subnet):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
subnets_per_network = 1 subnets_per_network = 1
subnet_cidr_start = "default_cidr" subnet_cidr_start = "default_cidr"
@ -160,25 +162,22 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
"enable_dhcp": False "enable_dhcp": False
} }
} }
mock_create_network_and_subnets.return_value = (net, [subnet]) mock__create_network_and_subnets.return_value = (net, [subnet])
subnet_update_args = {"name": "_updated", "enable_dhcp": True} subnet_update_args = {"name": "_updated", "enable_dhcp": True}
mock_create_network_and_subnets.reset_mock()
mock_update_subnet.reset_mock()
# Default options # Default options
scenario.create_and_update_subnets( scenario.create_and_update_subnets(
subnet_update_args=subnet_update_args, subnet_update_args=subnet_update_args,
subnet_cidr_start=subnet_cidr_start, subnet_cidr_start=subnet_cidr_start,
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {}, subnets_per_network, subnet_cidr_start)]) [mock.call({}, {}, subnets_per_network, subnet_cidr_start)])
mock_update_subnet.assert_has_calls( mock__update_subnet.assert_has_calls(
[mock.call(subnet, subnet_update_args)]) [mock.call(subnet, subnet_update_args)])
mock_create_network_and_subnets.reset_mock() mock__create_network_and_subnets.reset_mock()
mock_update_subnet.reset_mock() mock__update_subnet.reset_mock()
# Custom options # Custom options
subnet_cidr_start = "custom_cidr" subnet_cidr_start = "custom_cidr"
@ -188,17 +187,17 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnet_cidr_start=subnet_cidr_start, subnet_cidr_start=subnet_cidr_start,
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {"allocation_pools": []}, subnets_per_network, [mock.call({}, {"allocation_pools": []}, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_update_subnet.assert_has_calls( mock__update_subnet.assert_has_calls(
[mock.call(subnet, subnet_update_args)]) [mock.call(subnet, subnet_update_args)])
@mock.patch(NEUTRON_NETWORKS + "._delete_subnet") @mock.patch(NEUTRON_NETWORKS + "._delete_subnet")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets") @mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
def test_create_and_delete_subnets(self, def test_create_and_delete_subnets(self,
mock_create_network_and_subnets, mock__create_network_and_subnets,
mock_delete): mock__delete_subnet):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
net = { net = {
"network": { "network": {
@ -212,26 +211,23 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
"enable_dhcp": False "enable_dhcp": False
} }
} }
mock_create_network_and_subnets.return_value = (net, [subnet]) mock__create_network_and_subnets.return_value = (net, [subnet])
subnets_per_network = 1 subnets_per_network = 1
subnet_cidr_start = "default_cidr" subnet_cidr_start = "default_cidr"
mock_create_network_and_subnets.reset_mock()
mock_delete.reset_mock()
# Default options # Default options
scenario.create_and_delete_subnets( scenario.create_and_delete_subnets(
subnets_per_network=subnets_per_network, subnets_per_network=subnets_per_network,
subnet_cidr_start=subnet_cidr_start) subnet_cidr_start=subnet_cidr_start)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {}, subnets_per_network, [mock.call({}, {}, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_delete.assert_has_calls([mock.call(subnet)]) mock__delete_subnet.assert_has_calls([mock.call(subnet)])
mock_create_network_and_subnets.reset_mock() mock__create_network_and_subnets.reset_mock()
mock_delete.reset_mock() mock__delete_subnet.reset_mock()
# Custom options # Custom options
subnet_cidr_start = "custom_cidr" subnet_cidr_start = "custom_cidr"
@ -240,18 +236,18 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnet_cidr_start="custom_cidr", subnet_cidr_start="custom_cidr",
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {"allocation_pools": []}, subnets_per_network, [mock.call({}, {"allocation_pools": []}, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_delete.assert_has_calls([mock.call(subnet)]) mock__delete_subnet.assert_has_calls([mock.call(subnet)])
@mock.patch(NEUTRON_NETWORKS + "._list_routers") @mock.patch(NEUTRON_NETWORKS + "._list_routers")
@mock.patch(NEUTRON_NETWORKS + "._create_router") @mock.patch(NEUTRON_NETWORKS + "._create_router")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets") @mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
def test_create_and_list_routers(self, def test_create_and_list_routers(self,
mock_create_network_and_subnets, mock__create_network_and_subnets,
mock_create_router, mock__create_router,
mock_list): mock__list_routers):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
subnets_per_network = 1 subnets_per_network = 1
subnet_cidr_start = "default_cidr" subnet_cidr_start = "default_cidr"
@ -268,7 +264,7 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
"enable_dhcp": False "enable_dhcp": False
} }
} }
mock_create_network_and_subnets.return_value = (net, [subnet]) mock__create_network_and_subnets.return_value = (net, [subnet])
self.clients("neutron").add_interface_router = mock.Mock() self.clients("neutron").add_interface_router = mock.Mock()
router = { router = {
"router": { "router": {
@ -276,16 +272,16 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
"id": "router-id" "id": "router-id"
} }
} }
mock_create_router.return_value = router mock__create_router.return_value = router
# Default options # Default options
scenario.create_and_list_routers( scenario.create_and_list_routers(
subnet_cidr_start=subnet_cidr_start, subnet_cidr_start=subnet_cidr_start,
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {}, subnets_per_network, subnet_cidr_start)]) [mock.call({}, {}, subnets_per_network, subnet_cidr_start)])
mock_create_router.assert_has_calls( mock__create_router.assert_has_calls(
[mock.call({})] * subnets_per_network) [mock.call({})] * subnets_per_network)
self.clients("neutron").add_interface_router.assert_has_calls( self.clients("neutron").add_interface_router.assert_has_calls(
@ -293,11 +289,11 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
{"subnet_id": subnet["subnet"]["id"]}) {"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network) ] * subnets_per_network)
mock_create_network_and_subnets.reset_mock() mock__create_network_and_subnets.reset_mock()
mock_create_router.reset_mock() mock__create_router.reset_mock()
self.clients("neutron").add_interface_router.reset_mock() self.clients("neutron").add_interface_router.reset_mock()
mock_list.reset_mock() mock__list_routers.reset_mock()
# Custom options # Custom options
subnet_cidr_start = "custom_cidr" subnet_cidr_start = "custom_cidr"
@ -309,26 +305,26 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnets_per_network=subnets_per_network, subnets_per_network=subnets_per_network,
router_create_args=router_create_args) router_create_args=router_create_args)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, subnet_create_args, subnets_per_network, [mock.call({}, subnet_create_args, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_create_router.assert_has_calls( mock__create_router.assert_has_calls(
[mock.call(router_create_args)] * subnets_per_network) [mock.call(router_create_args)] * subnets_per_network)
self.clients("neutron").add_interface_router.assert_has_calls( self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"], [mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]}) {"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network) ] * subnets_per_network)
mock_list.assert_called_once_with() mock__list_routers.assert_called_once_with()
@mock.patch(NEUTRON_NETWORKS + "._update_router") @mock.patch(NEUTRON_NETWORKS + "._update_router")
@mock.patch(NEUTRON_NETWORKS + "._create_router") @mock.patch(NEUTRON_NETWORKS + "._create_router")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets") @mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
def test_create_and_update_routers(self, def test_create_and_update_routers(self,
mock_create_network_and_subnets, mock__create_network_and_subnets,
mock_create_router, mock__create_router,
mock_update_router): mock__update_router):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
subnets_per_network = 1 subnets_per_network = 1
subnet_cidr_start = "default_cidr" subnet_cidr_start = "default_cidr"
@ -355,8 +351,8 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
"name": "_updated", "name": "_updated",
"admin_state_up": False "admin_state_up": False
} }
mock_create_router.return_value = router mock__create_router.return_value = router
mock_create_network_and_subnets.return_value = (net, [subnet]) mock__create_network_and_subnets.return_value = (net, [subnet])
self.clients("neutron").add_interface_router = mock.Mock() self.clients("neutron").add_interface_router = mock.Mock()
# Default options # Default options
@ -365,24 +361,24 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnet_cidr_start=subnet_cidr_start, subnet_cidr_start=subnet_cidr_start,
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {}, subnets_per_network, subnet_cidr_start)]) [mock.call({}, {}, subnets_per_network, subnet_cidr_start)])
mock_create_router.assert_has_calls( mock__create_router.assert_has_calls(
[mock.call({})] * subnets_per_network) [mock.call({})] * subnets_per_network)
self.clients("neutron").add_interface_router.assert_has_calls( self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"], [mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]}) {"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network) ] * subnets_per_network)
mock_update_router.assert_has_calls( mock__update_router.assert_has_calls(
[mock.call(router, router_update_args) [mock.call(router, router_update_args)
] * subnets_per_network) ] * subnets_per_network)
mock_create_network_and_subnets.reset_mock() mock__create_network_and_subnets.reset_mock()
mock_create_router.reset_mock() mock__create_router.reset_mock()
self.clients("neutron").add_interface_router.reset_mock() self.clients("neutron").add_interface_router.reset_mock()
mock_update_router.reset_mock() mock__update_router.reset_mock()
# Custom options # Custom options
subnet_cidr_start = "custom_cidr" subnet_cidr_start = "custom_cidr"
@ -395,18 +391,18 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnets_per_network=subnets_per_network, subnets_per_network=subnets_per_network,
router_create_args=router_create_args) router_create_args=router_create_args)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, subnet_create_args, subnets_per_network, [mock.call({}, subnet_create_args, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_create_router.assert_has_calls( mock__create_router.assert_has_calls(
[mock.call(router_create_args)] * subnets_per_network) [mock.call(router_create_args)] * subnets_per_network)
self.clients("neutron").add_interface_router.assert_has_calls( self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"], [mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]}) {"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network) ] * subnets_per_network)
mock_update_router.assert_has_calls( mock__update_router.assert_has_calls(
[mock.call(router, router_update_args) [mock.call(router, router_update_args)
] * subnets_per_network) ] * subnets_per_network)
@ -414,9 +410,9 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_NETWORKS + "._create_router") @mock.patch(NEUTRON_NETWORKS + "._create_router")
@mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets") @mock.patch(NEUTRON_NETWORKS + "._create_network_and_subnets")
def test_create_and_delete_routers(self, def test_create_and_delete_routers(self,
mock_create_network_and_subnets, mock__create_network_and_subnets,
mock_create_router, mock__create_router,
mock_delete_router): mock__delete_router):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
subnets_per_network = 1 subnets_per_network = 1
subnet_cidr_start = "default_cidr" subnet_cidr_start = "default_cidr"
@ -440,8 +436,8 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
} }
} }
mock_create_router.return_value = router mock__create_router.return_value = router
mock_create_network_and_subnets.return_value = (net, [subnet]) mock__create_network_and_subnets.return_value = (net, [subnet])
self.clients("neutron").add_interface_router = mock.Mock() self.clients("neutron").add_interface_router = mock.Mock()
# Default options # Default options
@ -449,23 +445,23 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnet_cidr_start=subnet_cidr_start, subnet_cidr_start=subnet_cidr_start,
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, {}, subnets_per_network, subnet_cidr_start)]) [mock.call({}, {}, subnets_per_network, subnet_cidr_start)])
mock_create_router.assert_has_calls( mock__create_router.assert_has_calls(
[mock.call({})] * subnets_per_network) [mock.call({})] * subnets_per_network)
self.clients("neutron").add_interface_router.assert_has_calls( self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"], [mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]}) {"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network) ] * subnets_per_network)
mock_delete_router.assert_has_calls( mock__delete_router.assert_has_calls(
[mock.call(router)] * subnets_per_network) [mock.call(router)] * subnets_per_network)
mock_create_network_and_subnets.reset_mock() mock__create_network_and_subnets.reset_mock()
mock_create_router.reset_mock() mock__create_router.reset_mock()
self.clients("neutron").add_interface_router.reset_mock() self.clients("neutron").add_interface_router.reset_mock()
mock_delete_router.reset_mock() mock__delete_router.reset_mock()
# Custom options # Custom options
subnet_cidr_start = "custom_cidr" subnet_cidr_start = "custom_cidr"
@ -477,18 +473,18 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
subnets_per_network=subnets_per_network, subnets_per_network=subnets_per_network,
router_create_args=router_create_args) router_create_args=router_create_args)
mock_create_network_and_subnets.assert_has_calls( mock__create_network_and_subnets.assert_has_calls(
[mock.call({}, subnet_create_args, subnets_per_network, [mock.call({}, subnet_create_args, subnets_per_network,
subnet_cidr_start)]) subnet_cidr_start)])
mock_create_router.assert_has_calls( mock__create_router.assert_has_calls(
[mock.call(router_create_args)] * subnets_per_network) [mock.call(router_create_args)] * subnets_per_network)
self.clients("neutron").add_interface_router.assert_has_calls( self.clients("neutron").add_interface_router.assert_has_calls(
[mock.call(router["router"]["id"], [mock.call(router["router"]["id"],
{"subnet_id": subnet["subnet"]["id"]}) {"subnet_id": subnet["subnet"]["id"]})
] * subnets_per_network) ] * subnets_per_network)
mock_delete_router.assert_has_calls( mock__delete_router.assert_has_calls(
[mock.call(router)] * subnets_per_network) [mock.call(router)] * subnets_per_network)
@mock.patch(NEUTRON_NETWORKS + "._generate_random_name") @mock.patch(NEUTRON_NETWORKS + "._generate_random_name")
@ -496,41 +492,41 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_NETWORKS + "._create_port") @mock.patch(NEUTRON_NETWORKS + "._create_port")
@mock.patch(NEUTRON_NETWORKS + "._create_network") @mock.patch(NEUTRON_NETWORKS + "._create_network")
def test_create_and_list_ports(self, def test_create_and_list_ports(self,
mock_create_network, mock__create_network,
mock_create_port, mock__create_port,
mock_list, mock__list_ports,
mock_random_name): mock__generate_random_name):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
mock_random_name.return_value = "random-name" mock__generate_random_name.return_value = "random-name"
net = {"network": {"id": "fake-id"}} net = {"network": {"id": "fake-id"}}
mock_create_network.return_value = net mock__create_network.return_value = net
ports_per_network = 10 ports_per_network = 10
self.assertRaises(TypeError, scenario.create_and_list_ports) self.assertRaises(TypeError, scenario.create_and_list_ports)
mock_create_network.reset_mock() mock__create_network.reset_mock()
# Defaults # Defaults
scenario.create_and_list_ports(ports_per_network=ports_per_network) scenario.create_and_list_ports(ports_per_network=ports_per_network)
mock_create_network.assert_called_once_with({}) mock__create_network.assert_called_once_with({})
self.assertEqual(mock_create_port.mock_calls, self.assertEqual(mock__create_port.mock_calls,
[mock.call(net, {})] * ports_per_network) [mock.call(net, {})] * ports_per_network)
mock_list.assert_called_once_with() mock__list_ports.assert_called_once_with()
mock_create_network.reset_mock() mock__create_network.reset_mock()
mock_create_port.reset_mock() mock__create_port.reset_mock()
mock_list.reset_mock() mock__list_ports.reset_mock()
# Custom options # Custom options
scenario.create_and_list_ports( scenario.create_and_list_ports(
network_create_args={"name": "given-name"}, network_create_args={"name": "given-name"},
port_create_args={"allocation_pools": []}, port_create_args={"allocation_pools": []},
ports_per_network=ports_per_network) ports_per_network=ports_per_network)
mock_create_network.assert_called_once_with({"name": "given-name"}) mock__create_network.assert_called_once_with({"name": "given-name"})
self.assertEqual( self.assertEqual(
mock_create_port.mock_calls, mock__create_port.mock_calls,
[mock.call(net, {"allocation_pools": []})] * ports_per_network) [mock.call(net, {"allocation_pools": []})] * ports_per_network)
mock_list.assert_called_once_with() mock__list_ports.assert_called_once_with()
@mock.patch(NEUTRON_NETWORKS + "._generate_random_name") @mock.patch(NEUTRON_NETWORKS + "._generate_random_name")
@mock.patch(NEUTRON_NETWORKS + "._update_port") @mock.patch(NEUTRON_NETWORKS + "._update_port")
@ -544,12 +540,12 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_NETWORKS + "._create_network", return_value={ @mock.patch(NEUTRON_NETWORKS + "._create_network", return_value={
"network": {"id": "fake-id"}}) "network": {"id": "fake-id"}})
def test_create_and_update_ports(self, def test_create_and_update_ports(self,
mock_create_network, mock__create_network,
mock_create_port, mock__create_port,
mock_update_port, mock__update_port,
mock_random_name): mock__generate_random_name):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
mock_random_name.return_value = "random-name" mock__generate_random_name.return_value = "random-name"
ports_per_network = 10 ports_per_network = 10
port_update_args = { port_update_args = {
@ -561,18 +557,18 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
scenario.create_and_update_ports( scenario.create_and_update_ports(
port_update_args=port_update_args, port_update_args=port_update_args,
ports_per_network=ports_per_network) ports_per_network=ports_per_network)
mock_create_network.assert_called_once_with({}) mock__create_network.assert_called_once_with({})
mock_create_port.assert_has_calls( mock__create_port.assert_has_calls(
[mock.call({"network": {"id": "fake-id"}}, [mock.call({"network": {"id": "fake-id"}},
{})] * ports_per_network) {})] * ports_per_network)
mock_update_port.assert_has_calls( mock__update_port.assert_has_calls(
[mock.call(mock_create_port.return_value, port_update_args) [mock.call(mock__create_port.return_value, port_update_args)
] * ports_per_network) ] * ports_per_network)
mock_create_network.reset_mock() mock__create_network.reset_mock()
mock_create_port.reset_mock() mock__create_port.reset_mock()
mock_update_port.reset_mock() mock__update_port.reset_mock()
# Custom options # Custom options
scenario.create_and_update_ports( scenario.create_and_update_ports(
@ -580,12 +576,12 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
network_create_args={"name": "given-name"}, network_create_args={"name": "given-name"},
port_create_args={"allocation_pools": []}, port_create_args={"allocation_pools": []},
ports_per_network=ports_per_network) ports_per_network=ports_per_network)
mock_create_network.assert_called_once_with({"name": "given-name"}) mock__create_network.assert_called_once_with({"name": "given-name"})
mock_create_port.assert_has_calls( mock__create_port.assert_has_calls(
[mock.call({"network": {"id": "fake-id"}}, [mock.call({"network": {"id": "fake-id"}},
{"allocation_pools": []})] * ports_per_network) {"allocation_pools": []})] * ports_per_network)
mock_update_port.assert_has_calls( mock__update_port.assert_has_calls(
[mock.call(mock_create_port.return_value, port_update_args) [mock.call(mock__create_port.return_value, port_update_args)
] * ports_per_network) ] * ports_per_network)
@mock.patch(NEUTRON_NETWORKS + "._generate_random_name") @mock.patch(NEUTRON_NETWORKS + "._generate_random_name")
@ -593,40 +589,41 @@ class NeutronNetworksTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_NETWORKS + "._create_port") @mock.patch(NEUTRON_NETWORKS + "._create_port")
@mock.patch(NEUTRON_NETWORKS + "._create_network") @mock.patch(NEUTRON_NETWORKS + "._create_network")
def test_create_and_delete_ports(self, def test_create_and_delete_ports(self,
mock_create_network, mock__create_network,
mock_create_port, mock__create_port,
mock_delete, mock__delete_port,
mock_random_name): mock__generate_random_name):
scenario = network.NeutronNetworks() scenario = network.NeutronNetworks()
mock_random_name.return_value = "random-name" mock__generate_random_name.return_value = "random-name"
net = {"network": {"id": "fake-id"}} net = {"network": {"id": "fake-id"}}
mock_create_network.return_value = net mock__create_network.return_value = net
ports_per_network = 10 ports_per_network = 10
self.assertRaises(TypeError, scenario.create_and_delete_ports) self.assertRaises(TypeError, scenario.create_and_delete_ports)
mock_create_network.reset_mock() mock__create_network.reset_mock()
# Default options # Default options
scenario.create_and_delete_ports(ports_per_network=ports_per_network) scenario.create_and_delete_ports(ports_per_network=ports_per_network)
mock_create_network.assert_called_once_with({}) mock__create_network.assert_called_once_with({})
self.assertEqual(mock_create_port.mock_calls, self.assertEqual(mock__create_port.mock_calls,
[mock.call(net, {})] * ports_per_network) [mock.call(net, {})] * ports_per_network)
self.assertEqual(mock_delete.mock_calls, self.assertEqual(mock__delete_port.mock_calls,
[mock.call(mock_create_port())] * ports_per_network) [mock.call(mock__create_port())] * ports_per_network)
mock_create_network.reset_mock() mock__create_network.reset_mock()
mock_create_port.reset_mock() mock__create_port.reset_mock()
mock_delete.reset_mock() mock__delete_port.reset_mock()
# Custom options # Custom options
scenario.create_and_delete_ports( scenario.create_and_delete_ports(
network_create_args={"name": "given-name"}, network_create_args={"name": "given-name"},
port_create_args={"allocation_pools": []}, port_create_args={"allocation_pools": []},
ports_per_network=ports_per_network) ports_per_network=ports_per_network)
mock_create_network.assert_called_once_with({"name": "given-name"}) mock__create_network.assert_called_once_with({"name": "given-name"})
self.assertEqual( self.assertEqual(
mock_create_port.mock_calls, mock__create_port.mock_calls,
[mock.call(net, {"allocation_pools": []})] * ports_per_network) [mock.call(net, {"allocation_pools": []})] * ports_per_network)
self.assertEqual(mock_delete.mock_calls, self.assertEqual(
[mock.call(mock_create_port())] * ports_per_network) mock__delete_port.mock_calls,
[mock.call(mock__create_port.return_value)] * ports_per_network)

39
tests/unit/plugins/openstack/scenarios/neutron/test_utils.py
View File

@ -29,11 +29,11 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
self.network = mock.Mock() self.network = mock.Mock()
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name") @mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
def test_create_network(self, mock_random_name): def test_create_network(self, mock__generate_random_name):
neutron_scenario = utils.NeutronScenario() neutron_scenario = utils.NeutronScenario()
explicit_name = "explicit_name" explicit_name = "explicit_name"
random_name = "random_name" random_name = "random_name"
mock_random_name.return_value = random_name mock__generate_random_name.return_value = random_name
self.clients("neutron").create_network.return_value = self.network self.clients("neutron").create_network.return_value = self.network
# Network name is specified # Network name is specified
@ -96,7 +96,7 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name", @mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name",
return_value="test_subnet") return_value="test_subnet")
def test_create_subnet(self, mock_random_name): def test_create_subnet(self, mock__generate_random_name):
scenario = utils.NeutronScenario() scenario = utils.NeutronScenario()
network_id = "fake-id" network_id = "fake-id"
start_cidr = "192.168.0.0/24" start_cidr = "192.168.0.0/24"
@ -107,7 +107,7 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
"network_id": network_id, "network_id": network_id,
"cidr": start_cidr, "cidr": start_cidr,
"ip_version": scenario.SUBNET_IP_VERSION, "ip_version": scenario.SUBNET_IP_VERSION,
"name": mock_random_name.return_value "name": mock__generate_random_name.return_value
} }
} }
@ -171,12 +171,12 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
"neutron.delete_subnet") "neutron.delete_subnet")
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name") @mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
def test_create_router(self, mock_random_name): def test_create_router(self, mock__generate_random_name):
scenario = utils.NeutronScenario() scenario = utils.NeutronScenario()
router = mock.Mock() router = mock.Mock()
explicit_name = "explicit_name" explicit_name = "explicit_name"
random_name = "random_name" random_name = "random_name"
mock_random_name.return_value = random_name mock__generate_random_name.return_value = random_name
self.clients("neutron").create_router.return_value = router self.clients("neutron").create_router.return_value = router
# Default options # Default options
@ -257,13 +257,13 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
self.assertEqual(utils.NeutronScenario.SUBNET_IP_VERSION, 4) self.assertEqual(utils.NeutronScenario.SUBNET_IP_VERSION, 4)
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name") @mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
def test_create_port(self, mock_rand_name): def test_create_port(self, mock__generate_random_name):
scenario = utils.NeutronScenario() scenario = utils.NeutronScenario()
net_id = "network-id" net_id = "network-id"
net = {"network": {"id": net_id}} net = {"network": {"id": net_id}}
rand_name = "random-name" rand_name = "random-name"
mock_rand_name.return_value = rand_name mock__generate_random_name.return_value = rand_name
expected_port_args = { expected_port_args = {
"port": { "port": {
"network_id": net_id, "network_id": net_id,
@ -354,29 +354,26 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
} }
}) })
def test_create_network_and_subnets(self, def test_create_network_and_subnets(self,
mock_create_network, mock__create_network,
mock_create_subnet): mock__create_subnet):
scenario = utils.NeutronScenario() scenario = utils.NeutronScenario()
network_create_args = {} network_create_args = {}
subnet_create_args = {} subnet_create_args = {}
subnets_per_network = 4 subnets_per_network = 4
mock_create_network.reset_mock()
mock_create_subnet.reset_mock()
# Default options # Default options
scenario._create_network_and_subnets( scenario._create_network_and_subnets(
network_create_args=network_create_args, network_create_args=network_create_args,
subnet_create_args=subnet_create_args, subnet_create_args=subnet_create_args,
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network.assert_called_once_with({}) mock__create_network.assert_called_once_with({})
mock_create_subnet.assert_has_calls( mock__create_subnet.assert_has_calls(
[mock.call({"network": {"id": "fake-id"}}, [mock.call({"network": {"id": "fake-id"}},
{}, "1.0.0.0/24")] * subnets_per_network) {}, "1.0.0.0/24")] * subnets_per_network)
mock_create_network.reset_mock() mock__create_network.reset_mock()
mock_create_subnet.reset_mock() mock__create_subnet.reset_mock()
# Custom options # Custom options
scenario._create_network_and_subnets( scenario._create_network_and_subnets(
@ -385,8 +382,8 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
subnet_cidr_start="10.10.10.0/24", subnet_cidr_start="10.10.10.0/24",
subnets_per_network=subnets_per_network) subnets_per_network=subnets_per_network)
mock_create_network.assert_called_once_with({}) mock__create_network.assert_called_once_with({})
mock_create_subnet.assert_has_calls( mock__create_subnet.assert_has_calls(
[mock.call({"network": {"id": "fake-id"}}, [mock.call({"network": {"id": "fake-id"}},
{"allocation_pools": []}, {"allocation_pools": []},
"10.10.10.0/24")] * subnets_per_network) "10.10.10.0/24")] * subnets_per_network)
@ -411,13 +408,13 @@ class NeutronScenarioTestCase(test.ClientsTestCase):
neutron_scenario.atomic_actions(), "neutron.create_pool") neutron_scenario.atomic_actions(), "neutron.create_pool")
@mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name") @mock.patch(NEUTRON_UTILS + "NeutronScenario._generate_random_name")
def test_create_v1_pool_default(self, mock_random_name): def test_create_v1_pool_default(self, mock__generate_random_name):
neutron_scenario = utils.NeutronScenario() neutron_scenario = utils.NeutronScenario()
random_name = "random_name" random_name = "random_name"
subnet = "fake-id" subnet = "fake-id"
pool = mock.Mock() pool = mock.Mock()
self.clients("neutron").create_pool.return_value = pool self.clients("neutron").create_pool.return_value = pool
mock_random_name.return_value = random_name mock__generate_random_name.return_value = random_name
# Random pool name # Random pool name
pool_data = {} pool_data = {}
args = {"lb_method": "ROUND_ROBIN", "protocol": "HTTP", args = {"lb_method": "ROUND_ROBIN", "protocol": "HTTP",

25
tests/unit/plugins/openstack/scenarios/nova/test_utils.py
View File

@ -25,7 +25,6 @@ from tests.unit import test
BM_UTILS = "rally.benchmark.utils" BM_UTILS = "rally.benchmark.utils"
NOVA_UTILS = "rally.plugins.openstack.scenarios.nova.utils" NOVA_UTILS = "rally.plugins.openstack.scenarios.nova.utils"
SCN = "rally.benchmark.scenarios.base"
CONF = cfg.CONF CONF = cfg.CONF
@ -95,9 +94,9 @@ class NovaScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.list_servers") "nova.list_servers")
@mock.patch(SCN + ".Scenario._generate_random_name", @mock.patch(NOVA_UTILS + ".NovaScenario._generate_random_name",
return_value="foo_server_name") return_value="foo_server_name")
def test__boot_server(self, mock_generate_random_name): def test__boot_server(self, mock__generate_random_name):
self.clients("nova").servers.create.return_value = self.server self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={}) nova_scenario = utils.NovaScenario(context={})
return_server = nova_scenario._boot_server("image_id", return_server = nova_scenario._boot_server("image_id",
@ -113,9 +112,9 @@ class NovaScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_server") "nova.boot_server")
@mock.patch(SCN + ".Scenario._generate_random_name", @mock.patch(NOVA_UTILS + ".NovaScenario._generate_random_name",
return_value="foo_server_name") return_value="foo_server_name")
def test__boot_server_with_network(self, mock_generate_random_name): def test__boot_server_with_network(self, mock__generate_random_name):
self.clients("nova").servers.create.return_value = self.server self.clients("nova").servers.create.return_value = self.server
networks = [{"id": "foo_id", "external": False}, networks = [{"id": "foo_id", "external": False},
{"id": "bar_id", "external": False}] {"id": "bar_id", "external": False}]
@ -147,9 +146,9 @@ class NovaScenarioTestCase(test.ClientsTestCase):
"image_id", "flavor_id", "image_id", "flavor_id",
auto_assign_nic=True) auto_assign_nic=True)
@mock.patch(SCN + ".Scenario._generate_random_name", @mock.patch(NOVA_UTILS + ".NovaScenario._generate_random_name",
return_value="foo_server_name") return_value="foo_server_name")
def test__boot_server_with_ssh(self, mock_generate_random_name): def test__boot_server_with_ssh(self, mock__generate_random_name):
self.clients("nova").servers.create.return_value = self.server self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={ nova_scenario = utils.NovaScenario(context={
"user": {"secgroup": {"name": "test"}}} "user": {"secgroup": {"name": "test"}}}
@ -167,9 +166,9 @@ class NovaScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_server") "nova.boot_server")
@mock.patch(SCN + ".Scenario._generate_random_name", @mock.patch(NOVA_UTILS + ".NovaScenario._generate_random_name",
return_value="foo_server_name") return_value="foo_server_name")
def test__boot_server_with_sec_group(self, mock_generate_random_name): def test__boot_server_with_sec_group(self, mock__generate_random_name):
self.clients("nova").servers.create.return_value = self.server self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={ nova_scenario = utils.NovaScenario(context={
"user": {"secgroup": {"name": "new"}}} "user": {"secgroup": {"name": "new"}}}
@ -189,10 +188,10 @@ class NovaScenarioTestCase(test.ClientsTestCase):
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.boot_server") "nova.boot_server")
@mock.patch(SCN + ".Scenario._generate_random_name", @mock.patch(NOVA_UTILS + ".NovaScenario._generate_random_name",
return_value="foo_server_name") return_value="foo_server_name")
def test__boot_server_with_similar_sec_group(self, def test__boot_server_with_similar_sec_group(self,
mock_generate_random_name): mock__generate_random_name):
self.clients("nova").servers.create.return_value = self.server self.clients("nova").servers.create.return_value = self.server
nova_scenario = utils.NovaScenario(context={ nova_scenario = utils.NovaScenario(context={
"user": {"secgroup": {"name": "test1"}}} "user": {"secgroup": {"name": "test1"}}}
@ -714,7 +713,7 @@ class NovaScenarioTestCase(test.ClientsTestCase):
"nova.list_floating_ips_bulk") "nova.list_floating_ips_bulk")
@mock.patch(NOVA_UTILS + ".network_wrapper.generate_cidr") @mock.patch(NOVA_UTILS + ".network_wrapper.generate_cidr")
def test__create_floating_ips_bulk(self, mock_gencidr): def test__create_floating_ips_bulk(self, mock_generate_cidr):
fake_cidr = "10.2.0.0/24" fake_cidr = "10.2.0.0/24"
fake_pool = "test1" fake_pool = "test1"
fake_floating_ips_bulk = mock.MagicMock() fake_floating_ips_bulk = mock.MagicMock()
@ -724,7 +723,7 @@ class NovaScenarioTestCase(test.ClientsTestCase):
fake_floating_ips_bulk) fake_floating_ips_bulk)
nova_scenario = utils.NovaScenario() nova_scenario = utils.NovaScenario()
return_iprange = nova_scenario._create_floating_ips_bulk(fake_cidr) return_iprange = nova_scenario._create_floating_ips_bulk(fake_cidr)
mock_gencidr.assert_called_once_with(start_cidr=fake_cidr) mock_generate_cidr.assert_called_once_with(start_cidr=fake_cidr)
self.assertEqual(return_iprange, fake_floating_ips_bulk) self.assertEqual(return_iprange, fake_floating_ips_bulk)
self._test_atomic_action_timer(nova_scenario.atomic_actions(), self._test_atomic_action_timer(nova_scenario.atomic_actions(),
"nova.create_floating_ips_bulk") "nova.create_floating_ips_bulk")

22
tests/unit/plugins/openstack/scenarios/sahara/test_clusters.py
View File

@ -28,8 +28,8 @@ class SaharaClustersTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_CLUSTERS + "._delete_cluster") @mock.patch(SAHARA_CLUSTERS + "._delete_cluster")
@mock.patch(SAHARA_CLUSTERS + "._launch_cluster", @mock.patch(SAHARA_CLUSTERS + "._launch_cluster",
return_value=mock.MagicMock(id=42)) return_value=mock.MagicMock(id=42))
def test_create_and_delete_cluster(self, mock_launch_cluster, def test_create_and_delete_cluster(
mock_delete_cluster): self, mock__launch_cluster, mock__delete_cluster):
clusters_scenario = clusters.SaharaClusters() clusters_scenario = clusters.SaharaClusters()
clusters_scenario.context = { clusters_scenario.context = {
@ -43,7 +43,7 @@ class SaharaClustersTestCase(test.ClientsTestCase):
plugin_name="test_plugin", plugin_name="test_plugin",
hadoop_version="test_version") hadoop_version="test_version")
mock_launch_cluster.assert_called_once_with( mock__launch_cluster.assert_called_once_with(
flavor_id="test_flavor", flavor_id="test_flavor",
image_id="test_image", image_id="test_image",
workers_count=5, workers_count=5,
@ -58,16 +58,16 @@ class SaharaClustersTestCase(test.ClientsTestCase):
cluster_configs=None, cluster_configs=None,
enable_anti_affinity=False) enable_anti_affinity=False)
mock_delete_cluster.assert_called_once_with( mock__delete_cluster.assert_called_once_with(
mock_launch_cluster.return_value) mock__launch_cluster.return_value)
@mock.patch(SAHARA_CLUSTERS + "._delete_cluster") @mock.patch(SAHARA_CLUSTERS + "._delete_cluster")
@mock.patch(SAHARA_CLUSTERS + "._scale_cluster") @mock.patch(SAHARA_CLUSTERS + "._scale_cluster")
@mock.patch(SAHARA_CLUSTERS + "._launch_cluster", @mock.patch(SAHARA_CLUSTERS + "._launch_cluster",
return_value=mock.MagicMock(id=42)) return_value=mock.MagicMock(id=42))
def test_create_scale_delete_cluster(self, mock_launch_cluster, def test_create_scale_delete_cluster(
mock_scale_cluster, self, mock__launch_cluster, mock__scale_cluster,
mock_delete_cluster): mock__delete_cluster):
self.clients("sahara").clusters.get.return_value = mock.MagicMock( self.clients("sahara").clusters.get.return_value = mock.MagicMock(
id=42, status="active" id=42, status="active"
) )
@ -86,7 +86,7 @@ class SaharaClustersTestCase(test.ClientsTestCase):
plugin_name="test_plugin", plugin_name="test_plugin",
hadoop_version="test_version") hadoop_version="test_version")
mock_launch_cluster.assert_called_once_with( mock__launch_cluster.assert_called_once_with(
flavor_id="test_flavor", flavor_id="test_flavor",
image_id="test_image", image_id="test_image",
workers_count=5, workers_count=5,
@ -101,10 +101,10 @@ class SaharaClustersTestCase(test.ClientsTestCase):
cluster_configs=None, cluster_configs=None,
enable_anti_affinity=False) enable_anti_affinity=False)
mock_scale_cluster.assert_has_calls([ mock__scale_cluster.assert_has_calls([
mock.call(self.clients("sahara").clusters.get.return_value, 1), mock.call(self.clients("sahara").clusters.get.return_value, 1),
mock.call(self.clients("sahara").clusters.get.return_value, -1), mock.call(self.clients("sahara").clusters.get.return_value, -1),
]) ])
mock_delete_cluster.assert_called_once_with( mock__delete_cluster.assert_called_once_with(
self.clients("sahara").clusters.get.return_value) self.clients("sahara").clusters.get.return_value)

52
tests/unit/plugins/openstack/scenarios/sahara/test_jobs.py
View File

@ -33,11 +33,12 @@ class SaharaJobTestCase(test.ClientsTestCase):
CONF.set_override("cluster_check_interval", 0, "benchmark") CONF.set_override("cluster_check_interval", 0, "benchmark")
CONF.set_override("job_check_interval", 0, "benchmark") CONF.set_override("job_check_interval", 0, "benchmark")
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch("rally.common.utils.generate_random_name",
return_value="job_42") return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution") @mock.patch(SAHARA_JOB + "._run_job_execution")
def test_create_launch_job_java(self, mock_run_execution, def test_create_launch_job_java(self, mock__run_job_execution,
mock_random_name): mock_generate_random_name):
self.clients("sahara").jobs.create.return_value = mock.MagicMock( self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42") id="42")
@ -58,14 +59,14 @@ class SaharaJobTestCase(test.ClientsTestCase):
job_idx=0 job_idx=0
) )
self.clients("sahara").jobs.create.assert_called_once_with( self.clients("sahara").jobs.create.assert_called_once_with(
name=mock_random_name.return_value, name=mock_generate_random_name.return_value,
type="java", type="java",
description="", description="",
mains=["main_42"], mains=["main_42"],
libs=["lib_42"] libs=["lib_42"]
) )
mock_run_execution.assert_called_once_with( mock__run_job_execution.assert_called_once_with(
job_id="42", job_id="42",
cluster_id="cl_42", cluster_id="cl_42",
input_id=None, input_id=None,
@ -74,13 +75,15 @@ class SaharaJobTestCase(test.ClientsTestCase):
job_idx=0 job_idx=0
) )
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch("rally.common.utils.generate_random_name",
return_value="job_42") return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution") @mock.patch(SAHARA_JOB + "._run_job_execution")
@mock.patch(SAHARA_JOB + "._create_output_ds", @mock.patch(SAHARA_JOB + "._create_output_ds",
return_value=mock.MagicMock(id="out_42")) return_value=mock.MagicMock(id="out_42"))
def test_create_launch_job_pig(self, mock_create_ds, def test_create_launch_job_pig(self, mock__create_output_ds,
mock_run_execution, mock_random_name): mock__run_job_execution,
mock_generate_random_name):
self.clients("sahara").jobs.create.return_value = mock.MagicMock( self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42") id="42")
@ -101,14 +104,14 @@ class SaharaJobTestCase(test.ClientsTestCase):
job_idx=0 job_idx=0
) )
self.clients("sahara").jobs.create.assert_called_once_with( self.clients("sahara").jobs.create.assert_called_once_with(
name=mock_random_name.return_value, name=mock_generate_random_name.return_value,
type="pig", type="pig",
description="", description="",
mains=["main_42"], mains=["main_42"],
libs=["lib_42"] libs=["lib_42"]
) )
mock_run_execution.assert_called_once_with( mock__run_job_execution.assert_called_once_with(
job_id="42", job_id="42",
cluster_id="cl_42", cluster_id="cl_42",
input_id="in_42", input_id="in_42",
@ -117,11 +120,12 @@ class SaharaJobTestCase(test.ClientsTestCase):
job_idx=0 job_idx=0
) )
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch("rally.common.utils.generate_random_name",
return_value="job_42") return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution") @mock.patch(SAHARA_JOB + "._run_job_execution")
def test_create_launch_job_sequence(self, mock_run_execution, def test_create_launch_job_sequence(self, mock__run_job_execution,
mock_random_name): mock_generate_random_name):
self.clients("sahara").jobs.create.return_value = mock.MagicMock( self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42") id="42")
@ -147,7 +151,7 @@ class SaharaJobTestCase(test.ClientsTestCase):
}]) }])
jobs_create_call = mock.call( jobs_create_call = mock.call(
name=mock_random_name.return_value, name=mock_generate_random_name.return_value,
type="java", type="java",
description="", description="",
mains=["main_42"], mains=["main_42"],
@ -156,7 +160,7 @@ class SaharaJobTestCase(test.ClientsTestCase):
self.clients("sahara").jobs.create.assert_has_calls([jobs_create_call, self.clients("sahara").jobs.create.assert_has_calls([jobs_create_call,
jobs_create_call]) jobs_create_call])
mock_run_execution.assert_has_calls([ mock__run_job_execution.assert_has_calls([
mock.call( mock.call(
job_id="42", job_id="42",
cluster_id="cl_42", cluster_id="cl_42",
@ -173,18 +177,18 @@ class SaharaJobTestCase(test.ClientsTestCase):
job_idx=1)] job_idx=1)]
) )
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch("rally.common.utils.generate_random_name",
return_value="job_42") return_value="job_42")
@mock.patch(SAHARA_JOB + "._run_job_execution") @mock.patch(SAHARA_JOB + "._run_job_execution")
@mock.patch(SAHARA_JOB + "._scale_cluster") @mock.patch(SAHARA_JOB + "._scale_cluster")
def test_create_launch_job_sequence_with_scaling(self, mock_scale, def test_create_launch_job_sequence_with_scaling(
mock_run_execution, self, mock__scale_cluster, mock__run_job_execution,
mock_random_name): mock_generate_random_name):
self.clients("sahara").jobs.create.return_value = mock.MagicMock( self.clients("sahara").jobs.create.return_value = mock.MagicMock(
id="42") id="42")
self.clients("sahara").clusters.get.return_value = mock.MagicMock( self.clients("sahara").clusters.get.return_value = mock.MagicMock(
id="cl_42", id="cl_42", status="active")
status="active")
jobs_scenario = jobs.SaharaJob() jobs_scenario = jobs.SaharaJob()
@ -209,7 +213,7 @@ class SaharaJobTestCase(test.ClientsTestCase):
deltas=[1, -1]) deltas=[1, -1])
jobs_create_call = mock.call( jobs_create_call = mock.call(
name=mock_random_name.return_value, name=mock_generate_random_name.return_value,
type="java", type="java",
description="", description="",
mains=["main_42"], mains=["main_42"],
@ -224,5 +228,5 @@ class SaharaJobTestCase(test.ClientsTestCase):
je_1 = mock.call(job_id="42", cluster_id="cl_42", input_id=None, je_1 = mock.call(job_id="42", cluster_id="cl_42", input_id=None,
output_id=None, output_id=None,
configs={"conf_key2": "conf_val2"}, job_idx=1) configs={"conf_key2": "conf_val2"}, job_idx=1)
mock_run_execution.assert_has_calls([je_0, je_1, je_0, je_1, je_0, mock__run_job_execution.assert_has_calls(
je_1]) [je_0, je_1, je_0, je_1, je_0, je_1])

32
tests/unit/plugins/openstack/scenarios/sahara/test_node_group_templates.py
View File

@ -30,33 +30,37 @@ class SaharaNodeGroupTemplatesTestCase(test.TestCase):
return_value=object()) return_value=object())
@mock.patch(SAHARA_NGTS + "._create_worker_node_group_template", @mock.patch(SAHARA_NGTS + "._create_worker_node_group_template",
return_value=object) return_value=object)
def test_create_and_list_node_group_templates(self, mock_create_worker, def test_create_and_list_node_group_templates(
mock_create_master, self,
mock_list): mock__create_worker_node_group_template,
mock__create_master_node_group_template,
mock__list_node_group_templates):
ngts_scenario = ngts.SaharaNodeGroupTemplates() ngts_scenario = ngts.SaharaNodeGroupTemplates()
ngts_scenario.create_and_list_node_group_templates("test_flavor", ngts_scenario.create_and_list_node_group_templates("test_flavor",
"test_plugin", "test_plugin",
"test_version") "test_version")
mock_create_master.assert_called_once_with( mock__create_master_node_group_template.assert_called_once_with(
flavor_id="test_flavor", flavor_id="test_flavor",
plugin_name="test_plugin", plugin_name="test_plugin",
hadoop_version="test_version") hadoop_version="test_version")
mock_create_worker.assert_called_once_with( mock__create_worker_node_group_template.assert_called_once_with(
flavor_id="test_flavor", flavor_id="test_flavor",
plugin_name="test_plugin", plugin_name="test_plugin",
hadoop_version="test_version") hadoop_version="test_version")
mock_list.assert_called_once_with() mock__list_node_group_templates.assert_called_once_with()
@mock.patch(SAHARA_NGTS + "._delete_node_group_template") @mock.patch(SAHARA_NGTS + "._delete_node_group_template")
@mock.patch(SAHARA_NGTS + "._create_master_node_group_template", @mock.patch(SAHARA_NGTS + "._create_master_node_group_template",
return_value=mock.MagicMock(id=1)) return_value=mock.MagicMock(id=1))
@mock.patch(SAHARA_NGTS + "._create_worker_node_group_template", @mock.patch(SAHARA_NGTS + "._create_worker_node_group_template",
return_value=mock.MagicMock(id=2)) return_value=mock.MagicMock(id=2))
def test_create_delete_node_group_templates(self, mock_create_worker, def test_create_delete_node_group_templates(
mock_create_master, self,
mock_delete): mock__create_worker_node_group_template,
mock__create_master_node_group_template,
mock__delete_node_group_template):
ngts_scenario = ngts.SaharaNodeGroupTemplates() ngts_scenario = ngts.SaharaNodeGroupTemplates()
ngts_scenario.create_delete_node_group_templates( ngts_scenario.create_delete_node_group_templates(
@ -64,15 +68,15 @@ class SaharaNodeGroupTemplatesTestCase(test.TestCase):
"test_plugin", "test_plugin",
"test_version") "test_version")
mock_create_master.assert_called_once_with( mock__create_master_node_group_template.assert_called_once_with(
flavor_id="test_flavor", flavor_id="test_flavor",
plugin_name="test_plugin", plugin_name="test_plugin",
hadoop_version="test_version") hadoop_version="test_version")
mock_create_worker.assert_called_once_with( mock__create_worker_node_group_template.assert_called_once_with(
flavor_id="test_flavor", flavor_id="test_flavor",
plugin_name="test_plugin", plugin_name="test_plugin",
hadoop_version="test_version") hadoop_version="test_version")
mock_delete.assert_has_calls(calls=[ mock__delete_node_group_template.assert_has_calls(calls=[
mock.call(mock_create_master.return_value), mock.call(mock__create_master_node_group_template.return_value),
mock.call(mock_create_worker.return_value)]) mock.call(mock__create_worker_node_group_template.return_value)])

31
tests/unit/plugins/openstack/scenarios/sahara/test_utils.py
View File

@ -28,10 +28,10 @@ CONF = cfg.CONF
SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils" SAHARA_UTILS = "rally.plugins.openstack.scenarios.sahara.utils"
class SaharaUtilsTestCase(test.ClientsTestCase): class SaharaScenarioTestCase(test.ClientsTestCase):
def setUp(self): def setUp(self):
super(SaharaUtilsTestCase, self).setUp() super(SaharaScenarioTestCase, self).setUp()
CONF.set_override("cluster_check_interval", 0, "benchmark") CONF.set_override("cluster_check_interval", 0, "benchmark")
CONF.set_override("job_check_interval", 0, "benchmark") CONF.set_override("job_check_interval", 0, "benchmark")
@ -50,8 +50,10 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="random_name") return_value="random_name")
@mock.patch(SAHARA_UTILS + ".sahara_consts") @mock.patch(SAHARA_UTILS + ".sahara_consts")
def test_create_node_group_templates(self, mock_constants, def test_create_node_group_templates(
mock_random_name): self, mock_sahara_consts,
mock__generate_random_name):
scenario = utils.SaharaScenario() scenario = utils.SaharaScenario()
mock_processes = { mock_processes = {
"test_plugin": { "test_plugin": {
@ -62,7 +64,7 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
} }
} }
mock_constants.NODE_PROCESSES = mock_processes mock_sahara_consts.NODE_PROCESSES = mock_processes
scenario._create_master_node_group_template( scenario._create_master_node_group_template(
flavor_id="test_flavor", flavor_id="test_flavor",
@ -114,7 +116,8 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="random_name") return_value="random_name")
@mock.patch(SAHARA_UTILS + ".sahara_consts") @mock.patch(SAHARA_UTILS + ".sahara_consts")
def test_launch_cluster(self, mock_constants, mock_random_name): def test_launch_cluster(self, mock_sahara_consts,
mock__generate_random_name):
context = { context = {
"tenant": { "tenant": {
@ -177,8 +180,8 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
} }
] ]
mock_constants.NODE_PROCESSES = mock_processes mock_sahara_consts.NODE_PROCESSES = mock_processes
mock_constants.REPLICATION_CONFIGS = mock_configs mock_sahara_consts.REPLICATION_CONFIGS = mock_configs
self.clients("sahara").clusters.create.return_value = mock.MagicMock( self.clients("sahara").clusters.create.return_value = mock.MagicMock(
id="test_cluster_id") id="test_cluster_id")
@ -217,7 +220,9 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="random_name") return_value="random_name")
@mock.patch(SAHARA_UTILS + ".sahara_consts") @mock.patch(SAHARA_UTILS + ".sahara_consts")
def test_launch_cluster_error(self, mock_constants, mock_random_name): def test_launch_cluster_error(self, mock_sahara_consts,
mock__generate_random_name):
scenario = utils.SaharaScenario(clients=mock.MagicMock()) scenario = utils.SaharaScenario(clients=mock.MagicMock())
mock_processes = { mock_processes = {
"test_plugin": { "test_plugin": {
@ -237,8 +242,8 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
} }
} }
mock_constants.NODE_PROCESSES = mock_processes mock_sahara_consts.NODE_PROCESSES = mock_processes
mock_constants.REPLICATION_CONFIGS = mock_configs mock_sahara_consts.REPLICATION_CONFIGS = mock_configs
self.clients("sahara").clusters.create.return_value = mock.MagicMock( self.clients("sahara").clusters.create.return_value = mock.MagicMock(
id="test_cluster_id") id="test_cluster_id")
@ -303,7 +308,7 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="42") return_value="42")
def test_create_output_ds(self, mock_random_name): def test_create_output_ds(self, mock__generate_random_name):
ctxt = { ctxt = {
"sahara_output_conf": { "sahara_output_conf": {
"output_type": "hdfs", "output_type": "hdfs",
@ -323,7 +328,7 @@ class SaharaUtilsTestCase(test.ClientsTestCase):
@mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name", @mock.patch(SAHARA_UTILS + ".SaharaScenario._generate_random_name",
return_value="42") return_value="42")
def test_create_output_ds_swift(self, mock_random_name): def test_create_output_ds_swift(self, mock__generate_random_name):
ctxt = { ctxt = {
"sahara_output_conf": { "sahara_output_conf": {
"output_type": "swift", "output_type": "swift",

69
tests/unit/plugins/openstack/scenarios/vm/test_utils.py
View File

@ -52,7 +52,7 @@ class VMScenarioTestCase(test.TestCase):
mock_open.assert_called_once_with("foobar", "rb") mock_open.assert_called_once_with("foobar", "rb")
@mock.patch("%s.six.moves.StringIO" % VMTASKS_UTILS) @mock.patch("%s.six.moves.StringIO" % VMTASKS_UTILS)
def test__run_command_over_ssh_script_inline(self, mock_stringio): def test__run_command_over_ssh_script_inline(self, mock_string_io):
mock_ssh = mock.MagicMock() mock_ssh = mock.MagicMock()
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
vm_scenario._run_command_over_ssh( vm_scenario._run_command_over_ssh(
@ -64,8 +64,8 @@ class VMScenarioTestCase(test.TestCase):
) )
mock_ssh.execute.assert_called_once_with( mock_ssh.execute.assert_called_once_with(
["interpreter", "interpreter_arg"], ["interpreter", "interpreter_arg"],
stdin=mock_stringio.return_value) stdin=mock_string_io.return_value)
mock_stringio.assert_called_once_with("foobar") mock_string_io.assert_called_once_with("foobar")
def test__run_command_over_ssh_remote_path(self): def test__run_command_over_ssh_remote_path(self):
mock_ssh = mock.MagicMock() mock_ssh = mock.MagicMock()
@ -95,102 +95,93 @@ class VMScenarioTestCase(test.TestCase):
@mock.patch(VMTASKS_UTILS + ".bench_utils.resource_is") @mock.patch(VMTASKS_UTILS + ".bench_utils.resource_is")
@mock.patch(VMTASKS_UTILS + ".VMScenario._ping_ip_address", @mock.patch(VMTASKS_UTILS + ".VMScenario._ping_ip_address",
return_value=True) return_value=True)
def test__wait_for_ping(self, mock__ping, mock_resource_is): def test__wait_for_ping(self, mock_vm_scenario__ping_ip_address,
mock_resource_is):
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
vm_scenario._wait_for_ping(netaddr.IPAddress("1.2.3.4")) vm_scenario._wait_for_ping(netaddr.IPAddress("1.2.3.4"))
self.wait_for.mock.assert_called_once_with( self.wait_for.mock.assert_called_once_with(
netaddr.IPAddress("1.2.3.4"), netaddr.IPAddress("1.2.3.4"),
is_ready=mock_resource_is.return_value, is_ready=mock_resource_is.return_value,
timeout=120) timeout=120)
mock_resource_is.assert_called_once_with("ICMP UP", mock__ping) mock_resource_is.assert_called_once_with(
"ICMP UP", mock_vm_scenario__ping_ip_address)
@mock.patch(VMTASKS_UTILS + ".VMScenario._run_command_over_ssh") @mock.patch(VMTASKS_UTILS + ".VMScenario._run_command_over_ssh")
@mock.patch("rally.common.sshutils.SSH") @mock.patch("rally.common.sshutils.SSH")
def test__run_command(self, mock_ssh_class, mock_run_command_over_ssh): def test__run_command(self, mock_sshutils_ssh,
mock_ssh_instance = mock.MagicMock() mock_vm_scenario__run_command_over_ssh):
mock_ssh_class.return_value = mock_ssh_instance
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
vm_scenario.context = {"user": {"keypair": {"private": "ssh"}}} vm_scenario.context = {"user": {"keypair": {"private": "ssh"}}}
vm_scenario._run_command("1.2.3.4", 22, "username", "password", vm_scenario._run_command("1.2.3.4", 22, "username", "password",
command={"script_file": "foo", command={"script_file": "foo",
"interpreter": "bar"}) "interpreter": "bar"})
mock_ssh_class.assert_called_once_with("username", "1.2.3.4", port=22, mock_sshutils_ssh.assert_called_once_with(
pkey="ssh", "username", "1.2.3.4", port=22, pkey="ssh", password="password")
password="password") mock_sshutils_ssh.return_value.wait.assert_called_once_with()
mock_ssh_instance.wait.assert_called_once_with() mock_vm_scenario__run_command_over_ssh.assert_called_once_with(
mock_run_command_over_ssh.assert_called_once_with( mock_sshutils_ssh.return_value,
mock_ssh_instance,
{"script_file": "foo", "interpreter": "bar"}) {"script_file": "foo", "interpreter": "bar"})
@mock.patch(VMTASKS_UTILS + ".sys") @mock.patch(VMTASKS_UTILS + ".sys")
@mock.patch("subprocess.Popen") @mock.patch("subprocess.Popen")
def test__ping_ip_address_linux(self, mock_subprocess, mock_sys): def test__ping_ip_address_linux(self, mock_popen, mock_sys):
ping_process = mock.MagicMock() mock_popen.return_value.returncode = 0
ping_process.returncode = 0
mock_subprocess.return_value = ping_process
mock_sys.platform = "linux2" mock_sys.platform = "linux2"
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
host_ip = netaddr.IPAddress("1.2.3.4") host_ip = netaddr.IPAddress("1.2.3.4")
self.assertTrue(vm_scenario._ping_ip_address(host_ip)) self.assertTrue(vm_scenario._ping_ip_address(host_ip))
mock_subprocess.assert_called_once_with( mock_popen.assert_called_once_with(
["ping", "-c1", "-w1", str(host_ip)], ["ping", "-c1", "-w1", str(host_ip)],
stderr=subprocess.PIPE, stdout=subprocess.PIPE) stderr=subprocess.PIPE, stdout=subprocess.PIPE)
ping_process.wait.assert_called_once_with() mock_popen.return_value.wait.assert_called_once_with()
@mock.patch(VMTASKS_UTILS + ".sys") @mock.patch(VMTASKS_UTILS + ".sys")
@mock.patch("subprocess.Popen") @mock.patch("subprocess.Popen")
def test__ping_ip_address_linux_ipv6(self, mock_subprocess, mock_sys): def test__ping_ip_address_linux_ipv6(self, mock_popen, mock_sys):
ping_process = mock.MagicMock() mock_popen.return_value.returncode = 0
ping_process.returncode = 0
mock_subprocess.return_value = ping_process
mock_sys.platform = "linux2" mock_sys.platform = "linux2"
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
host_ip = netaddr.IPAddress("1ce:c01d:bee2:15:a5:900d:a5:11fe") host_ip = netaddr.IPAddress("1ce:c01d:bee2:15:a5:900d:a5:11fe")
self.assertTrue(vm_scenario._ping_ip_address(host_ip)) self.assertTrue(vm_scenario._ping_ip_address(host_ip))
mock_subprocess.assert_called_once_with( mock_popen.assert_called_once_with(
["ping6", "-c1", "-w1", str(host_ip)], ["ping6", "-c1", "-w1", str(host_ip)],
stderr=subprocess.PIPE, stdout=subprocess.PIPE) stderr=subprocess.PIPE, stdout=subprocess.PIPE)
ping_process.wait.assert_called_once_with() mock_popen.return_value.wait.assert_called_once_with()
@mock.patch(VMTASKS_UTILS + ".sys") @mock.patch(VMTASKS_UTILS + ".sys")
@mock.patch("subprocess.Popen") @mock.patch("subprocess.Popen")
def test__ping_ip_address_other_os(self, mock_subprocess, mock_sys): def test__ping_ip_address_other_os(self, mock_popen, mock_sys):
ping_process = mock.MagicMock() mock_popen.return_value.returncode = 0
ping_process.returncode = 0
mock_subprocess.return_value = ping_process
mock_sys.platform = "freebsd10" mock_sys.platform = "freebsd10"
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
host_ip = netaddr.IPAddress("1.2.3.4") host_ip = netaddr.IPAddress("1.2.3.4")
self.assertTrue(vm_scenario._ping_ip_address(host_ip)) self.assertTrue(vm_scenario._ping_ip_address(host_ip))
mock_subprocess.assert_called_once_with( mock_popen.assert_called_once_with(
["ping", "-c1", str(host_ip)], ["ping", "-c1", str(host_ip)],
stderr=subprocess.PIPE, stdout=subprocess.PIPE) stderr=subprocess.PIPE, stdout=subprocess.PIPE)
ping_process.wait.assert_called_once_with() mock_popen.return_value.wait.assert_called_once_with()
@mock.patch(VMTASKS_UTILS + ".sys") @mock.patch(VMTASKS_UTILS + ".sys")
@mock.patch("subprocess.Popen") @mock.patch("subprocess.Popen")
def test__ping_ip_address_other_os_ipv6(self, mock_subprocess, mock_sys): def test__ping_ip_address_other_os_ipv6(self, mock_popen, mock_sys):
ping_process = mock.MagicMock() mock_popen.return_value.returncode = 0
ping_process.returncode = 0
mock_subprocess.return_value = ping_process
mock_sys.platform = "freebsd10" mock_sys.platform = "freebsd10"
vm_scenario = utils.VMScenario() vm_scenario = utils.VMScenario()
host_ip = netaddr.IPAddress("1ce:c01d:bee2:15:a5:900d:a5:11fe") host_ip = netaddr.IPAddress("1ce:c01d:bee2:15:a5:900d:a5:11fe")
self.assertTrue(vm_scenario._ping_ip_address(host_ip)) self.assertTrue(vm_scenario._ping_ip_address(host_ip))
mock_subprocess.assert_called_once_with( mock_popen.assert_called_once_with(
["ping6", "-c1", str(host_ip)], ["ping6", "-c1", str(host_ip)],
stderr=subprocess.PIPE, stdout=subprocess.PIPE) stderr=subprocess.PIPE, stdout=subprocess.PIPE)
ping_process.wait.assert_called_once_with() mock_popen.return_value.wait.assert_called_once_with()
def get_scenario(self): def get_scenario(self):
server = mock.Mock( server = mock.Mock(

4
tests/unit/plugins/openstack/scenarios/zaqar/test_basic.py
View File

@ -24,14 +24,14 @@ BASIC = BASE + "basic.ZaqarBasic."
class ZaqarBasicTestCase(test.TestCase): class ZaqarBasicTestCase(test.TestCase):
@mock.patch(BASIC + "_generate_random_name", return_value="fizbit") @mock.patch(BASIC + "_generate_random_name", return_value="fizbit")
def test_create_queue(self, mock_gen_name): def test_create_queue(self, mock__generate_random_name):
scenario = basic.ZaqarBasic() scenario = basic.ZaqarBasic()
scenario._queue_create = mock.MagicMock() scenario._queue_create = mock.MagicMock()
scenario.create_queue(name_length=10) scenario.create_queue(name_length=10)
scenario._queue_create.assert_called_once_with(name_length=10) scenario._queue_create.assert_called_once_with(name_length=10)
@mock.patch(BASIC + "_generate_random_name", return_value="kitkat") @mock.patch(BASIC + "_generate_random_name", return_value="kitkat")
def test_producer_consumer(self, mock_gen_name): def test_producer_consumer(self, mock__generate_random_name):
scenario = basic.ZaqarBasic() scenario = basic.ZaqarBasic()
messages = [{"body": {"id": idx}, "ttl": 360} for idx messages = [{"body": {"id": idx}, "ttl": 360} for idx
in range(20)] in range(20)]

2
tests/unit/plugins/openstack/scenarios/zaqar/test_utils.py
View File

@ -25,7 +25,7 @@ class ZaqarScenarioTestCase(test.ClientsTestCase):
@mock.patch(UTILS + "ZaqarScenario._generate_random_name", @mock.patch(UTILS + "ZaqarScenario._generate_random_name",
return_value="kitkat") return_value="kitkat")
def test_queue_create(self, mock_gen_name): def test_queue_create(self, mock__generate_random_name):
scenario = utils.ZaqarScenario() scenario = utils.ZaqarScenario()
result = scenario._queue_create(name_length=10) result = scenario._queue_create(name_length=10)

62
tests/unit/plugins/openstack/wrappers/test_network.py
View File

@ -45,21 +45,24 @@ class NovaNetworkWrapperTestCase(test.TestCase):
service.client.networks.list.assert_called_once_with() service.client.networks.list.assert_called_once_with()
@mock.patch("rally.plugins.openstack.wrappers.network.generate_cidr") @mock.patch("rally.plugins.openstack.wrappers.network.generate_cidr")
def test__generate_cidr(self, mock_cidr): def test__generate_cidr(self, mock_generate_cidr):
skip_cidrs = [5, 7] skip_cidrs = [5, 7]
cidrs = iter(range(7)) cidrs = iter(range(7))
mock_cidr.side_effect = lambda start_cidr: start_cidr + next(cidrs) mock_generate_cidr.side_effect = (
lambda start_cidr: start_cidr + next(cidrs)
)
service = self.get_wrapper(*skip_cidrs, start_cidr=3) service = self.get_wrapper(*skip_cidrs, start_cidr=3)
self.assertEqual(service._generate_cidr(), 3) self.assertEqual(service._generate_cidr(), 3)
self.assertEqual(service._generate_cidr(), 4) self.assertEqual(service._generate_cidr(), 4)
self.assertEqual(service._generate_cidr(), 6) # 5 is skipped self.assertEqual(service._generate_cidr(), 6) # 5 is skipped
self.assertEqual(service._generate_cidr(), 8) # 7 is skipped self.assertEqual(service._generate_cidr(), 8) # 7 is skipped
self.assertEqual(service._generate_cidr(), 9) self.assertEqual(service._generate_cidr(), 9)
self.assertEqual(mock_cidr.mock_calls, [mock.call(start_cidr=3)] * 7) self.assertEqual(mock_generate_cidr.mock_calls,
[mock.call(start_cidr=3)] * 7)
@mock.patch("rally.common.utils.generate_random_name", @mock.patch("rally.common.utils.generate_random_name",
return_value="foo_name") return_value="foo_name")
def test_create_network(self, mock_name): def test_create_network(self, mock_generate_random_name):
service = self.get_wrapper() service = self.get_wrapper()
service.client.networks.create.side_effect = ( service.client.networks.create.side_effect = (
lambda **kwargs: self.Net(id="foo_id", **kwargs)) lambda **kwargs: self.Net(id="foo_id", **kwargs))
@ -71,7 +74,7 @@ class NovaNetworkWrapperTestCase(test.TestCase):
"status": "ACTIVE", "status": "ACTIVE",
"external": False, "external": False,
"tenant_id": "foo_tenant"}) "tenant_id": "foo_tenant"})
mock_name.assert_called_once_with("rally_net_") mock_generate_random_name.assert_called_once_with("rally_net_")
service._generate_cidr.assert_called_once_with() service._generate_cidr.assert_called_once_with()
service.client.networks.create.assert_called_once_with( service.client.networks.create.assert_called_once_with(
tenant_id="foo_tenant", cidr="foo_cidr", label="foo_name") tenant_id="foo_tenant", cidr="foo_cidr", label="foo_name")
@ -152,16 +155,19 @@ class NeutronWrapperTestCase(test.TestCase):
self.assertEqual(network.NeutronWrapper.SUBNET_IP_VERSION, 4) self.assertEqual(network.NeutronWrapper.SUBNET_IP_VERSION, 4)
@mock.patch("rally.plugins.openstack.wrappers.network.generate_cidr") @mock.patch("rally.plugins.openstack.wrappers.network.generate_cidr")
def test__generate_cidr(self, mock_cidr): def test__generate_cidr(self, mock_generate_cidr):
cidrs = iter(range(5)) cidrs = iter(range(5))
mock_cidr.side_effect = lambda start_cidr: start_cidr + next(cidrs) mock_generate_cidr.side_effect = (
lambda start_cidr: start_cidr + next(cidrs)
)
service = self.get_wrapper(start_cidr=3) service = self.get_wrapper(start_cidr=3)
self.assertEqual(service._generate_cidr(), 3) self.assertEqual(service._generate_cidr(), 3)
self.assertEqual(service._generate_cidr(), 4) self.assertEqual(service._generate_cidr(), 4)
self.assertEqual(service._generate_cidr(), 5) self.assertEqual(service._generate_cidr(), 5)
self.assertEqual(service._generate_cidr(), 6) self.assertEqual(service._generate_cidr(), 6)
self.assertEqual(service._generate_cidr(), 7) self.assertEqual(service._generate_cidr(), 7)
self.assertEqual(mock_cidr.mock_calls, [mock.call(start_cidr=3)] * 5) self.assertEqual(mock_generate_cidr.mock_calls,
[mock.call(start_cidr=3)] * 5)
def test_external_networks(self): def test_external_networks(self):
wrap = self.get_wrapper() wrap = self.get_wrapper()
@ -205,15 +211,15 @@ class NeutronWrapperTestCase(test.TestCase):
name="foo_name") name="foo_name")
@mock.patch("rally.common.utils.generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_network(self, mock_name): def test_create_network(self, mock_generate_random_name):
mock_name.return_value = "foo_name" mock_generate_random_name.return_value = "foo_name"
service = self.get_wrapper() service = self.get_wrapper()
service.client.create_network.return_value = { service.client.create_network.return_value = {
"network": {"id": "foo_id", "network": {"id": "foo_id",
"name": "foo_name", "name": "foo_name",
"status": "foo_status"}} "status": "foo_status"}}
net = service.create_network("foo_tenant") net = service.create_network("foo_tenant")
mock_name.assert_called_once_with("rally_net_") mock_generate_random_name.assert_called_once_with("rally_net_")
service.client.create_network.assert_called_once_with({ service.client.create_network.assert_called_once_with({
"network": {"tenant_id": "foo_tenant", "name": "foo_name"}}) "network": {"tenant_id": "foo_tenant", "name": "foo_name"}})
self.assertEqual(net, {"id": "foo_id", self.assertEqual(net, {"id": "foo_id",
@ -225,9 +231,9 @@ class NeutronWrapperTestCase(test.TestCase):
"subnets": []}) "subnets": []})
@mock.patch("rally.common.utils.generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_network_with_subnets(self, mock_name): def test_create_network_with_subnets(self, mock_generate_random_name):
subnets_num = 4 subnets_num = 4
mock_name.return_value = "foo_name" mock_generate_random_name.return_value = "foo_name"
service = self.get_wrapper() service = self.get_wrapper()
subnets_cidrs = iter(range(subnets_num)) subnets_cidrs = iter(range(subnets_num))
subnets_ids = iter(range(subnets_num)) subnets_ids = iter(range(subnets_num))
@ -263,8 +269,8 @@ class NeutronWrapperTestCase(test.TestCase):
for i in range(subnets_num)]) for i in range(subnets_num)])
@mock.patch("rally.common.utils.generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_network_with_router(self, mock_name): def test_create_network_with_router(self, mock_generate_random_name):
mock_name.return_value = "foo_name" mock_generate_random_name.return_value = "foo_name"
service = self.get_wrapper() service = self.get_wrapper()
service.create_router = mock.Mock(return_value={"id": "foo_router"}) service.create_router = mock.Mock(return_value={"id": "foo_router"})
service.client.create_network.return_value = { service.client.create_network.return_value = {
@ -283,9 +289,10 @@ class NeutronWrapperTestCase(test.TestCase):
tenant_id="foo_tenant") tenant_id="foo_tenant")
@mock.patch("rally.common.utils.generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_network_with_router_and_subnets(self, mock_name): def test_create_network_with_router_and_subnets(self,
mock_generate_random_name):
subnets_num = 4 subnets_num = 4
mock_name.return_value = "foo_name" mock_generate_random_name.return_value = "foo_name"
service = self.get_wrapper() service = self.get_wrapper()
service._generate_cidr = mock.Mock(return_value="foo_cidr") service._generate_cidr = mock.Mock(return_value="foo_cidr")
service.create_router = mock.Mock(return_value={"id": "foo_router"}) service.create_router = mock.Mock(return_value={"id": "foo_router"})
@ -375,7 +382,7 @@ class NeutronWrapperTestCase(test.TestCase):
service.client.list_networks.assert_called_once_with() service.client.list_networks.assert_called_once_with()
@mock.patch(SVC + "NeutronWrapper.external_networks") @mock.patch(SVC + "NeutronWrapper.external_networks")
def test_create_floating_ip(self, mock_ext_networks): def test_create_floating_ip(self, mock_neutron_wrapper_external_networks):
wrap = self.get_wrapper() wrap = self.get_wrapper()
wrap.create_port = mock.Mock(return_value={"id": "port_id"}) wrap.create_port = mock.Mock(return_value={"id": "port_id"})
wrap.client.create_floatingip = mock.Mock( wrap.client.create_floatingip = mock.Mock(
@ -384,11 +391,13 @@ class NeutronWrapperTestCase(test.TestCase):
self.assertRaises(ValueError, wrap.create_floating_ip) self.assertRaises(ValueError, wrap.create_floating_ip)
mock_ext_networks.__get__ = lambda *args: [] mock_neutron_wrapper_external_networks.__get__ = lambda *args: []
self.assertRaises(network.NetworkWrapperException, self.assertRaises(network.NetworkWrapperException,
wrap.create_floating_ip, tenant_id="foo_tenant") wrap.create_floating_ip, tenant_id="foo_tenant")
mock_ext_networks.__get__ = lambda *args: [{"id": "ext_id"}] mock_neutron_wrapper_external_networks.__get__ = (
lambda *args: [{"id": "ext_id"}]
)
fip = wrap.create_floating_ip(tenant_id="foo_tenant") fip = wrap.create_floating_ip(tenant_id="foo_tenant")
self.assertEqual(fip, {"id": "fip_id", "ip": "fip_ip"}) self.assertEqual(fip, {"id": "fip_id", "ip": "fip_ip"})
@ -416,11 +425,14 @@ class NeutronWrapperTestCase(test.TestCase):
@mock.patch(SVC + "NeutronWrapper.external_networks") @mock.patch(SVC + "NeutronWrapper.external_networks")
@mock.patch("rally.common.utils.generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_router(self, mock_random, mock_ext_networks): def test_create_router(self, mock_generate_random_name,
mock_neutron_wrapper_external_networks):
wrap = self.get_wrapper() wrap = self.get_wrapper()
mock_random.return_value = "random_name" mock_generate_random_name.return_value = "random_name"
wrap.client.create_router.return_value = {"router": "foo_router"} wrap.client.create_router.return_value = {"router": "foo_router"}
mock_ext_networks.__get__ = lambda *args: [{"id": "ext_id"}] mock_neutron_wrapper_external_networks.__get__ = (
lambda *args: [{"id": "ext_id"}]
)
router = wrap.create_router(name="foo_name") router = wrap.create_router(name="foo_name")
wrap.client.create_router.assert_called_once_with( wrap.client.create_router.assert_called_once_with(
@ -436,9 +448,9 @@ class NeutronWrapperTestCase(test.TestCase):
"foo": "bar"}}) "foo": "bar"}})
@mock.patch("rally.common.utils.generate_random_name") @mock.patch("rally.common.utils.generate_random_name")
def test_create_port(self, mock_random): def test_create_port(self, mock_generate_random_name):
wrap = self.get_wrapper() wrap = self.get_wrapper()
mock_random.return_value = "random_name" mock_generate_random_name.return_value = "random_name"
wrap.client.create_port.return_value = {"port": "foo_port"} wrap.client.create_port.return_value = {"port": "foo_port"}
port = wrap.create_port("foo_net", name="foo_name") port = wrap.create_port("foo_net", name="foo_name")

3
tests/unit/rally_jobs/test_jobs.py
View File

@ -30,7 +30,8 @@ class RallyJobsTestCase(test.TestCase):
@mock.patch("rally.benchmark.engine.BenchmarkEngine" @mock.patch("rally.benchmark.engine.BenchmarkEngine"
"._validate_config_semantic") "._validate_config_semantic")
def test_schema_is_valid(self, mock_validate): def test_schema_is_valid(
self, mock_benchmark_engine__validate_config_semantic):
discover.load_plugins(os.path.join(self.rally_jobs_path, "plugins")) discover.load_plugins(os.path.join(self.rally_jobs_path, "plugins"))
for filename in ["rally.yaml", "rally-neutron.yaml", for filename in ["rally.yaml", "rally-neutron.yaml",