Fixed order of arguments in assertEqual

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

tests/functional/test_cli_task.py

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

tests/unit/plugins/openstack/cleanup/test_base.py

@@ -30,8 +30,8 @@ class ResourceDecoratorTestCase(test.TestCase):
         class Fake(object):
             pass
 
-        self.assertEqual(Fake._service, "service")
-        self.assertEqual(Fake._resource, "res")
+        self.assertEqual("service", Fake._service)
+        self.assertEqual("res", Fake._resource)
 
 
 class ResourceManagerTestCase(test.TestCase):
@@ -86,7 +86,7 @@ class ResourceManagerTestCase(test.TestCase):
 
         mock_resource_manager__manager.assert_has_calls(
             [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)
     def test_is_deleted_exceptions(self, mock_resource_manager__manager):

tests/unit/plugins/openstack/cleanup/test_manager.py

@@ -56,9 +56,9 @@ class SeekAndDestroyTestCase(test.TestCase):
             mock_resource)
 
         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)
-        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!
         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[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.SeekAndDestroy._get_cached_client" % BASE)

tests/unit/plugins/openstack/context/keystone/test_users.py

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

tests/unit/plugins/openstack/context/manila/test_manila_security_services.py

@@ -89,7 +89,7 @@ class SecurityServicesTestCase(test.ScenarioTestCase):
 
         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.assertEqual(445, inst.get_order())
         self.assertEqual(CONTEXT_NAME, inst.get_name())

tests/unit/plugins/openstack/context/network/test_network.py

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

tests/unit/plugins/openstack/context/nova/test_flavors.py

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

tests/unit/plugins/openstack/scenarios/cinder/test_utils.py

@@ -109,11 +109,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
 
         self.scenario._set_metadata(volume, sets=2, set_size=4)
         calls = self.clients("cinder").volumes.set_metadata.call_args_list
-        self.assertEqual(len(calls), 2)
+        self.assertEqual(2, len(calls))
         for call in calls:
             call_volume, metadata = call[0]
-            self.assertEqual(call_volume, volume)
-            self.assertEqual(len(metadata), 4)
+            self.assertEqual(volume, call_volume)
+            self.assertEqual(4, len(metadata))
 
         self._test_atomic_action_timer(self.scenario.atomic_actions(),
                                        "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"]
         self.scenario._delete_metadata(volume, keys, deletes=3, delete_size=4)
         calls = self.clients("cinder").volumes.delete_metadata.call_args_list
-        self.assertEqual(len(calls), 3)
+        self.assertEqual(3, len(calls))
         all_deleted = []
         for call in calls:
             call_volume, del_keys = call[0]
-            self.assertEqual(call_volume, volume)
-            self.assertEqual(len(del_keys), 4)
+            self.assertEqual(volume, call_volume)
+            self.assertEqual(4, len(del_keys))
             for key in del_keys:
                 self.assertIn(key, keys)
                 self.assertNotIn(key, all_deleted)

tests/unit/plugins/openstack/scenarios/neutron/test_utils.py

@@ -138,7 +138,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                                                        network_update_args)
         self.clients("neutron").update_network.assert_called_once_with(
             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(),
                                        "neutron.update_network")
 
@@ -221,7 +221,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                                                      subnet_update_args)
         self.clients("neutron").update_subnet.assert_called_once_with(
             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(),
                                        "neutron.update_subnet")
 
@@ -337,7 +337,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                                                      router_update_args)
         self.clients("neutron").update_router.assert_called_once_with(
             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(),
                                        "neutron.update_router")
 
