openstack/rally-openstack
Code Issues Proposed changes

Fixed order of arguments in assertEqual

Browse Source 
Some tests used incorrect order of arguments in
assertEqual(observed, expected). The correct order expected
by testtool is assertEqual(expected, observed).

Partial-Bug: #1259292

Change-Id: I944b72f743a21d0908d17485c25aeb0e7ee70cba
This commit is contained in:
sudhir_agarwal 2017-06-30 16:43:39 +05:30 committed by Boris Pavlovic
parent 018a014fe7
commit 79a372858f
17 changed files with 155 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/functional/test_cli_task.py
View File

@ -1074,7 +1074,7 @@ class SLAExtraFlagsTestCase(unittest.TestCase):
try: try:
rally("task sla-check --json", getjson=True) rally("task sla-check --json", getjson=True)
except utils.RallyCliError as expected_error: except utils.RallyCliError as expected_error:
self.assertEqual(json.loads(expected_error.output), expected) self.assertEqual(expected, json.loads(expected_error.output))
else: else:
self.fail("`rally task sla-check` command should return non-zero " self.fail("`rally task sla-check` command should return non-zero "
"exit code") "exit code")
@ -1102,7 +1102,7 @@ class SLAExtraFlagsTestCase(unittest.TestCase):
try: try:
rally("task sla-check --json", getjson=True) rally("task sla-check --json", getjson=True)
except utils.RallyCliError as expected_error: except utils.RallyCliError as expected_error:
self.assertEqual(json.loads(expected_error.output), expected) self.assertEqual(expected, json.loads(expected_error.output))
else: else:
self.fail("`rally task sla-check` command should return non-zero " self.fail("`rally task sla-check` command should return non-zero "
"exit code") "exit code")

6
tests/unit/plugins/openstack/cleanup/test_base.py
View File

@ -30,8 +30,8 @@ class ResourceDecoratorTestCase(test.TestCase):
class Fake(object): class Fake(object):
pass pass
self.assertEqual(Fake._service, "service") self.assertEqual("service", Fake._service)
self.assertEqual(Fake._resource, "res") self.assertEqual("res", Fake._resource)
class ResourceManagerTestCase(test.TestCase): class ResourceManagerTestCase(test.TestCase):
@ -86,7 +86,7 @@ class ResourceManagerTestCase(test.TestCase):
mock_resource_manager__manager.assert_has_calls( mock_resource_manager__manager.assert_has_calls(
[mock.call(), mock.call().get(resource.id)] * 3) [mock.call(), mock.call().get(resource.id)] * 3)
self.assertEqual(mock_resource_manager__manager.call_count, 3) self.assertEqual(3, mock_resource_manager__manager.call_count)
@mock.patch("%s.ResourceManager._manager" % BASE) @mock.patch("%s.ResourceManager._manager" % BASE)
def test_is_deleted_exceptions(self, mock_resource_manager__manager): def test_is_deleted_exceptions(self, mock_resource_manager__manager):

6
tests/unit/plugins/openstack/cleanup/test_manager.py
View File

@ -56,9 +56,9 @@ class SeekAndDestroyTestCase(test.TestCase):
mock_resource) mock_resource)
mock_resource.delete.assert_has_calls([mock.call()] * 3) mock_resource.delete.assert_has_calls([mock.call()] * 3)
self.assertEqual(mock_resource.delete.call_count, 3) self.assertEqual(3, mock_resource.delete.call_count)
mock_resource.is_deleted.assert_has_calls([mock.call()] * 3) mock_resource.is_deleted.assert_has_calls([mock.call()] * 3)
self.assertEqual(mock_resource.is_deleted.call_count, 3) self.assertEqual(3, mock_resource.is_deleted.call_count)
# NOTE(boris-42): No logs and no exceptions means no bugs! # NOTE(boris-42): No logs and no exceptions means no bugs!
self.assertEqual(0, mock_log.call_count) self.assertEqual(0, mock_log.call_count)
@ -167,7 +167,7 @@ class SeekAndDestroyTestCase(test.TestCase):
]) ])
expected_queue = [(admin, users[0], x) for x in range(1, 4)] expected_queue = [(admin, users[0], x) for x in range(1, 4)]
expected_queue += [(admin, users[1], x) for x in range(4, 6)] expected_queue += [(admin, users[1], x) for x in range(4, 6)]
self.assertEqual(queue, expected_queue) self.assertEqual(expected_queue, queue)
@mock.patch("%s.LOG" % BASE) @mock.patch("%s.LOG" % BASE)
@mock.patch("%s.SeekAndDestroy._get_cached_client" % BASE) @mock.patch("%s.SeekAndDestroy._get_cached_client" % BASE)

24
tests/unit/plugins/openstack/context/keystone/test_users.py
View File

@ -376,7 +376,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"}, user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"},
"t2": {"id": "t2", "name": "t2"}} "t2": {"id": "t2", "name": "t2"}}
user_generator._delete_tenants() user_generator._delete_tenants()
self.assertEqual(len(user_generator.context["tenants"]), 0) self.assertEqual(0, len(user_generator.context["tenants"]))
@mock.patch("%s.identity" % CTX) @mock.patch("%s.identity" % CTX)
def test__delete_tenants_failure(self, mock_identity): def test__delete_tenants_failure(self, mock_identity):
@ -386,7 +386,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"}, user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"},
"t2": {"id": "t2", "name": "t2"}} "t2": {"id": "t2", "name": "t2"}}
user_generator._delete_tenants() user_generator._delete_tenants()
self.assertEqual(len(user_generator.context["tenants"]), 0) self.assertEqual(0, len(user_generator.context["tenants"]))
@mock.patch("%s.identity" % CTX) @mock.patch("%s.identity" % CTX)
def test__delete_users(self, mock_identity): def test__delete_users(self, mock_identity):
@ -395,7 +395,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
user2 = mock.MagicMock() user2 = mock.MagicMock()
user_generator.context["users"] = [user1, user2] user_generator.context["users"] = [user1, user2]
user_generator._delete_users() user_generator._delete_users()
self.assertEqual(len(user_generator.context["users"]), 0) self.assertEqual(0, len(user_generator.context["users"]))
@mock.patch("%s.identity" % CTX) @mock.patch("%s.identity" % CTX)
def test__delete_users_failure(self, mock_identity): def test__delete_users_failure(self, mock_identity):
@ -406,7 +406,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
user2 = mock.MagicMock() user2 = mock.MagicMock()
user_generator.context["users"] = [user1, user2] user_generator.context["users"] = [user1, user2]
user_generator._delete_users() user_generator._delete_users()
self.assertEqual(len(user_generator.context["users"]), 0) self.assertEqual(0, len(user_generator.context["users"]))
@mock.patch("%s.identity" % CTX) @mock.patch("%s.identity" % CTX)
def test_setup_and_cleanup(self, mock_identity): def test_setup_and_cleanup(self, mock_identity):
@ -414,16 +414,16 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
ctx.setup() ctx.setup()
self.assertEqual(len(ctx.context["users"]), self.assertEqual(self.users_num,
self.users_num) len(ctx.context["users"]))
self.assertEqual(len(ctx.context["tenants"]), self.assertEqual(self.tenants_num,
self.tenants_num) len(ctx.context["tenants"]))
self.assertEqual("random", ctx.context["user_choice_method"]) self.assertEqual("random", ctx.context["user_choice_method"])
# Cleanup (called by content manager) # Cleanup (called by content manager)
self.assertEqual(len(ctx.context["users"]), 0) self.assertEqual(0, len(ctx.context["users"]))
self.assertEqual(len(ctx.context["tenants"]), 0) self.assertEqual(0, len(ctx.context["tenants"]))
@mock.patch("rally.common.broker.LOG.warning") @mock.patch("rally.common.broker.LOG.warning")
@mock.patch("%s.identity" % CTX) @mock.patch("%s.identity" % CTX)
@ -488,8 +488,8 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
for (user, tenant_id, orig_user) in zip(ctx.context["users"], for (user, tenant_id, orig_user) in zip(ctx.context["users"],
tenants_ids, user_list): tenants_ids, user_list):
self.assertEqual(user["id"], orig_user.id) self.assertEqual(orig_user.id, user["id"])
self.assertEqual(user["tenant_id"], tenant_id) self.assertEqual(tenant_id, user["tenant_id"])
@mock.patch("%s.identity" % CTX) @mock.patch("%s.identity" % CTX)
def test_users_contains_correct_endpoint_type(self, mock_identity): def test_users_contains_correct_endpoint_type(self, mock_identity):

2
tests/unit/plugins/openstack/context/manila/test_manila_security_services.py
View File

@ -89,7 +89,7 @@ class SecurityServicesTestCase(test.ScenarioTestCase):
inst = manila_security_services.SecurityServices(context) inst = manila_security_services.SecurityServices(context)
self.assertEqual(inst.config.get("foo"), "bar") self.assertEqual("bar", inst.config.get("foo"))
self.assertFalse(inst.config.get("security_services")) self.assertFalse(inst.config.get("security_services"))
self.assertEqual(445, inst.get_order()) self.assertEqual(445, inst.get_order())
self.assertEqual(CONTEXT_NAME, inst.get_name()) self.assertEqual(CONTEXT_NAME, inst.get_name())

18
tests/unit/plugins/openstack/context/network/test_network.py
View File

@ -41,9 +41,9 @@ class NetworkTestCase(test.TestCase):
@mock.patch(NET + "wrap", return_value="foo_service") @mock.patch(NET + "wrap", return_value="foo_service")
def test__init__default(self, mock_wrap, mock_clients): def test__init__default(self, mock_wrap, mock_clients):
context = network_context.Network(self.get_context()) context = network_context.Network(self.get_context())
self.assertEqual(context.config["networks_per_tenant"], 1) self.assertEqual(1, context.config["networks_per_tenant"])
self.assertEqual(context.config["start_cidr"], self.assertEqual(network_context.Network.DEFAULT_CONFIG["start_cidr"],
network_context.Network.DEFAULT_CONFIG["start_cidr"]) context.config["start_cidr"])
self.assertIsNone(context.config["dns_nameservers"]) self.assertIsNone(context.config["dns_nameservers"])
@mock.patch("rally.osclients.Clients") @mock.patch("rally.osclients.Clients")
@ -53,12 +53,12 @@ class NetworkTestCase(test.TestCase):
self.get_context(start_cidr="foo_cidr", networks_per_tenant=42, self.get_context(start_cidr="foo_cidr", networks_per_tenant=42,
network_create_args={"fakearg": "fake"}, network_create_args={"fakearg": "fake"},
dns_nameservers=["1.2.3.4", "5.6.7.8"])) dns_nameservers=["1.2.3.4", "5.6.7.8"]))
self.assertEqual(context.config["networks_per_tenant"], 42) self.assertEqual(42, context.config["networks_per_tenant"])
self.assertEqual(context.config["start_cidr"], "foo_cidr") self.assertEqual("foo_cidr", context.config["start_cidr"])
self.assertEqual(context.config["network_create_args"], self.assertEqual({"fakearg": "fake"},
{"fakearg": "fake"}) context.config["network_create_args"])
self.assertEqual(context.config["dns_nameservers"], self.assertEqual(("1.2.3.4", "5.6.7.8"),
("1.2.3.4", "5.6.7.8")) context.config["dns_nameservers"])
@ddt.data({}, @ddt.data({},
{"dns_nameservers": []}, {"dns_nameservers": []},

4
tests/unit/plugins/openstack/context/nova/test_flavors.py
View File

@ -59,8 +59,8 @@ class FlavorsGeneratorTestCase(test.TestCase):
flavors_ctx.setup() flavors_ctx.setup()
# Assertions # Assertions
self.assertEqual(flavors_ctx.context["flavors"], self.assertEqual({"flavor_name": {"flavor_key": "flavor_value"}},
{"flavor_name": {"flavor_key": "flavor_value"}}) flavors_ctx.context["flavors"])
mock_clients.assert_called_with(self.context["admin"]["credential"]) mock_clients.assert_called_with(self.context["admin"]["credential"])

12
tests/unit/plugins/openstack/scenarios/cinder/test_utils.py
View File

@ -109,11 +109,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.scenario._set_metadata(volume, sets=2, set_size=4) self.scenario._set_metadata(volume, sets=2, set_size=4)
calls = self.clients("cinder").volumes.set_metadata.call_args_list calls = self.clients("cinder").volumes.set_metadata.call_args_list
self.assertEqual(len(calls), 2) self.assertEqual(2, len(calls))
for call in calls: for call in calls:
call_volume, metadata = call[0] call_volume, metadata = call[0]
self.assertEqual(call_volume, volume) self.assertEqual(volume, call_volume)
self.assertEqual(len(metadata), 4) self.assertEqual(4, len(metadata))
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"cinder.set_4_metadatas_2_times") "cinder.set_4_metadatas_2_times")
@ -124,12 +124,12 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"] keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]
self.scenario._delete_metadata(volume, keys, deletes=3, delete_size=4) self.scenario._delete_metadata(volume, keys, deletes=3, delete_size=4)
calls = self.clients("cinder").volumes.delete_metadata.call_args_list calls = self.clients("cinder").volumes.delete_metadata.call_args_list
self.assertEqual(len(calls), 3) self.assertEqual(3, len(calls))
all_deleted = [] all_deleted = []
for call in calls: for call in calls:
call_volume, del_keys = call[0] call_volume, del_keys = call[0]
self.assertEqual(call_volume, volume) self.assertEqual(volume, call_volume)
self.assertEqual(len(del_keys), 4) self.assertEqual(4, len(del_keys))
for key in del_keys: for key in del_keys:
self.assertIn(key, keys) self.assertIn(key, keys)
self.assertNotIn(key, all_deleted) self.assertNotIn(key, all_deleted)

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