@@ -398,7 +398,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
 
     def test_SUBNET_IP_VERSION(self):
         """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):
         net_id = "network-id"
@@ -474,7 +474,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
         result_port = self.scenario._update_port(port, port_update_args)
         self.clients("neutron").update_port.assert_called_once_with(
             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(),
                                        "neutron.update_port")
 
@@ -613,7 +613,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                                                          subnet_cidr_start,
                                                          subnets_per_network,
                                                          router_create_args)
-        self.assertEqual(actual, (network, subnets, routers))
+        self.assertEqual((network, subnets, routers), actual)
         self.scenario._create_network.assert_called_once_with(
             network_create_args or {})
         self.scenario._create_subnets.assert_called_once_with(
@@ -652,7 +652,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                             "fakearg": "fake"}
 
         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(
             pool["pool"]["id"], expected_pool)
         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}
 
         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(
             vip["vip"]["id"], expected_vip)
         self._test_atomic_action_timer(self.scenario.atomic_actions(),
@@ -784,7 +784,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                 "description": "Updated",
                 "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(),
                                        "neutron.update_security_group")
 
@@ -859,7 +859,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
             self.scenario._create_lb_pool.assert_has_calls(
                 [mock.call(subnet,
                            **pool_create_args) for subnet in subnets])
-            self.assertEqual(resultant_pools, [pool] * len(subnets))
+            self.assertEqual([pool] * len(subnets), resultant_pools)
 
     @ddt.data(
         {"subnet_id": "foo-id"},
@@ -884,7 +884,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
         resultant_pool = self.scenario._create_lb_pool(
             subnet_id=subnet_id,
             **pool_create_args)
-        self.assertEqual(resultant_pool, pool)
+        self.assertEqual(pool, resultant_pool)
         self.clients("neutron").create_pool.assert_called_once_with(
             expected_pool_data)
         self._test_atomic_action_timer(
@@ -910,7 +910,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
         args.update(vip_create_args)
         expected_vip_data = {"vip": 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(
             expected_vip_data)
 
@@ -933,7 +933,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
         expected_fip_data = {"floatingip": args}
         resultant_fip = self.scenario._create_floatingip(
             floating_network, **floating_ip_args)
-        self.assertEqual(resultant_fip, fip)
+        self.assertEqual(fip, resultant_fip)
         self.clients("neutron").create_floatingip.assert_called_once_with(
             expected_fip_data)
         mock_get_network_id.assert_called_once_with(floating_network)
@@ -957,7 +957,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
         expected_hm_data = {"health_monitor": args}
         resultant_hm = self.scenario._create_v1_healthmonitor(
             **healthmonitor_create_args)
-        self.assertEqual(resultant_hm, hm)
+        self.assertEqual(hm, resultant_hm)
         self.clients("neutron").create_health_monitor.assert_called_once_with(
             expected_hm_data)
         self._test_atomic_action_timer(self.scenario.atomic_actions(),
@@ -988,7 +988,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
         healthmonitor_update_args = {"admin_state_up": False}
         result_hm = self.scenario._update_v1_healthmonitor(
             hm, **healthmonitor_update_args)
-        self.assertEqual(result_hm, expected_hm)
+        self.assertEqual(expected_hm, result_hm)
         mock_update.assert_called_once_with(
             hm["health_monitor"]["id"], expected_hm)
         self._test_atomic_action_timer(self.scenario.atomic_actions(),
@@ -1112,7 +1112,7 @@ class NeutronScenarioTestCase(test.ScenarioTestCase):
                                                      **bgpvpn_update_data)
         self.admin_clients("neutron").update_bgpvpn.assert_called_once_with(
             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(),
                                        "neutron.update_bgpvpn")
 

tests/unit/plugins/openstack/services/storage/test_cinder_common.py

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

tests/unit/plugins/openstack/test_types.py

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

tests/unit/plugins/openstack/test_validators.py

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

tests/unit/plugins/openstack/verification/tempest/test_config.py

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

tests/unit/plugins/openstack/verification/tempest/test_context.py

@@ -136,9 +136,9 @@ class TempestContextTestCase(test.TestCase):
         glanceclient = self.context.clients.glance()
         novaclient = self.context.clients.nova()
 
-        self.assertEqual(glanceclient.images.create.call_count, 0)
-        self.assertEqual(novaclient.flavors.create.call_count, 0)
-        self.assertEqual(mock_neutron_wrapper_create_network.call_count, 0)
+        self.assertEqual(0, glanceclient.images.create.call_count)
+        self.assertEqual(0, novaclient.flavors.create.call_count)
+        self.assertEqual(0, mock_neutron_wrapper_create_network.call_count)
 
     def test__create_tempest_roles(self):
         role1 = CONF.tempest.swift_operator_role
@@ -153,7 +153,7 @@ class TempestContextTestCase(test.TestCase):
                                            fakes.FakeFlavor(name=role4)]
 
         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]
         self.assertIn(role3, created_roles)
@@ -201,7 +201,7 @@ class TempestContextTestCase(test.TestCase):
         self.context.conf.set("compute", "flavor_ref", "")
         self.context._configure_option("compute", "flavor_ref",
                                        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")
         self.assertEqual("id1", result)
@@ -274,7 +274,7 @@ class TempestContextTestCase(test.TestCase):
 
         self.context._cleanup_tempest_roles()
         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")
     def test__cleanup_images(self, mock_image):
@@ -309,7 +309,7 @@ class TempestContextTestCase(test.TestCase):
 
         self.context._cleanup_flavors()
         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",
@@ -325,7 +325,7 @@ class TempestContextTestCase(test.TestCase):
         self.context.conf.set("compute", "fixed_network_name", "net-12345")
 
         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",
                                                    "fixed_network_name"))
 

tests/unit/plugins/openstack/wrappers/test_network.py

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

tests/unit/test_hacking.py

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

tests/unit/test_test_ddt.py

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