@ -138,7 +138,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
network_update_args) network_update_args)
self.clients("neutron").update_network.assert_called_once_with( self.clients("neutron").update_network.assert_called_once_with(
network["network"]["id"], expected_network) network["network"]["id"], expected_network)
self.assertEqual(result_network, expected_network) self.assertEqual(expected_network, result_network)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"neutron.update_network") "neutron.update_network")
@ -221,7 +221,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
subnet_update_args) subnet_update_args)
self.clients("neutron").update_subnet.assert_called_once_with( self.clients("neutron").update_subnet.assert_called_once_with(
subnet["subnet"]["id"], expected_subnet) subnet["subnet"]["id"], expected_subnet)
self.assertEqual(result_subnet, expected_subnet) self.assertEqual(expected_subnet, result_subnet)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"neutron.update_subnet") "neutron.update_subnet")
@ -337,7 +337,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
router_update_args) router_update_args)
self.clients("neutron").update_router.assert_called_once_with( self.clients("neutron").update_router.assert_called_once_with(
router["router"]["id"], expected_router) router["router"]["id"], expected_router)
self.assertEqual(result_router, expected_router) self.assertEqual(expected_router, result_router)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"neutron.update_router") "neutron.update_router")
@ -398,7 +398,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
def test_SUBNET_IP_VERSION(self): def test_SUBNET_IP_VERSION(self):
"""Curent NeutronScenario implementation supports only IPv4.""" """Curent NeutronScenario implementation supports only IPv4."""
self.assertEqual(utils.NeutronScenario.SUBNET_IP_VERSION, 4) self.assertEqual(4, utils.NeutronScenario.SUBNET_IP_VERSION)
def test_create_port(self): def test_create_port(self):
net_id = "network-id" net_id = "network-id"
@ -474,7 +474,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
result_port = self.scenario._update_port(port, port_update_args) result_port = self.scenario._update_port(port, port_update_args)
self.clients("neutron").update_port.assert_called_once_with( self.clients("neutron").update_port.assert_called_once_with(
port["port"]["id"], expected_port) port["port"]["id"], expected_port)
self.assertEqual(result_port, expected_port) self.assertEqual(expected_port, result_port)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"neutron.update_port") "neutron.update_port")
@ -613,7 +613,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
subnet_cidr_start, subnet_cidr_start,
subnets_per_network, subnets_per_network,
router_create_args) router_create_args)
self.assertEqual(actual, (network, subnets, routers)) self.assertEqual((network, subnets, routers), actual)
self.scenario._create_network.assert_called_once_with( self.scenario._create_network.assert_called_once_with(
network_create_args or {}) network_create_args or {})
self.scenario._create_subnets.assert_called_once_with( self.scenario._create_subnets.assert_called_once_with(
@ -652,7 +652,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
"fakearg": "fake"} "fakearg": "fake"}
result_pool = self.scenario._update_v1_pool(pool, **pool_update_args) result_pool = self.scenario._update_v1_pool(pool, **pool_update_args)
self.assertEqual(result_pool, expected_pool) self.assertEqual(expected_pool, result_pool)
self.clients("neutron").update_pool.assert_called_once_with( self.clients("neutron").update_pool.assert_called_once_with(
pool["pool"]["id"], expected_pool) pool["pool"]["id"], expected_pool)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -697,7 +697,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
vip_update_args = {"name": "foo", "admin_state_up": False} vip_update_args = {"name": "foo", "admin_state_up": False}
result_vip = self.scenario._update_v1_vip(vip, **vip_update_args) result_vip = self.scenario._update_v1_vip(vip, **vip_update_args)
self.assertEqual(result_vip, expected_vip) self.assertEqual(expected_vip, result_vip)
self.clients("neutron").update_vip.assert_called_once_with( self.clients("neutron").update_vip.assert_called_once_with(
vip["vip"]["id"], expected_vip) vip["vip"]["id"], expected_vip)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -784,7 +784,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
"description": "Updated", "description": "Updated",
"name": self.scenario.generate_random_name.return_value}} "name": self.scenario.generate_random_name.return_value}}
) )
self.assertEqual(result_security_group, expected_security_group) self.assertEqual(expected_security_group, result_security_group)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"neutron.update_security_group") "neutron.update_security_group")
@ -859,7 +859,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
self.scenario._create_lb_pool.assert_has_calls( self.scenario._create_lb_pool.assert_has_calls(
[mock.call(subnet, [mock.call(subnet,
**pool_create_args) for subnet in subnets]) **pool_create_args) for subnet in subnets])
self.assertEqual(resultant_pools, [pool] * len(subnets)) self.assertEqual([pool] * len(subnets), resultant_pools)
@ddt.data( @ddt.data(
{"subnet_id": "foo-id"}, {"subnet_id": "foo-id"},
@ -884,7 +884,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
resultant_pool = self.scenario._create_lb_pool( resultant_pool = self.scenario._create_lb_pool(
subnet_id=subnet_id, subnet_id=subnet_id,
**pool_create_args) **pool_create_args)
self.assertEqual(resultant_pool, pool) self.assertEqual(pool, resultant_pool)
self.clients("neutron").create_pool.assert_called_once_with( self.clients("neutron").create_pool.assert_called_once_with(
expected_pool_data) expected_pool_data)
self._test_atomic_action_timer( self._test_atomic_action_timer(
@ -910,7 +910,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
args.update(vip_create_args) args.update(vip_create_args)
expected_vip_data = {"vip": args} expected_vip_data = {"vip": args}
resultant_vip = self.scenario._create_v1_vip(pool, **vip_create_args) resultant_vip = self.scenario._create_v1_vip(pool, **vip_create_args)
self.assertEqual(resultant_vip, vip) self.assertEqual(vip, resultant_vip)
self.clients("neutron").create_vip.assert_called_once_with( self.clients("neutron").create_vip.assert_called_once_with(
expected_vip_data) expected_vip_data)
@ -933,7 +933,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
expected_fip_data = {"floatingip": args} expected_fip_data = {"floatingip": args}
resultant_fip = self.scenario._create_floatingip( resultant_fip = self.scenario._create_floatingip(
floating_network, **floating_ip_args) floating_network, **floating_ip_args)
self.assertEqual(resultant_fip, fip) self.assertEqual(fip, resultant_fip)
self.clients("neutron").create_floatingip.assert_called_once_with( self.clients("neutron").create_floatingip.assert_called_once_with(
expected_fip_data) expected_fip_data)
mock_get_network_id.assert_called_once_with(floating_network) mock_get_network_id.assert_called_once_with(floating_network)
@ -957,7 +957,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
expected_hm_data = {"health_monitor": args} expected_hm_data = {"health_monitor": args}
resultant_hm = self.scenario._create_v1_healthmonitor( resultant_hm = self.scenario._create_v1_healthmonitor(
**healthmonitor_create_args) **healthmonitor_create_args)
self.assertEqual(resultant_hm, hm) self.assertEqual(hm, resultant_hm)
self.clients("neutron").create_health_monitor.assert_called_once_with( self.clients("neutron").create_health_monitor.assert_called_once_with(
expected_hm_data) expected_hm_data)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -988,7 +988,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
healthmonitor_update_args = {"admin_state_up": False} healthmonitor_update_args = {"admin_state_up": False}
result_hm = self.scenario._update_v1_healthmonitor( result_hm = self.scenario._update_v1_healthmonitor(
hm, **healthmonitor_update_args) hm, **healthmonitor_update_args)
self.assertEqual(result_hm, expected_hm) self.assertEqual(expected_hm, result_hm)
mock_update.assert_called_once_with( mock_update.assert_called_once_with(
hm["health_monitor"]["id"], expected_hm) hm["health_monitor"]["id"], expected_hm)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
@ -1112,7 +1112,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
**bgpvpn_update_data) **bgpvpn_update_data)
self.admin_clients("neutron").update_bgpvpn.assert_called_once_with( self.admin_clients("neutron").update_bgpvpn.assert_called_once_with(
bgpvpn["bgpvpn"]["id"], expected_bgpvpn) bgpvpn["bgpvpn"]["id"], expected_bgpvpn)
self.assertEqual(result_bgpvpn, expected_bgpvpn) self.assertEqual(expected_bgpvpn, result_bgpvpn)
self._test_atomic_action_timer(self.scenario.atomic_actions(), self._test_atomic_action_timer(self.scenario.atomic_actions(),
"neutron.update_bgpvpn") "neutron.update_bgpvpn")

12
tests/unit/plugins/openstack/services/storage/test_cinder_common.py
View File

@ -158,11 +158,11 @@ class CinderMixinTestCase(test.ScenarioTestCase):
self.service.set_metadata(volume, sets=2, set_size=4) self.service.set_metadata(volume, sets=2, set_size=4)
calls = self.cinder.volumes.set_metadata.call_args_list calls = self.cinder.volumes.set_metadata.call_args_list
self.assertEqual(len(calls), 2) self.assertEqual(2, len(calls))
for call in calls: for call in calls:
call_volume, metadata = call[0] call_volume, metadata = call[0]
self.assertEqual(call_volume, volume) self.assertEqual(volume, call_volume)
self.assertEqual(len(metadata), 4) self.assertEqual(4, len(metadata))
def test_delete_metadata(self): def test_delete_metadata(self):
volume = fakes.FakeVolume() volume = fakes.FakeVolume()
@ -170,12 +170,12 @@ class CinderMixinTestCase(test.ScenarioTestCase):
keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"] keys = ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l"]
self.service.delete_metadata(volume, keys, deletes=3, delete_size=4) self.service.delete_metadata(volume, keys, deletes=3, delete_size=4)
calls = self.cinder.volumes.delete_metadata.call_args_list calls = self.cinder.volumes.delete_metadata.call_args_list
self.assertEqual(len(calls), 3) self.assertEqual(3, len(calls))
all_deleted = [] all_deleted = []
for call in calls: for call in calls:
call_volume, del_keys = call[0] call_volume, del_keys = call[0]
self.assertEqual(call_volume, volume) self.assertEqual(volume, call_volume)
self.assertEqual(len(del_keys), 4) self.assertEqual(4, len(del_keys))
for key in del_keys: for key in del_keys:
self.assertIn(key, keys) self.assertIn(key, keys)
self.assertNotIn(key, all_deleted) self.assertNotIn(key, all_deleted)

28
tests/unit/plugins/openstack/test_types.py
View File

@ -40,13 +40,13 @@ class FlavorTestCase(test.TestCase):
resource_config = {"id": "42"} resource_config = {"id": "42"}
flavor_id = types.Flavor.transform( flavor_id = types.Flavor.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(flavor_id, "42") self.assertEqual("42", flavor_id)
def test_transform_by_name(self): def test_transform_by_name(self):
resource_config = {"name": "m1.nano"} resource_config = {"name": "m1.nano"}
flavor_id = types.Flavor.transform( flavor_id = types.Flavor.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(flavor_id, "42") self.assertEqual("42", flavor_id)
def test_transform_by_name_no_match(self): def test_transform_by_name_no_match(self):
resource_config = {"name": "m1.medium"} resource_config = {"name": "m1.medium"}
@ -64,7 +64,7 @@ class FlavorTestCase(test.TestCase):
resource_config = {"regex": "m(1|2)\.nano"} resource_config = {"regex": "m(1|2)\.nano"}
flavor_id = types.Flavor.transform( flavor_id = types.Flavor.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(flavor_id, "42") self.assertEqual("42", flavor_id)
def test_transform_by_regex_multiple_match(self): def test_transform_by_regex_multiple_match(self):
resource_config = {"regex": "^m1"} resource_config = {"regex": "^m1"}
@ -97,13 +97,13 @@ class EC2FlavorTestCase(test.TestCase):
resource_config = {"name": "m1.nano"} resource_config = {"name": "m1.nano"}
flavor_name = types.EC2Flavor.transform( flavor_name = types.EC2Flavor.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(flavor_name, "m1.nano") self.assertEqual("m1.nano", flavor_name)
def test_transform_by_id(self): def test_transform_by_id(self):
resource_config = {"id": "2"} resource_config = {"id": "2"}
flavor_name = types.EC2Flavor.transform( flavor_name = types.EC2Flavor.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(flavor_name, "m1.nano") self.assertEqual("m1.nano", flavor_name)
def test_transform_by_id_no_match(self): def test_transform_by_id_no_match(self):
resource_config = {"id": "4"} resource_config = {"id": "4"}
@ -138,13 +138,13 @@ class GlanceImageTestCase(test.TestCase):
resource_config = {"id": "100"} resource_config = {"id": "100"}
image_id = types.GlanceImage.transform( image_id = types.GlanceImage.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(image_id, "100") self.assertEqual("100", image_id)
def test_transform_by_name(self): def test_transform_by_name(self):
resource_config = {"name": "^cirros-0.3.4-uec$"} resource_config = {"name": "^cirros-0.3.4-uec$"}
image_id = types.GlanceImage.transform( image_id = types.GlanceImage.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(image_id, "100") self.assertEqual("100", image_id)
def test_transform_by_name_no_match(self): def test_transform_by_name_no_match(self):
resource_config = {"name": "cirros-0.3.4-uec-boot"} resource_config = {"name": "cirros-0.3.4-uec-boot"}
@ -162,7 +162,7 @@ class GlanceImageTestCase(test.TestCase):
resource_config = {"regex": "-uec$"} resource_config = {"regex": "-uec$"}
image_id = types.GlanceImage.transform( image_id = types.GlanceImage.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(image_id, "100") self.assertEqual("100", image_id)
def test_transform_by_regex_match_multiple(self): def test_transform_by_regex_match_multiple(self):
resource_config = {"regex": "^cirros"} resource_config = {"regex": "^cirros"}
@ -225,13 +225,13 @@ class EC2ImageTestCase(test.TestCase):
resource_config = {"name": "^cirros-0.3.4-uec$"} resource_config = {"name": "^cirros-0.3.4-uec$"}
ec2_image_id = types.EC2Image.transform( ec2_image_id = types.EC2Image.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(ec2_image_id, "200") self.assertEqual("200", ec2_image_id)
def test_transform_by_id(self): def test_transform_by_id(self):
resource_config = {"id": "100"} resource_config = {"id": "100"}
ec2_image_id = types.EC2Image.transform( ec2_image_id = types.EC2Image.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(ec2_image_id, "200") self.assertEqual("200", ec2_image_id)
def test_transform_by_id_no_match(self): def test_transform_by_id_no_match(self):
resource_config = {"id": "101"} resource_config = {"id": "101"}
@ -261,7 +261,7 @@ class EC2ImageTestCase(test.TestCase):
resource_config = {"regex": "-uec$"} resource_config = {"regex": "-uec$"}
ec2_image_id = types.EC2Image.transform( ec2_image_id = types.EC2Image.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(ec2_image_id, "200") self.assertEqual("200", ec2_image_id)
def test_transform_by_regex_match_multiple(self): def test_transform_by_regex_match_multiple(self):
resource_config = {"regex": "^cirros"} resource_config = {"regex": "^cirros"}
@ -288,13 +288,13 @@ class VolumeTypeTestCase(test.TestCase):
resource_config = {"id": 100} resource_config = {"id": 100}
volumetype_id = types.VolumeType.transform( volumetype_id = types.VolumeType.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(volumetype_id, 100) self.assertEqual(100, volumetype_id)
def test_transform_by_name(self): def test_transform_by_name(self):
resource_config = {"name": "lvmdriver-1"} resource_config = {"name": "lvmdriver-1"}
volumetype_id = types.VolumeType.transform( volumetype_id = types.VolumeType.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(volumetype_id, 100) self.assertEqual(100, volumetype_id)
def test_transform_by_name_no_match(self): def test_transform_by_name_no_match(self):
resource_config = {"name": "nomatch-1"} resource_config = {"name": "nomatch-1"}
@ -306,7 +306,7 @@ class VolumeTypeTestCase(test.TestCase):
resource_config = {"regex": "^lvm.*-1"} resource_config = {"regex": "^lvm.*-1"}
volumetype_id = types.VolumeType.transform( volumetype_id = types.VolumeType.transform(
clients=self.clients, resource_config=resource_config) clients=self.clients, resource_config=resource_config)
self.assertEqual(volumetype_id, 100) self.assertEqual(100, volumetype_id)
def test_transform_by_regex_no_match(self): def test_transform_by_regex_no_match(self):
resource_config = {"regex": "dd"} resource_config = {"regex": "dd"}

22
tests/unit/plugins/openstack/test_validators.py
View File

@ -315,7 +315,7 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
clients, clients,
"flavor") "flavor")
self.assertTrue(result[0].is_valid, result[0].msg) self.assertTrue(result[0].is_valid, result[0].msg)
self.assertEqual(result[1], "flavor") self.assertEqual("flavor", result[1])
mock_flavor_transform.assert_called_once_with( mock_flavor_transform.assert_called_once_with(
clients=clients, resource_config=self.config["args"]["flavor"]) clients=clients, resource_config=self.config["args"]["flavor"])
@ -326,7 +326,7 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
clients, clients,
"flavor") "flavor")
self.assertTrue(result[0].is_valid, result[0].msg) self.assertTrue(result[0].is_valid, result[0].msg)
self.assertEqual(result[1], "flavor") self.assertEqual("flavor", result[1])
mock_flavor_transform.assert_called_with( mock_flavor_transform.assert_called_with(
clients=clients, resource_config=self.config["args"]["flavor"]) clients=clients, resource_config=self.config["args"]["flavor"])
clients.nova().flavors.get.assert_called_with(flavor="flavor_id") clients.nova().flavors.get.assert_called_with(flavor="flavor_id")
@ -365,8 +365,8 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
}}, self.credentials, "image") }}, self.credentials, "image")
self.assertIsInstance(result[0], validators.ValidationResult) self.assertIsInstance(result[0], validators.ValidationResult)
self.assertTrue(result[0].is_valid) self.assertTrue(result[0].is_valid)
self.assertEqual(result[0].msg, "") self.assertEqual("", result[0].msg)
self.assertEqual(result[1], image) self.assertEqual(image, result[1])
clients = mock.Mock() clients = mock.Mock()
clients.glance().images.get().to_dict.return_value = { clients.glance().images.get().to_dict.return_value = {
@ -393,8 +393,8 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
"fake_param") "fake_param")
self.assertIsInstance(result[0], validators.ValidationResult) self.assertIsInstance(result[0], validators.ValidationResult)
self.assertFalse(result[0].is_valid) self.assertFalse(result[0].is_valid)
self.assertEqual(result[0].msg, self.assertEqual("Parameter fake_param is not specified.",
"Parameter fake_param is not specified.") result[0].msg)
self.assertIsNone(result[1]) self.assertIsNone(result[1])
# 'image_name' is not in 'image_context' # 'image_name' is not in 'image_context'
@ -413,7 +413,7 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
"image") "image")
self.assertIsNotNone(result) self.assertIsNotNone(result)
self.assertTrue(result[0].is_valid) self.assertTrue(result[0].is_valid)
self.assertEqual(result[1], image) self.assertEqual(image, result[1])
mock_glance_image_transform.assert_called_once_with( mock_glance_image_transform.assert_called_once_with(
clients=clients, resource_config=config["args"]["image"]) clients=clients, resource_config=config["args"]["image"])
@ -432,8 +432,8 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
"image") "image")
self.assertIsInstance(result[0], validators.ValidationResult) self.assertIsInstance(result[0], validators.ValidationResult)
self.assertFalse(result[0].is_valid) self.assertFalse(result[0].is_valid)
self.assertEqual(result[0].msg, self.assertEqual("Image '%s' not found" % config["args"]["image"],
"Image '%s' not found" % config["args"]["image"]) result[0].msg)
self.assertIsNone(result[1]) self.assertIsNone(result[1])
mock_glance_image_transform.assert_called_once_with( mock_glance_image_transform.assert_called_once_with(
clients=clients, resource_config=config["args"]["image"]) clients=clients, resource_config=config["args"]["image"])
@ -445,8 +445,8 @@ class ImageValidOnFlavorValidatorTestCase(test.TestCase):
"image") "image")
self.assertIsInstance(result[0], validators.ValidationResult) self.assertIsInstance(result[0], validators.ValidationResult)
self.assertFalse(result[0].is_valid) self.assertFalse(result[0].is_valid)
self.assertEqual(result[0].msg, self.assertEqual("Image '%s' not found" % config["args"]["image"],
"Image '%s' not found" % config["args"]["image"]) result[0].msg)
self.assertIsNone(result[1]) self.assertIsNone(result[1])
mock_glance_image_transform.assert_called_with( mock_glance_image_transform.assert_called_with(
clients=clients, resource_config=config["args"]["image"]) clients=clients, resource_config=config["args"]["image"])

24
tests/unit/plugins/openstack/verification/tempest/test_config.py
View File

@ -72,9 +72,9 @@ class TempestConfigfileManagerTestCase(test.TestCase):
service_type: "sahara"} service_type: "sahara"}
self.tempest.conf.add_section("data-processing") self.tempest.conf.add_section("data-processing")
self.tempest._configure_data_processing() self.tempest._configure_data_processing()
self.assertEqual( self.assertEqual(service_type,
self.tempest.conf.get( self.tempest.conf.get("data-processing",
"data-processing", "catalog_type"), service_type) "catalog_type"))
@ddt.data( @ddt.data(
# The prefix "ex_" is abbreviation of "expected" # The prefix "ex_" is abbreviation of "expected"
@ -158,11 +158,11 @@ class TempestConfigfileManagerTestCase(test.TestCase):
self.tempest.conf.add_section("network") self.tempest.conf.add_section("network")
self.tempest._configure_network() self.tempest._configure_network()
self.assertEqual(self.tempest.conf.get("network", "public_network_id"), self.assertEqual("test_id",
"test_id") self.tempest.conf.get("network", "public_network_id"))
self.assertEqual(self.tempest.conf.get("network", self.assertEqual("test_name",
"floating_network_name"), self.tempest.conf.get("network",
"test_name") "floating_network_name"))
def test__configure_network_if_nova(self): def test__configure_network_if_nova(self):
self.tempest.available_services = ["nova"] self.tempest.available_services = ["nova"]
@ -195,9 +195,9 @@ class TempestConfigfileManagerTestCase(test.TestCase):
self.tempest._configure_network_feature_enabled() self.tempest._configure_network_feature_enabled()
client.list_ext.assert_called_once_with("extensions", "/extensions", client.list_ext.assert_called_once_with("extensions", "/extensions",
retrieve_all=True) retrieve_all=True)
self.assertEqual(self.tempest.conf.get( self.assertEqual("dvr,extra_dhcp_opt,extraroute",
"network-feature-enabled", "api_extensions"), self.tempest.conf.get("network-feature-enabled",
"dvr,extra_dhcp_opt,extraroute") "api_extensions"))
def test__configure_object_storage(self): def test__configure_object_storage(self):
self.tempest.conf.add_section("object-storage") self.tempest.conf.add_section("object-storage")
@ -262,7 +262,7 @@ class TempestConfigfileManagerTestCase(test.TestCase):
fake_extra_conf = {"section2": {"option2": "value2"}} fake_extra_conf = {"section2": {"option2": "value2"}}
self.tempest.create("/path/to/fake/conf", fake_extra_conf) self.tempest.create("/path/to/fake/conf", fake_extra_conf)
self.assertEqual(configure_something_method.call_count, 1) self.assertEqual(1, configure_something_method.call_count)
self.assertIn(("option2", "value2"), self.assertIn(("option2", "value2"),
self.tempest.conf.items("section2")) self.tempest.conf.items("section2"))
mock_open.assert_called_once_with("/path/to/fake/conf", "w") mock_open.assert_called_once_with("/path/to/fake/conf", "w")

16
tests/unit/plugins/openstack/verification/tempest/test_context.py
View File

@ -136,9 +136,9 @@ class TempestContextTestCase(test.TestCase):
glanceclient = self.context.clients.glance() glanceclient = self.context.clients.glance()
novaclient = self.context.clients.nova() novaclient = self.context.clients.nova()
self.assertEqual(glanceclient.images.create.call_count, 0) self.assertEqual(0, glanceclient.images.create.call_count)
self.assertEqual(novaclient.flavors.create.call_count, 0) self.assertEqual(0, novaclient.flavors.create.call_count)
self.assertEqual(mock_neutron_wrapper_create_network.call_count, 0) self.assertEqual(0, mock_neutron_wrapper_create_network.call_count)
def test__create_tempest_roles(self): def test__create_tempest_roles(self):
role1 = CONF.tempest.swift_operator_role role1 = CONF.tempest.swift_operator_role
@ -153,7 +153,7 @@ class TempestContextTestCase(test.TestCase):
fakes.FakeFlavor(name=role4)] fakes.FakeFlavor(name=role4)]
self.context._create_tempest_roles() self.context._create_tempest_roles()
self.assertEqual(client.roles.create.call_count, 2) self.assertEqual(2, client.roles.create.call_count)
created_roles = [role.name for role in self.context._created_roles] created_roles = [role.name for role in self.context._created_roles]
self.assertIn(role3, created_roles) self.assertIn(role3, created_roles)
@ -201,7 +201,7 @@ class TempestContextTestCase(test.TestCase):
self.context.conf.set("compute", "flavor_ref", "") self.context.conf.set("compute", "flavor_ref", "")
self.context._configure_option("compute", "flavor_ref", self.context._configure_option("compute", "flavor_ref",
helper_method=helper_method, flv_ram=64) helper_method=helper_method, flv_ram=64)
self.assertEqual(helper_method.call_count, 1) self.assertEqual(1, helper_method.call_count)
result = self.context.conf.get("compute", "flavor_ref") result = self.context.conf.get("compute", "flavor_ref")
self.assertEqual("id1", result) self.assertEqual("id1", result)
@ -274,7 +274,7 @@ class TempestContextTestCase(test.TestCase):
self.context._cleanup_tempest_roles() self.context._cleanup_tempest_roles()
client = self.context.clients.keystone() client = self.context.clients.keystone()
self.assertEqual(client.roles.delete.call_count, 2) self.assertEqual(2, client.roles.delete.call_count)
@mock.patch("rally.plugins.openstack.services.image.image.Image") @mock.patch("rally.plugins.openstack.services.image.image.Image")
def test__cleanup_images(self, mock_image): def test__cleanup_images(self, mock_image):
@ -309,7 +309,7 @@ class TempestContextTestCase(test.TestCase):
self.context._cleanup_flavors() self.context._cleanup_flavors()
client = self.context.clients.nova() client = self.context.clients.nova()
self.assertEqual(client.flavors.delete.call_count, 3) self.assertEqual(3, client.flavors.delete.call_count)
self.assertEqual("", self.context.conf.get("compute", "flavor_ref")) self.assertEqual("", self.context.conf.get("compute", "flavor_ref"))
self.assertEqual("", self.context.conf.get("compute", self.assertEqual("", self.context.conf.get("compute",
@ -325,7 +325,7 @@ class TempestContextTestCase(test.TestCase):
self.context.conf.set("compute", "fixed_network_name", "net-12345") self.context.conf.set("compute", "fixed_network_name", "net-12345")
self.context._cleanup_network_resources() self.context._cleanup_network_resources()
self.assertEqual(mock_neutron_wrapper_delete_network.call_count, 1) self.assertEqual(1, mock_neutron_wrapper_delete_network.call_count)
self.assertEqual("", self.context.conf.get("compute", self.assertEqual("", self.context.conf.get("compute",
"fixed_network_name")) "fixed_network_name"))

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

@ -39,7 +39,7 @@ class NeutronWrapperTestCase(test.TestCase):
return network.NeutronWrapper(mock.Mock(), self.owner, config=kwargs) return network.NeutronWrapper(mock.Mock(), self.owner, config=kwargs)
def test_SUBNET_IP_VERSION(self): def test_SUBNET_IP_VERSION(self):
self.assertEqual(network.NeutronWrapper.SUBNET_IP_VERSION, 4) self.assertEqual(4, network.NeutronWrapper.SUBNET_IP_VERSION)
@mock.patch("rally.plugins.openstack.wrappers.network.generate_cidr") @mock.patch("rally.plugins.openstack.wrappers.network.generate_cidr")
def test__generate_cidr(self, mock_generate_cidr): def test__generate_cidr(self, mock_generate_cidr):
@ -48,18 +48,18 @@ class NeutronWrapperTestCase(test.TestCase):
lambda start_cidr: start_cidr + next(cidrs) 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(3, service._generate_cidr())
self.assertEqual(service._generate_cidr(), 4) self.assertEqual(4, service._generate_cidr())
self.assertEqual(service._generate_cidr(), 5) self.assertEqual(5, service._generate_cidr())
self.assertEqual(service._generate_cidr(), 6) self.assertEqual(6, service._generate_cidr())
self.assertEqual(service._generate_cidr(), 7) self.assertEqual(7, service._generate_cidr())
self.assertEqual(mock_generate_cidr.mock_calls, self.assertEqual([mock.call(start_cidr=3)] * 5,
[mock.call(start_cidr=3)] * 5) mock_generate_cidr.mock_calls)
def test_external_networks(self): def test_external_networks(self):
wrap = self.get_wrapper() wrap = self.get_wrapper()
wrap.client.list_networks.return_value = {"networks": "foo_networks"} wrap.client.list_networks.return_value = {"networks": "foo_networks"}
self.assertEqual(wrap.external_networks, "foo_networks") self.assertEqual("foo_networks", wrap.external_networks)
wrap.client.list_networks.assert_called_once_with( wrap.client.list_networks.assert_called_once_with(
**{"router:external": True}) **{"router:external": True})
@ -80,7 +80,7 @@ class NeutronWrapperTestCase(test.TestCase):
"subnets": "foo_subnets"} "subnets": "foo_subnets"}
wrap.client.show_network.return_value = {"network": neutron_net} wrap.client.show_network.return_value = {"network": neutron_net}
net = wrap.get_network(net_id="foo_id") net = wrap.get_network(net_id="foo_id")
self.assertEqual(net, expected_net) self.assertEqual(expected_net, net)
wrap.client.show_network.assert_called_once_with("foo_id") wrap.client.show_network.assert_called_once_with("foo_id")
wrap.client.show_network.side_effect = ( wrap.client.show_network.side_effect = (
@ -90,7 +90,7 @@ class NeutronWrapperTestCase(test.TestCase):
wrap.client.list_networks.return_value = {"networks": [neutron_net]} wrap.client.list_networks.return_value = {"networks": [neutron_net]}
net = wrap.get_network(name="foo_name") net = wrap.get_network(name="foo_name")
self.assertEqual(net, expected_net) self.assertEqual(expected_net, net)
wrap.client.list_networks.assert_called_once_with(name="foo_name") wrap.client.list_networks.assert_called_once_with(name="foo_name")
wrap.client.list_networks.return_value = {"networks": []} wrap.client.list_networks.return_value = {"networks": []}
@ -114,7 +114,7 @@ class NeutronWrapperTestCase(test.TestCase):
"tenant_id": tenant, "tenant_id": tenant,
"protocol": "HTTP", "protocol": "HTTP",
"name": self.owner.generate_random_name.return_value}}) "name": self.owner.generate_random_name.return_value}})
self.assertEqual(resultant_pool, expected_pool) self.assertEqual(expected_pool, resultant_pool)
def test_create_network(self): def test_create_network(self):
service = self.get_wrapper() service = self.get_wrapper()
@ -126,14 +126,13 @@ class NeutronWrapperTestCase(test.TestCase):
service.client.create_network.assert_called_once_with({ service.client.create_network.assert_called_once_with({
"network": {"tenant_id": "foo_tenant", "network": {"tenant_id": "foo_tenant",
"name": self.owner.generate_random_name.return_value}}) "name": self.owner.generate_random_name.return_value}})
self.assertEqual(net, self.assertEqual({"id": "foo_id",
{"id": "foo_id",
"name": self.owner.generate_random_name.return_value, "name": self.owner.generate_random_name.return_value,
"status": "foo_status", "status": "foo_status",
"external": False, "external": False,
"tenant_id": "foo_tenant", "tenant_id": "foo_tenant",
"router_id": None, "router_id": None,
"subnets": []}) "subnets": []}, net)
def test_create_network_with_subnets(self): def test_create_network_with_subnets(self):
subnets_num = 4 subnets_num = 4
@ -155,15 +154,14 @@ class NeutronWrapperTestCase(test.TestCase):
service.client.create_network.assert_called_once_with({ service.client.create_network.assert_called_once_with({
"network": {"tenant_id": "foo_tenant", "network": {"tenant_id": "foo_tenant",
"name": self.owner.generate_random_name.return_value}}) "name": self.owner.generate_random_name.return_value}})
self.assertEqual(net, self.assertEqual({"id": "foo_id",
{"id": "foo_id",
"name": self.owner.generate_random_name.return_value, "name": self.owner.generate_random_name.return_value,
"status": "foo_status", "status": "foo_status",
"external": False, "external": False,
"router_id": None, "router_id": None,
"tenant_id": "foo_tenant", "tenant_id": "foo_tenant",
"subnets": ["subnet-%d" % i "subnets": ["subnet-%d" % i
for i in range(subnets_num)]}) for i in range(subnets_num)]}, net)
self.assertEqual( self.assertEqual(
service.client.create_subnet.mock_calls, service.client.create_subnet.mock_calls,
[mock.call({"subnet": [mock.call({"subnet":
@ -184,14 +182,13 @@ class NeutronWrapperTestCase(test.TestCase):
"name": self.owner.generate_random_name.return_value, "name": self.owner.generate_random_name.return_value,
"status": "foo_status"}} "status": "foo_status"}}
net = service.create_network("foo_tenant", add_router=True) net = service.create_network("foo_tenant", add_router=True)
self.assertEqual(net, self.assertEqual({"id": "foo_id",
{"id": "foo_id",
"name": self.owner.generate_random_name.return_value, "name": self.owner.generate_random_name.return_value,
"status": "foo_status", "status": "foo_status",
"external": False, "external": False,
"tenant_id": "foo_tenant", "tenant_id": "foo_tenant",
"router_id": "foo_router", "router_id": "foo_router",
"subnets": []}) "subnets": []}, net)
service.create_router.assert_called_once_with(external=True, service.create_router.assert_called_once_with(external=True,
tenant_id="foo_tenant") tenant_id="foo_tenant")
@ -209,14 +206,13 @@ class NeutronWrapperTestCase(test.TestCase):
net = service.create_network("foo_tenant", add_router=True, net = service.create_network("foo_tenant", add_router=True,
subnets_num=subnets_num, subnets_num=subnets_num,
dns_nameservers=["foo_nameservers"]) dns_nameservers=["foo_nameservers"])
self.assertEqual(net, self.assertEqual({"id": "foo_id",
{"id": "foo_id",
"name": self.owner.generate_random_name.return_value, "name": self.owner.generate_random_name.return_value,
"status": "foo_status", "status": "foo_status",
"external": False, "external": False,
"tenant_id": "foo_tenant", "tenant_id": "foo_tenant",
"router_id": "foo_router", "router_id": "foo_router",
"subnets": ["foo_subnet"] * subnets_num}) "subnets": ["foo_subnet"] * subnets_num}, net)
service.create_router.assert_called_once_with(external=True, service.create_router.assert_called_once_with(external=True,
tenant_id="foo_tenant") tenant_id="foo_tenant")
self.assertEqual( self.assertEqual(
@ -241,12 +237,12 @@ class NeutronWrapperTestCase(test.TestCase):
service.client.delete_network.return_value = "foo_deleted" service.client.delete_network.return_value = "foo_deleted"
result = service.delete_network({"id": "foo_id", "router_id": None, result = service.delete_network({"id": "foo_id", "router_id": None,
"subnets": []}) "subnets": []})
self.assertEqual(result, "foo_deleted") self.assertEqual("foo_deleted", result)
self.assertEqual(service.client.remove_gateway_router.mock_calls, []) self.assertEqual([], service.client.remove_gateway_router.mock_calls)
self.assertEqual( self.assertEqual(
service.client.remove_interface_router.mock_calls, []) [], service.client.remove_interface_router.mock_calls)
self.assertEqual(service.client.delete_router.mock_calls, []) self.assertEqual([], service.client.delete_router.mock_calls)
self.assertEqual(service.client.delete_subnet.mock_calls, []) self.assertEqual([], service.client.delete_subnet.mock_calls)
service.client.delete_network.assert_called_once_with("foo_id") service.client.delete_network.assert_called_once_with("foo_id")
def test_delete_v1_pool(self): def test_delete_v1_pool(self):
@ -275,7 +271,7 @@ class NeutronWrapperTestCase(test.TestCase):
{"id": "foo_id", "router_id": "foo_router", "subnets": subnets, {"id": "foo_id", "router_id": "foo_router", "subnets": subnets,
"lb_pools": []}) "lb_pools": []})
self.assertEqual(result, "foo_deleted") self.assertEqual("foo_deleted", result)
self.assertEqual( self.assertEqual(
service.client.remove_network_from_dhcp_agent.mock_calls, service.client.remove_network_from_dhcp_agent.mock_calls,
[mock.call(agent_id, "foo_id") for agent_id in agents]) [mock.call(agent_id, "foo_id") for agent_id in agents])
@ -294,7 +290,7 @@ class NeutronWrapperTestCase(test.TestCase):
def test_list_networks(self): def test_list_networks(self):
service = self.get_wrapper() service = self.get_wrapper()
service.client.list_networks.return_value = {"networks": "foo_nets"} service.client.list_networks.return_value = {"networks": "foo_nets"}
self.assertEqual(service.list_networks(), "foo_nets") self.assertEqual("foo_nets", service.list_networks())
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")
@ -316,7 +312,7 @@ class NeutronWrapperTestCase(test.TestCase):
) )
fip = wrap.create_floating_ip(tenant_id="foo_tenant", fip = wrap.create_floating_ip(tenant_id="foo_tenant",
port_id="port_id") port_id="port_id")
self.assertEqual(fip, {"id": "fip_id", "ip": "fip_ip"}) self.assertEqual({"id": "fip_id", "ip": "fip_ip"}, fip)
wrap.get_network = mock.Mock( wrap.get_network = mock.Mock(
return_value={"id": "foo_net", "external": True}) return_value={"id": "foo_net", "external": True})
@ -335,8 +331,8 @@ class NeutronWrapperTestCase(test.TestCase):
wrap = self.get_wrapper() wrap = self.get_wrapper()
wrap.delete_floating_ip("fip_id") wrap.delete_floating_ip("fip_id")
wrap.delete_floating_ip("fip_id", ignored_kwarg="bar") wrap.delete_floating_ip("fip_id", ignored_kwarg="bar")
self.assertEqual(wrap.client.delete_floatingip.mock_calls, self.assertEqual([mock.call("fip_id")] * 2,
[mock.call("fip_id")] * 2) wrap.client.delete_floatingip.mock_calls)
@mock.patch(SVC + "NeutronWrapper.external_networks") @mock.patch(SVC + "NeutronWrapper.external_networks")
def test_create_router(self, mock_neutron_wrapper_external_networks): def test_create_router(self, mock_neutron_wrapper_external_networks):
@ -349,7 +345,7 @@ class NeutronWrapperTestCase(test.TestCase):
router = wrap.create_router() router = wrap.create_router()
wrap.client.create_router.assert_called_once_with( wrap.client.create_router.assert_called_once_with(
{"router": {"name": self.owner.generate_random_name.return_value}}) {"router": {"name": self.owner.generate_random_name.return_value}})
self.assertEqual(router, "foo_router") self.assertEqual("foo_router", router)
router = wrap.create_router(external=True, foo="bar") router = wrap.create_router(external=True, foo="bar")
wrap.client.create_router.assert_called_with( wrap.client.create_router.assert_called_with(
@ -367,7 +363,7 @@ class NeutronWrapperTestCase(test.TestCase):
wrap.client.create_port.assert_called_once_with( wrap.client.create_port.assert_called_once_with(
{"port": {"network_id": "foo_net", {"port": {"network_id": "foo_net",
"name": self.owner.generate_random_name.return_value}}) "name": self.owner.generate_random_name.return_value}})
self.assertEqual(port, "foo_port") self.assertEqual("foo_port", port)
port = wrap.create_port("foo_net", foo="bar") port = wrap.create_port("foo_net", foo="bar")
wrap.client.create_port.assert_called_with( wrap.client.create_port.assert_called_with(
@ -394,16 +390,16 @@ class FunctionsTestCase(test.TestCase):
def test_generate_cidr(self): def test_generate_cidr(self):
with mock.patch("rally.plugins.openstack.wrappers.network.cidr_incr", with mock.patch("rally.plugins.openstack.wrappers.network.cidr_incr",
iter(range(1, 4))): iter(range(1, 4))):
self.assertEqual(network.generate_cidr(), "10.2.1.0/24") self.assertEqual("10.2.1.0/24", network.generate_cidr())
self.assertEqual(network.generate_cidr(), "10.2.2.0/24") self.assertEqual("10.2.2.0/24", network.generate_cidr())
self.assertEqual(network.generate_cidr(), "10.2.3.0/24") self.assertEqual("10.2.3.0/24", network.generate_cidr())
with mock.patch("rally.plugins.openstack.wrappers.network.cidr_incr", with mock.patch("rally.plugins.openstack.wrappers.network.cidr_incr",
iter(range(1, 4))): iter(range(1, 4))):
start_cidr = "1.1.0.0/26" start_cidr = "1.1.0.0/26"
self.assertEqual(network.generate_cidr(start_cidr), "1.1.0.64/26") self.assertEqual("1.1.0.64/26", network.generate_cidr(start_cidr))
self.assertEqual(network.generate_cidr(start_cidr), "1.1.0.128/26") self.assertEqual("1.1.0.128/26", network.generate_cidr(start_cidr))
self.assertEqual(network.generate_cidr(start_cidr), "1.1.0.192/26") self.assertEqual("1.1.0.192/26", network.generate_cidr(start_cidr))
def test_wrap(self): def test_wrap(self):
mock_clients = mock.Mock() mock_clients = mock.Mock()

13
tests/unit/test_hacking.py
View File

@ -156,8 +156,8 @@ class HackingTestCase(test.TestCase):
) )
@ddt.unpack @ddt.unpack
def test_assert_equal_type(self, line, result): def test_assert_equal_type(self, line, result):
self.assertEqual( self.assertEqual(result,
len(list(checks.assert_equal_type(line, line, "f"))), result) len(list(checks.assert_equal_type(line, line, "f"))))
@ddt.data( @ddt.data(
{"line": "self.assertEqual(A, None)", "result": 1}, {"line": "self.assertEqual(A, None)", "result": 1},
@ -167,8 +167,8 @@ class HackingTestCase(test.TestCase):
@ddt.unpack @ddt.unpack
def test_assert_equal_none(self, line, result): def test_assert_equal_none(self, line, result):
self.assertEqual( self.assertEqual(result,
len(list(checks.assert_equal_none(line, line, "f"))), result) len(list(checks.assert_equal_none(line, line, "f"))))
@ddt.data( @ddt.data(
{"line": "self.assertNotEqual(A, None)", "result": 1}, {"line": "self.assertNotEqual(A, None)", "result": 1},
@ -178,8 +178,9 @@ class HackingTestCase(test.TestCase):
@ddt.unpack @ddt.unpack
def test_assert_not_equal_none(self, line, result): def test_assert_not_equal_none(self, line, result):
self.assertEqual( self.assertEqual(result,
len(list(checks.assert_not_equal_none(line, line, "f"))), result) len(list(checks.assert_not_equal_none(line,
line, "f"))))
def test_assert_true_or_false_with_in_or_not_in(self): def test_assert_true_or_false_with_in_or_not_in(self):
good_lines = [ good_lines = [

11
tests/unit/test_test_ddt.py
View File

@ -29,7 +29,7 @@ class Test(object):
tree = ast.parse(code).body[0] tree = ast.parse(code).body[0]
visitor = test_ddt.DDTDecoratorChecker() visitor = test_ddt.DDTDecoratorChecker()
visitor.visit(tree) visitor.visit(tree)
self.assertEqual(visitor.errors, {}) self.assertEqual({}, visitor.errors)
def test_fail(self): def test_fail(self):
code = """ code = """
@ -41,8 +41,7 @@ class Test(object):
tree = ast.parse(code).body[0] tree = ast.parse(code).body[0]
visitor = test_ddt.DDTDecoratorChecker() visitor = test_ddt.DDTDecoratorChecker()
visitor.visit(tree) visitor.visit(tree)
self.assertEqual( self.assertEqual({"Test": {"lineno": 3,
visitor.errors, "message": "Class Test has functions that use DDT, "
{"Test": {"lineno": 3, "but is not decorated with `ddt.ddt`"}},
"message": "Class Test has functions that use DDT, " visitor.errors)
"but is not decorated with `ddt.ddt`"}})