diff --git a/tests/functional/test_cli_task.py b/tests/functional/test_cli_task.py index 3694b2b065..ba3aff2d43 100644 --- a/tests/functional/test_cli_task.py +++ b/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") diff --git a/tests/unit/cli/commands/test_plugin.py b/tests/unit/cli/commands/test_plugin.py index 4738519365..b43d99fccd 100644 --- a/tests/unit/cli/commands/test_plugin.py +++ b/tests/unit/cli/commands/test_plugin.py @@ -112,7 +112,7 @@ class PluginCommandsTestCase(test.TestCase): def test_show_not_found(self, name, namespace, text): with utils.StdOutCapture() as out: plugin_cmd.PluginCommands().show(None, name, namespace) - self.assertEqual(out.getvalue(), text) + self.assertEqual(text, out.getvalue()) @mock.patch("rally.cli.commands.plugin.PluginCommands._print_plugins_list") def test_show_many(self, mock_plugin_commands__print_plugins_list): @@ -121,7 +121,7 @@ class PluginCommandsTestCase(test.TestCase): "get_all") as mock_plugin_get_all: mock_plugin_get_all.return_value = [self.Plugin2, self.Plugin3] plugin_cmd.PluginCommands().show(None, "p", "p2_ns") - self.assertEqual(out.getvalue(), "Multiple plugins found:\n") + self.assertEqual("Multiple plugins found:\n", out.getvalue()) mock_plugin_get_all.assert_called_once_with(platform="p2_ns") mock_plugin_commands__print_plugins_list.assert_called_once_with([ @@ -144,7 +144,7 @@ class PluginCommandsTestCase(test.TestCase): with utils.StdOutCapture() as out: plugin_cmd.PluginCommands().list(None, name, namespace) - self.assertEqual(out.getvalue(), text) + self.assertEqual(text, out.getvalue()) @mock.patch("rally.cli.commands.plugin.PluginCommands._print_plugins_list") def test_list(self, mock_plugin_commands__print_plugins_list): diff --git a/tests/unit/cli/commands/test_task.py b/tests/unit/cli/commands/test_task.py index 3b965b93ea..72a3f0551e 100644 --- a/tests/unit/cli/commands/test_task.py +++ b/tests/unit/cli/commands/test_task.py @@ -61,7 +61,7 @@ class TaskCommandsTestCase(test.TestCase): ] task_conf = self.task._load_and_validate_task( self.real_api, "in_task", raw_args=input_args) - self.assertEqual(task_conf, {"ab": 2}) + self.assertEqual({"ab": 2}, task_conf) mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value, @@ -70,7 +70,7 @@ class TaskCommandsTestCase(test.TestCase): task_conf = self.task._load_and_validate_task( self.real_api, "in_task", raw_args=input_args, args_file="any_file") - self.assertEqual(task_conf, {"ab": 2}) + self.assertEqual({"ab": 2}, task_conf) mock_open.side_effect = [ mock.mock_open(read_data=input_task).return_value, @@ -79,7 +79,7 @@ class TaskCommandsTestCase(test.TestCase): task_conf = self.task._load_and_validate_task( self.real_api, "in_task", raw_args="test=2", args_file="any_file") - self.assertEqual(task_conf, {"ab": 2}) + self.assertEqual({"ab": 2}, task_conf) @mock.patch("rally.cli.commands.task.open", create=True) def test__load_task_wrong_task_args_file(self, mock_open): @@ -740,7 +740,7 @@ class TaskCommandsTestCase(test.TestCase): def test_old_report_exceptions(self, mock_open, mock_path_exists): ret = self.task._old_report(self.real_api, tasks="/tmp/task.json", out="/tmp/tmp.hsml") - self.assertEqual(ret, 1) + self.assertEqual(1, ret) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) def test_report(self, mock_path_exists): diff --git a/tests/unit/cli/test_cliutils.py b/tests/unit/cli/test_cliutils.py index fdbfdcd719..cc4d2697c6 100644 --- a/tests/unit/cli/test_cliutils.py +++ b/tests/unit/cli/test_cliutils.py @@ -149,7 +149,7 @@ class CliUtilsTestCase(test.TestCase): def test_make_header(self): h1 = cliutils.make_header("msg", size=4, symbol="=") - self.assertEqual(h1, "====\nmsg\n====\n") + self.assertEqual("====\nmsg\n====\n", h1) def test_make_table_header(self): actual = cliutils.make_table_header("Response Times (sec)", 40) @@ -253,7 +253,7 @@ class CliUtilsTestCase(test.TestCase): pass mock_obj = fake_class() result = cliutils._methods_of(mock_obj) - self.assertEqual(result, []) + self.assertEqual([], result) def _unregister_opts(self): CONF.reset() @@ -267,19 +267,19 @@ class CliUtilsTestCase(test.TestCase): side_effect=exceptions.RallyException("config_file")) def test_run_fails(self, mock_rally_api_api): ret = cliutils.run(["rally", "version"], self.categories) - self.assertEqual(ret, 2) + self.assertEqual(2, ret) mock_rally_api_api.assert_called_once_with( config_args=["version"], skip_db_check=True) @mock.patch("rally.api.API.check_db_revision") def test_run_version(self, mock_api_check_db_revision): ret = cliutils.run(["rally", "version"], self.categories) - self.assertEqual(ret, 0) + self.assertEqual(0, ret) @mock.patch("rally.api.API.check_db_revision") def test_run_bash_completion(self, mock_api_check_db_revision): ret = cliutils.run(["rally", "bash-completion"], self.categories) - self.assertEqual(ret, 0) + self.assertEqual(0, ret) @mock.patch("rally.api.API.check_db_revision") @mock.patch("rally.common.db.api.task_get", @@ -289,7 +289,7 @@ class CliUtilsTestCase(test.TestCase): ret = cliutils.run(["rally", "task", "status", "%s" % FAKE_TASK_UUID], self.categories) self.assertTrue(mock_task_get.called) - self.assertEqual(ret, 1) + self.assertEqual(1, ret) @mock.patch("rally.api.API.check_db_revision") @mock.patch("rally.cli.cliutils.validate_args", @@ -299,7 +299,7 @@ class CliUtilsTestCase(test.TestCase): ret = cliutils.run(["rally", "task", "status", "%s" % FAKE_TASK_UUID], self.categories) self.assertTrue(mock_validate_args.called) - self.assertEqual(ret, 1) + self.assertEqual(1, ret) @mock.patch("rally.api.API.check_db_revision") def test_run_failed_to_open_file(self, mock_api_check_db_revision): @@ -940,7 +940,7 @@ class ValidateArgsTest(test.TestCase): alias_fn = mock.Mock(name="alias_fn") cmd_name = "test-command" wrapped = cliutils.alias(cmd_name) - self.assertEqual(wrapped(alias_fn).alias, cmd_name) + self.assertEqual(cmd_name, wrapped(alias_fn).alias) class CategoryParserTestCase(test.TestCase): diff --git a/tests/unit/cli/test_envutils.py b/tests/unit/cli/test_envutils.py index 559ba976e3..ff9bbf0462 100644 --- a/tests/unit/cli/test_envutils.py +++ b/tests/unit/cli/test_envutils.py @@ -36,8 +36,8 @@ class EnvUtilsTestCase(test.TestCase): with mock.patch("sys.stdout", new_callable=moves.StringIO) as mock_stdout: test_function() - self.assertEqual(mock_stdout.getvalue(), - "Missing argument: --test_missing_arg\n") + self.assertEqual("Missing argument: --test_missing_arg\n", + mock_stdout.getvalue()) @mock.patch.dict(os.environ, values={envutils.ENV_DEPLOYMENT: "my_deployment_id"}, @@ -91,7 +91,7 @@ class EnvUtilsTestCase(test.TestCase): envutils.clear_global(envutils.ENV_DEPLOYMENT) mock_update_env_file.assert_called_once_with(os.path.expanduser( "~/.rally/globals"), envutils.ENV_DEPLOYMENT, "\n") - self.assertEqual(os.environ, {}) + self.assertEqual({}, os.environ) @mock.patch.dict(os.environ, values={envutils.ENV_DEPLOYMENT: "test_deployment_id", @@ -102,7 +102,7 @@ class EnvUtilsTestCase(test.TestCase): return_value=True) def test_clear_env(self, mock_update_env_file, mock_path_exists): envutils.clear_env() - self.assertEqual(os.environ, {}) + self.assertEqual({}, os.environ) @mock.patch.dict(os.environ, {"OS_AUTH_URL": "fake_auth_url", "OS_USERNAME": "fake_username", diff --git a/tests/unit/common/db/test_api.py b/tests/unit/common/db/test_api.py index 40da07fc3a..7afab99348 100644 --- a/tests/unit/common/db/test_api.py +++ b/tests/unit/common/db/test_api.py @@ -68,27 +68,27 @@ class TasksTestCase(test.DBTestCase): db_task = self._get_task(task["uuid"]) self.assertIsNotNone(db_task["uuid"]) self.assertIsNotNone(db_task["id"]) - self.assertEqual(db_task["status"], consts.TaskStatus.INIT) + self.assertEqual(consts.TaskStatus.INIT, db_task["status"]) def test_task_create_with_tag(self): task = self._create_task(values={"tags": ["test_tag"]}) db_task = self._get_task(task["uuid"]) self.assertIsNotNone(db_task["uuid"]) self.assertIsNotNone(db_task["id"]) - self.assertEqual(db_task["status"], consts.TaskStatus.INIT) - self.assertEqual(db_task["tags"], ["test_tag"]) + self.assertEqual(consts.TaskStatus.INIT, db_task["status"]) + self.assertEqual(["test_tag"], db_task["tags"]) def test_task_create_without_uuid(self): _uuid = "19be8589-48b0-4af1-a369-9bebaaa563ab" task = self._create_task({"uuid": _uuid}) db_task = self._get_task(task["uuid"]) - self.assertEqual(db_task["uuid"], _uuid) + self.assertEqual(_uuid, db_task["uuid"]) def test_task_update(self): task = self._create_task({}) db.task_update(task["uuid"], {"status": consts.TaskStatus.CRASHED}) db_task = self._get_task(task["uuid"]) - self.assertEqual(db_task["status"], consts.TaskStatus.CRASHED) + self.assertEqual(consts.TaskStatus.CRASHED, db_task["status"]) def test_task_update_with_tag(self): task = self._create_task({}) @@ -97,8 +97,8 @@ class TasksTestCase(test.DBTestCase): "tags": ["test_tag"] }) db_task = self._get_task(task["uuid"]) - self.assertEqual(db_task["status"], consts.TaskStatus.CRASHED) - self.assertEqual(db_task["tags"], ["test_tag"]) + self.assertEqual(consts.TaskStatus.CRASHED, db_task["status"]) + self.assertEqual(["test_tag"], db_task["tags"]) def test_task_update_not_found(self): self.assertRaises(exceptions.TaskNotFound, @@ -116,7 +116,7 @@ class TasksTestCase(test.DBTestCase): for status in consts.TaskStatus: db.task_update(_uuid, {"status": status}) db_task = self._get_task(_uuid) - self.assertEqual(db_task["status"], status) + self.assertEqual(status, db_task["status"]) def test_task_list_empty(self): self.assertEqual([], db.task_list()) @@ -308,8 +308,8 @@ class TasksTestCase(test.DBTestCase): sla_results=sla_results) detailed_task = db.task_get(task_id, detailed=True) - self.assertEqual(len(detailed_task["subtasks"]), 1) - self.assertEqual(len(detailed_task["subtasks"][0]["workloads"]), 1) + self.assertEqual(1, len(detailed_task["subtasks"])) + self.assertEqual(1, len(detailed_task["subtasks"][0]["workloads"])) workload = detailed_task["subtasks"][0]["workloads"][0] self.assertEqual([ {"error": "anError", "timestamp": 10, "duration": 1, @@ -550,71 +550,71 @@ class DeploymentTestCase(test.DBTestCase): def test_deployment_create(self): deploy = db.deployment_create({"config": {"opt": "val"}}) deploys = db.deployment_list() - self.assertEqual(len(deploys), 1) - self.assertEqual(deploy["uuid"], deploys[0]["uuid"]) - self.assertEqual(deploy["status"], consts.DeployStatus.DEPLOY_INIT) - self.assertEqual(deploy["config"], {"opt": "val"}) - self.assertEqual(deploy["credentials"], {}) + self.assertEqual(1, len(deploys)) + self.assertEqual(deploys[0]["uuid"], deploy["uuid"]) + self.assertEqual(consts.DeployStatus.DEPLOY_INIT, deploy["status"]) + self.assertEqual({"opt": "val"}, deploy["config"]) + self.assertEqual({}, deploy["credentials"]) def test_deployment_create_several(self): # Create a deployment deploys = db.deployment_list() - self.assertEqual(len(deploys), 0) + self.assertEqual(0, len(deploys)) deploy_one = db.deployment_create({"config": {"opt1": "val1"}}) deploys = db.deployment_list() - self.assertEqual(len(deploys), 1) - self.assertEqual(deploy_one["uuid"], deploys[0]["uuid"]) - self.assertEqual(deploy_one["status"], consts.DeployStatus.DEPLOY_INIT) - self.assertEqual(deploy_one["config"], {"opt1": "val1"}) + self.assertEqual(1, len(deploys)) + self.assertEqual(deploys[0]["uuid"], deploy_one["uuid"]) + self.assertEqual(consts.DeployStatus.DEPLOY_INIT, deploy_one["status"]) + self.assertEqual({"opt1": "val1"}, deploy_one["config"]) # Create another deployment and sure that they are different deploy_two = db.deployment_create({"config": {"opt2": "val2"}}) deploys = db.deployment_list() - self.assertEqual(len(deploys), 2) + self.assertEqual(2, len(deploys)) self.assertEqual(set([deploy_one["uuid"], deploy_two["uuid"]]), set([deploy["uuid"] for deploy in deploys])) self.assertNotEqual(deploy_one["uuid"], deploy_two["uuid"]) - self.assertEqual(deploy_two["status"], consts.DeployStatus.DEPLOY_INIT) - self.assertEqual(deploy_two["config"], {"opt2": "val2"}) + self.assertEqual(consts.DeployStatus.DEPLOY_INIT, deploy_two["status"]) + self.assertEqual({"opt2": "val2"}, deploy_two["config"]) def test_deployment_update(self): credentials = { "openstack": [{"admin": {"foo": "bar"}, "users": ["foo_user"]}]} deploy = db.deployment_create({}) - self.assertEqual(deploy["config"], {}) - self.assertEqual(deploy["credentials"], {}) + self.assertEqual({}, deploy["config"]) + self.assertEqual({}, deploy["credentials"]) update_deploy = db.deployment_update( deploy["uuid"], {"config": {"opt": "val"}, "credentials": copy.deepcopy(credentials)}) - self.assertEqual(update_deploy["uuid"], deploy["uuid"]) - self.assertEqual(update_deploy["config"], {"opt": "val"}) - self.assertEqual(update_deploy["credentials"], credentials) + self.assertEqual(deploy["uuid"], update_deploy["uuid"]) + self.assertEqual({"opt": "val"}, update_deploy["config"]) + self.assertEqual(credentials, update_deploy["credentials"]) get_deploy = db.deployment_get(deploy["uuid"]) - self.assertEqual(get_deploy["uuid"], deploy["uuid"]) - self.assertEqual(get_deploy["config"], {"opt": "val"}) - self.assertEqual(update_deploy["credentials"], credentials) + self.assertEqual(deploy["uuid"], get_deploy["uuid"]) + self.assertEqual({"opt": "val"}, get_deploy["config"]) + self.assertEqual(credentials, update_deploy["credentials"]) def test_deployment_update_several(self): # Create a deployment and update it deploy_one = db.deployment_create({}) - self.assertEqual(deploy_one["config"], {}) + self.assertEqual({}, deploy_one["config"]) update_deploy_one = db.deployment_update( deploy_one["uuid"], {"config": {"opt1": "val1"}}) - self.assertEqual(update_deploy_one["uuid"], deploy_one["uuid"]) - self.assertEqual(update_deploy_one["config"], {"opt1": "val1"}) + self.assertEqual(deploy_one["uuid"], update_deploy_one["uuid"]) + self.assertEqual({"opt1": "val1"}, update_deploy_one["config"]) get_deploy_one = db.deployment_get(deploy_one["uuid"]) - self.assertEqual(get_deploy_one["uuid"], deploy_one["uuid"]) - self.assertEqual(get_deploy_one["config"], {"opt1": "val1"}) + self.assertEqual(deploy_one["uuid"], get_deploy_one["uuid"]) + self.assertEqual({"opt1": "val1"}, get_deploy_one["config"]) # Create another deployment deploy_two = db.deployment_create({}) update_deploy_two = db.deployment_update( deploy_two["uuid"], {"config": {"opt2": "val2"}}) - self.assertEqual(update_deploy_two["uuid"], deploy_two["uuid"]) - self.assertEqual(update_deploy_two["config"], {"opt2": "val2"}) + self.assertEqual(deploy_two["uuid"], update_deploy_two["uuid"]) + self.assertEqual({"opt2": "val2"}, update_deploy_two["config"]) get_deploy_one_again = db.deployment_get(deploy_one["uuid"]) - self.assertEqual(get_deploy_one_again["uuid"], deploy_one["uuid"]) - self.assertEqual(get_deploy_one_again["config"], {"opt1": "val1"}) + self.assertEqual(deploy_one["uuid"], get_deploy_one_again["uuid"]) + self.assertEqual({"opt1": "val1"}, get_deploy_one_again["config"]) def test_deployment_get(self): deploy_one = db.deployment_create({"config": {"opt1": "val1"}}) @@ -622,8 +622,8 @@ class DeploymentTestCase(test.DBTestCase): get_deploy_one = db.deployment_get(deploy_one["uuid"]) get_deploy_two = db.deployment_get(deploy_two["uuid"]) self.assertNotEqual(get_deploy_one["uuid"], get_deploy_two["uuid"]) - self.assertEqual(get_deploy_one["config"], {"opt1": "val1"}) - self.assertEqual(get_deploy_two["config"], {"opt2": "val2"}) + self.assertEqual({"opt1": "val1"}, get_deploy_one["config"]) + self.assertEqual({"opt2": "val2"}, get_deploy_two["config"]) def test_deployment_get_not_found(self): self.assertRaises(exceptions.DeploymentNotFound, @@ -646,17 +646,17 @@ class DeploymentTestCase(test.DBTestCase): deploy_three = db.deployment_create({"name": "deployment_name"}) deploys = db.deployment_list(status=consts.DeployStatus.DEPLOY_INIT) deploys.sort(key=lambda x: x["id"]) - self.assertEqual(len(deploys), 2) - self.assertEqual(deploys[0]["uuid"], deploy_one["uuid"]) + self.assertEqual(2, len(deploys)) + self.assertEqual(deploy_one["uuid"], deploys[0]["uuid"]) deploys = db.deployment_list(status=consts.DeployStatus.DEPLOY_FAILED) - self.assertEqual(len(deploys), 1) - self.assertEqual(deploys[0]["uuid"], deploy_two["uuid"]) + self.assertEqual(1, len(deploys)) + self.assertEqual(deploy_two["uuid"], deploys[0]["uuid"]) deploys = db.deployment_list( status=consts.DeployStatus.DEPLOY_FINISHED) - self.assertEqual(len(deploys), 0) + self.assertEqual(0, len(deploys)) deploys = db.deployment_list(name="deployment_name") - self.assertEqual(deploys[0]["uuid"], deploy_three["uuid"]) - self.assertEqual(len(deploys), 1) + self.assertEqual(deploy_three["uuid"], deploys[0]["uuid"]) + self.assertEqual(1, len(deploys)) def test_deployment_list_parent(self): deploy = db.deployment_create({}) @@ -673,8 +673,8 @@ class DeploymentTestCase(test.DBTestCase): deploy_two = db.deployment_create({}) db.deployment_delete(deploy_two["uuid"]) deploys = db.deployment_list() - self.assertEqual(len(deploys), 1) - self.assertEqual(deploys[0]["uuid"], deploy_one["uuid"]) + self.assertEqual(1, len(deploys)) + self.assertEqual(deploy_one["uuid"], deploys[0]["uuid"]) def test_deployment_delete_not_found(self): self.assertRaises(exceptions.DeploymentNotFound, @@ -699,18 +699,18 @@ class ResourceTestCase(test.DBTestCase): }) resources = db.resource_get_all(deployment["uuid"]) self.assertTrue(resource["id"]) - self.assertEqual(len(resources), 1) - self.assertTrue(resource["id"], resources[0]["id"]) - self.assertEqual(resource["deployment_uuid"], deployment["uuid"]) - self.assertEqual(resource["provider_name"], "fakeprovider") - self.assertEqual(resource["type"], "faketype") + self.assertEqual(1, len(resources)) + self.assertTrue(resources[0]["id"], resource["id"]) + self.assertEqual(deployment["uuid"], resource["deployment_uuid"]) + self.assertEqual("fakeprovider", resource["provider_name"]) + self.assertEqual("faketype", resource["type"]) def test_delete(self): deployment = db.deployment_create({}) res = db.resource_create({"deployment_uuid": deployment["uuid"]}) db.resource_delete(res["id"]) resources = db.resource_get_all(deployment["uuid"]) - self.assertEqual(len(resources), 0) + self.assertEqual(0, len(resources)) def test_delete_not_found(self): self.assertRaises(exceptions.ResourceNotFound, @@ -726,7 +726,7 @@ class ResourceTestCase(test.DBTestCase): self.assertEqual(sorted([res1["id"], res2["id"]]), sorted([r["id"] for r in resources])) resources = db.resource_get_all(deployment0["uuid"]) - self.assertEqual(len(resources), 1) + self.assertEqual(1, len(resources)) self.assertEqual(res0["id"], resources[0]["id"]) def test_get_all_by_provider_name(self): @@ -741,11 +741,11 @@ class ResourceTestCase(test.DBTestCase): }) resources = db.resource_get_all(deployment["uuid"], provider_name="one") - self.assertEqual(len(resources), 1) + self.assertEqual(1, len(resources)) self.assertEqual(res_one["id"], resources[0]["id"]) resources = db.resource_get_all(deployment["uuid"], provider_name="two") - self.assertEqual(len(resources), 1) + self.assertEqual(1, len(resources)) self.assertEqual(res_two["id"], resources[0]["id"]) def test_get_all_by_provider_type(self): @@ -759,10 +759,10 @@ class ResourceTestCase(test.DBTestCase): "type": "two", }) resources = db.resource_get_all(deployment["uuid"], type="one") - self.assertEqual(len(resources), 1) + self.assertEqual(1, len(resources)) self.assertEqual(res_one["id"], resources[0]["id"]) resources = db.resource_get_all(deployment["uuid"], type="two") - self.assertEqual(len(resources), 1) + self.assertEqual(1, len(resources)) self.assertEqual(res_two["id"], resources[0]["id"]) @@ -787,7 +787,7 @@ class VerifierTestCase(test.DBTestCase): v1 = db.verifier_update(v1["uuid"], status="foo") vs = db.verifier_list(status="foo") - self.assertEqual(len(vs), 1) + self.assertEqual(1, len(vs)) self.assertEqual(v1["uuid"], vs[0]["uuid"]) def test_verifier_delete(self): @@ -840,16 +840,16 @@ class VerificationTestCase(test.DBTestCase): sorted([v["uuid"] for v in vs])) vs = db.verification_list(self.verifier["uuid"], deploy["uuid"]) - self.assertEqual(len(vs), 1) + self.assertEqual(1, len(vs)) self.assertEqual(v1["uuid"], vs[0]["uuid"]) vs = db.verification_list(tags=["bar"]) - self.assertEqual(len(vs), 1) + self.assertEqual(1, len(vs)) self.assertEqual(v1["uuid"], vs[0]["uuid"]) v2 = db.verification_update(v2["uuid"], status="foo") vs = db.verification_list(status="foo") - self.assertEqual(len(vs), 1) + self.assertEqual(1, len(vs)) self.assertEqual(v2["uuid"], vs[0]["uuid"]) def test_verification_delete(self): diff --git a/tests/unit/common/db/test_migrations.py b/tests/unit/common/db/test_migrations.py index 8d390fbe81..6fbba68482 100644 --- a/tests/unit/common/db/test_migrations.py +++ b/tests/unit/common/db/test_migrations.py @@ -230,7 +230,7 @@ class MigrationWalkTestCase(rtest.DBTestCase, def assertColumnCount(self, engine, table, columns): t = db_utils.get_table(engine, table) - self.assertEqual(len(t.columns), len(columns)) + self.assertEqual(len(columns), len(t.columns)) def assertColumnNotExists(self, engine, table, column): t = db_utils.get_table(engine, table) @@ -419,7 +419,7 @@ class MigrationWalkTestCase(rtest.DBTestCase, "name": self._08e1515a576c_deployment_uuid, "config": six.b("{}"), "enum_deployments_status": - consts.DeployStatus.DEPLOY_FINISHED, + consts.DeployStatus.DEPLOY_FINISHED, "credentials": six.b(json.dumps([])), "users": six.b(json.dumps([])) }]) @@ -544,21 +544,21 @@ class MigrationWalkTestCase(rtest.DBTestCase, where(task_table.c.uuid == self._e654a0648db0_task_uuid) ).fetchall() - self.assertEqual(len(tasks_found), 1) + self.assertEqual(1, len(tasks_found)) task_found = tasks_found[0] - self.assertEqual(task_found.uuid, self._e654a0648db0_task_uuid) - self.assertEqual(task_found.deployment_uuid, - self._e654a0648db0_deployment_uuid) - self.assertEqual(task_found.status, consts.TaskStatus.FINISHED) + self.assertEqual(self._e654a0648db0_task_uuid, task_found.uuid) + self.assertEqual(self._e654a0648db0_deployment_uuid, + task_found.deployment_uuid) + self.assertEqual(consts.TaskStatus.FINISHED, task_found.status) # NOTE(ikhudoshyn): if for all workloads success == True - self.assertEqual(task_found.pass_sla, False) + self.assertFalse(task_found.pass_sla) # NOTE(ikhudoshyn): sum of all full_durations of all workloads - self.assertEqual(task_found.task_duration, 142) + self.assertEqual(142, task_found.task_duration) # NOTE(ikhudoshyn): we have no info on validation duration in old # schema - self.assertEqual(task_found.validation_duration, 0) - self.assertEqual(json.loads(task_found.validation_result), {}) + self.assertEqual(0, task_found.validation_duration) + self.assertEqual({}, json.loads(task_found.validation_result)) # Check subtask @@ -568,16 +568,16 @@ class MigrationWalkTestCase(rtest.DBTestCase, self._e654a0648db0_task_uuid) ).fetchall() - self.assertEqual(len(subtasks_found), 1) + self.assertEqual(1, len(subtasks_found)) subtask_found = subtasks_found[0] - self.assertEqual(subtask_found.task_uuid, - self._e654a0648db0_task_uuid) + self.assertEqual(self._e654a0648db0_task_uuid, + subtask_found.task_uuid) # NOTE(ikhudoshyn): if for all workloads success == True - self.assertEqual(subtask_found.pass_sla, False) + self.assertFalse(subtask_found.pass_sla) # NOTE(ikhudoshyn): sum of all full_durations of all workloads - self.assertEqual(subtask_found.duration, 142) + self.assertEqual(142, subtask_found.duration) self._e654a0648db0_subtask_uuid = subtask_found.uuid @@ -588,9 +588,9 @@ class MigrationWalkTestCase(rtest.DBTestCase, where(tag_table.c.uuid == self._e654a0648db0_task_uuid) ).fetchall() - self.assertEqual(len(tags_found), 1) - self.assertEqual(tags_found[0].tag, "test_tag") - self.assertEqual(tags_found[0].type, consts.TagType.TASK) + self.assertEqual(1, len(tags_found)) + self.assertEqual("test_tag", tags_found[0].tag) + self.assertEqual(consts.TagType.TASK, tags_found[0].type) # Check workload @@ -600,43 +600,36 @@ class MigrationWalkTestCase(rtest.DBTestCase, self._e654a0648db0_task_uuid) ).fetchall() - self.assertEqual(len(workloads_found), 1) + self.assertEqual(1, len(workloads_found)) workload_found = workloads_found[0] - self.assertEqual(workload_found.task_uuid, - self._e654a0648db0_task_uuid) + self.assertEqual(self._e654a0648db0_task_uuid, + workload_found.task_uuid) - self.assertEqual(workload_found.subtask_uuid, - self._e654a0648db0_subtask_uuid) + self.assertEqual(self._e654a0648db0_subtask_uuid, + workload_found.subtask_uuid) - self.assertEqual(workload_found.name, "test_scenario") - self.assertEqual(workload_found.position, 0) - self.assertEqual(workload_found.runner_type, "theRunner") - self.assertEqual(workload_found.runner, - json.dumps({"type": "theRunner"})) - self.assertEqual(workload_found.sla, - json.dumps({"s": "S"})) - self.assertEqual(workload_found.args, - json.dumps({"a": "A"})) - self.assertEqual(workload_found.context, - json.dumps({"c": "C"})) - self.assertEqual(workload_found.sla_results, - json.dumps({ - "sla": [ - {"success": True}, - {"success": False} - ] - })) - self.assertEqual(workload_found.context_execution, - json.dumps({})) - self.assertEqual(workload_found.load_duration, 42) - self.assertEqual(workload_found.full_duration, 142) - self.assertEqual(workload_found.min_duration, 1) - self.assertEqual(workload_found.max_duration, 8) - self.assertEqual(workload_found.total_iteration_count, 3) - self.assertEqual(workload_found.failed_iteration_count, 1) - self.assertEqual(workload_found.pass_sla, False) + self.assertEqual("test_scenario", workload_found.name) + self.assertEqual(0, workload_found.position) + self.assertEqual("theRunner", workload_found.runner_type) + self.assertEqual(json.dumps({"type": "theRunner"}), + workload_found.runner) + self.assertEqual(json.dumps({"s": "S"}), workload_found.sla) + self.assertEqual(json.dumps({"a": "A"}), workload_found.args) + self.assertEqual(json.dumps({"c": "C"}), workload_found.context) + self.assertEqual(json.dumps({ + "sla": [{"success": True}, + {"success": False}] + }), workload_found.sla_results) + self.assertEqual(json.dumps({}), workload_found.context_execution) + self.assertEqual(42, workload_found.load_duration) + self.assertEqual(142, workload_found.full_duration) + self.assertEqual(1, workload_found.min_duration) + self.assertEqual(8, workload_found.max_duration) + self.assertEqual(3, workload_found.total_iteration_count) + self.assertEqual(1, workload_found.failed_iteration_count) + self.assertFalse(workload_found.pass_sla) self._e654a0648db0_workload_uuid = workload_found.uuid @@ -648,23 +641,22 @@ class MigrationWalkTestCase(rtest.DBTestCase, self._e654a0648db0_task_uuid) ).fetchall() - self.assertEqual(len(workloaddata_found), 1) + self.assertEqual(1, len(workloaddata_found)) wloaddata_found = workloaddata_found[0] - self.assertEqual(wloaddata_found.task_uuid, - self._e654a0648db0_task_uuid) + self.assertEqual(self._e654a0648db0_task_uuid, + wloaddata_found.task_uuid) - self.assertEqual(wloaddata_found.workload_uuid, - self._e654a0648db0_workload_uuid) + self.assertEqual(self._e654a0648db0_workload_uuid, + wloaddata_found.workload_uuid) - self.assertEqual(wloaddata_found.chunk_order, 0) - self.assertEqual(wloaddata_found.chunk_size, 0) - self.assertEqual(wloaddata_found.compressed_chunk_size, 0) - self.assertEqual(wloaddata_found.iteration_count, 3) - self.assertEqual(wloaddata_found.failed_iteration_count, 1) + self.assertEqual(0, wloaddata_found.chunk_order) + self.assertEqual(0, wloaddata_found.chunk_size) + self.assertEqual(0, wloaddata_found.compressed_chunk_size) + self.assertEqual(3, wloaddata_found.iteration_count) + self.assertEqual(1, wloaddata_found.failed_iteration_count) self.assertEqual( - wloaddata_found.chunk_data, json.dumps( { "raw": [ @@ -673,7 +665,7 @@ class MigrationWalkTestCase(rtest.DBTestCase, {"duration": 8}, ] } - ) + ), wloaddata_found.chunk_data ) # Delete all stuff created at _pre_upgrade step @@ -939,7 +931,7 @@ class MigrationWalkTestCase(rtest.DBTestCase, verifications_table.insert(), [{"uuid": vuuid, "deployment_uuid": - self._484cd9413e66_deployment_uuid, + self._484cd9413e66_deployment_uuid, "status": vstatus, "set_name": verification["set_name"], "tests": verification["total"]["tests"], @@ -1286,7 +1278,7 @@ class MigrationWalkTestCase(rtest.DBTestCase, "name": self._4ef544102ba7_deployment_uuid, "config": six.b(json.dumps([])), "enum_deployments_status": - consts.DeployStatus.DEPLOY_FINISHED, + consts.DeployStatus.DEPLOY_FINISHED, "credentials": six.b(json.dumps([])), "users": six.b(json.dumps([])) }]) diff --git a/tests/unit/common/objects/test_deploy.py b/tests/unit/common/objects/test_deploy.py index b8b06c8cd5..e0ba2dac61 100644 --- a/tests/unit/common/objects/test_deploy.py +++ b/tests/unit/common/objects/test_deploy.py @@ -50,20 +50,20 @@ class DeploymentTestCase(test.TestCase): mock_deployment_create.return_value = self.deployment deploy = objects.Deployment() mock_deployment_create.assert_called_once_with({}) - self.assertEqual(deploy["uuid"], self.deployment["uuid"]) + self.assertEqual(self.deployment["uuid"], deploy["uuid"]) @mock.patch("rally.common.objects.deploy.db.deployment_create") def test_init_without_create(self, mock_deployment_create): deploy = objects.Deployment(deployment=self.deployment) self.assertFalse(mock_deployment_create.called) - self.assertEqual(deploy["uuid"], self.deployment["uuid"]) + self.assertEqual(self.deployment["uuid"], deploy["uuid"]) @mock.patch("rally.common.objects.deploy.db.deployment_get") def test_get(self, mock_deployment_get): mock_deployment_get.return_value = self.deployment deploy = objects.Deployment.get(self.deployment["uuid"]) mock_deployment_get.assert_called_once_with(self.deployment["uuid"]) - self.assertEqual(deploy["uuid"], self.deployment["uuid"]) + self.assertEqual(self.deployment["uuid"], deploy["uuid"]) @mock.patch("rally.common.objects.deploy.db.deployment_delete") @mock.patch("rally.common.objects.deploy.db.deployment_create") @@ -88,7 +88,7 @@ class DeploymentTestCase(test.TestCase): deploy._update({"opt": "val2"}) mock_deployment_update.assert_called_once_with( self.deployment["uuid"], {"opt": "val2"}) - self.assertEqual(deploy["opt"], "val2") + self.assertEqual("val2", deploy["opt"]) @mock.patch("rally.common.objects.deploy.db.deployment_update") def test_update_status(self, mock_deployment_update): @@ -250,7 +250,7 @@ class DeploymentTestCase(test.TestCase): deploy = objects.Deployment(deployment=self.deployment) resource = deploy.add_resource("provider", type="some", info={"key": "value"}) - self.assertEqual(resource["id"], self.resource["id"]) + self.assertEqual(self.resource["id"], resource["id"]) mock_resource_create.assert_called_once_with({ "deployment_uuid": self.deployment["uuid"], "provider_name": "provider", @@ -268,8 +268,8 @@ class DeploymentTestCase(test.TestCase): mock_resource_get_all.return_value = [self.resource] deploy = objects.Deployment(deployment=self.deployment) resources = deploy.get_resources(provider_name="provider", type="some") - self.assertEqual(len(resources), 1) - self.assertEqual(resources[0]["id"], self.resource["id"]) + self.assertEqual(1, len(resources)) + self.assertEqual(self.resource["id"], resources[0]["id"]) @mock.patch("rally.common.objects.deploy.dt.datetime") @mock.patch("rally.common.objects.deploy.db.deployment_update") diff --git a/tests/unit/common/plugin/test_meta.py b/tests/unit/common/plugin/test_meta.py index 0e4ed1b9b6..e3648e6c8e 100644 --- a/tests/unit/common/plugin/test_meta.py +++ b/tests/unit/common/plugin/test_meta.py @@ -66,7 +66,7 @@ class TestMetaMixinTestCase(test.TestCase): Meta._meta_init() Meta._meta_set("aaa", 42) - self.assertEqual(Meta._meta_get("aaa"), 42) + self.assertEqual(42, Meta._meta_get("aaa")) def test_meta_get_default(self): @@ -74,7 +74,7 @@ class TestMetaMixinTestCase(test.TestCase): pass Meta._meta_init() - self.assertEqual(Meta._meta_get("b", 42), 42) + self.assertEqual(42, Meta._meta_get("b", 42)) def test_meta_get_if_is_not_inited(self): diff --git a/tests/unit/common/plugin/test_plugin.py b/tests/unit/common/plugin/test_plugin.py index fd113c971f..31a8368625 100644 --- a/tests/unit/common/plugin/test_plugin.py +++ b/tests/unit/common/plugin/test_plugin.py @@ -79,8 +79,8 @@ class PluginModuleTestCase(test.TestCase): class B(SecondBase): pass - self.assertEqual(A, OneBase.get(name)) - self.assertEqual(B, SecondBase.get(name)) + self.assertEqual(OneBase.get(name), A) + self.assertEqual(SecondBase.get(name), B) def test_get_multiple_chooses(self): name = "test_get_multiple_chooses" @@ -221,5 +221,5 @@ class PluginTestCase(test.TestCase): def test_is_deprecated(self): self.assertFalse(SomePlugin.is_deprecated()) - self.assertEqual(DeprecatedPlugin.is_deprecated(), - {"reason": "some_reason", "rally_version": "0.1.1"}) + self.assertEqual({"reason": "some_reason", "rally_version": "0.1.1"}, + DeprecatedPlugin.is_deprecated()) diff --git a/tests/unit/common/test_logging.py b/tests/unit/common/test_logging.py index 3714876bbf..e553df0246 100644 --- a/tests/unit/common/test_logging.py +++ b/tests/unit/common/test_logging.py @@ -224,14 +224,14 @@ class LogTestCase(test.TestCase): return x + y t = TaskLog() - self.assertEqual(t.some_method.__name__, "some_method") - self.assertEqual(t.some_method(2, 2), 4) + self.assertEqual("some_method", t.some_method.__name__) + self.assertEqual(4, t.some_method(2, 2)) params = {"msg": msg % {"a": 10, "b": 20}, "uuid": t.task["uuid"]} expected = [ mock.call(_("Task %(uuid)s | Starting: %(msg)s") % params), mock.call(_("Task %(uuid)s | Completed: %(msg)s") % params) ] - self.assertEqual(mock_log.mock_calls, expected) + self.assertEqual(expected, mock_log.mock_calls) def test_log_deprecated(self): mock_log = mock.MagicMock() @@ -240,7 +240,7 @@ class LogTestCase(test.TestCase): def some_method(x, y): return x + y - self.assertEqual(some_method(2, 2), 4) + self.assertEqual(4, some_method(2, 2)) self.assertIn("some_method()", mock_log.call_args[0][0]) self.assertIn("depr42", mock_log.call_args[0][0]) self.assertIn("1.1.1", mock_log.call_args[0][0]) @@ -253,13 +253,13 @@ class LogTestCase(test.TestCase): def some_method(x, y, z): return x + y + z - self.assertEqual(some_method(2, 2, z=3), 7) + self.assertEqual(7, some_method(2, 2, z=3)) self.assertIn("ABC42", mock_log.call_args[0][0]) self.assertIn("`z' of `some_method()'", mock_log.call_args[0][0]) self.assertIn("0.0.1", mock_log.call_args[0][0]) mock_log.reset_mock() - self.assertEqual(some_method(2, 2, z=3), 7) + self.assertEqual(7, some_method(2, 2, z=3)) self.assertFalse(mock_log.called) @rally_logging.log_deprecated_args("CBA42", "0.0.1", ("z",), @@ -267,9 +267,9 @@ class LogTestCase(test.TestCase): def some_method(x, y, z): return x + y + z - self.assertEqual(some_method(2, 2, z=3), 7) + self.assertEqual(7, some_method(2, 2, z=3)) self.assertIn("CBA42", mock_log.call_args[0][0]) mock_log.reset_mock() - self.assertEqual(some_method(2, 2, z=3), 7) + self.assertEqual(7, some_method(2, 2, z=3)) self.assertIn("CBA42", mock_log.call_args[0][0]) diff --git a/tests/unit/common/test_sshutils.py b/tests/unit/common/test_sshutils.py index 6490127c45..e58bae9d3f 100644 --- a/tests/unit/common/test_sshutils.py +++ b/tests/unit/common/test_sshutils.py @@ -76,7 +76,7 @@ class SSHTestCase(test.TestCase): key = self.ssh._get_pkey("key") dss_calls = mock_paramiko.dsskey.DSSKey.from_private_key.mock_calls self.assertEqual([mock.call("string_key")], dss_calls) - self.assertEqual(key, "dss_key") + self.assertEqual("dss_key", key) mock_string_io.assert_called_once_with("key") @mock.patch("rally.common.sshutils.six.moves.StringIO") @@ -90,7 +90,7 @@ class SSHTestCase(test.TestCase): key = self.ssh._get_pkey("key") rsa_calls = mock_paramiko.rsakey.RSAKey.from_private_key.mock_calls self.assertEqual([mock.call("string_key")], rsa_calls) - self.assertEqual(key, "rsa_key") + self.assertEqual("rsa_key", key) mock_string_io.assert_called_once_with("key") @mock.patch("rally.common.sshutils.SSH._get_pkey") diff --git a/tests/unit/common/test_utils.py b/tests/unit/common/test_utils.py index 0b12f00a2b..e21fa50f83 100644 --- a/tests/unit/common/test_utils.py +++ b/tests/unit/common/test_utils.py @@ -46,7 +46,7 @@ class ImmutableMixinTestCase(test.TestCase): a = A("test") self.assertRaises(AttributeError, a.__setattr__, "abc", "test") - self.assertEqual(a.test, "test") + self.assertEqual("test", a.test) class EnumMixinTestCase(test.TestCase): @@ -58,7 +58,7 @@ class EnumMixinTestCase(test.TestCase): b = 20 CC = "2000" - self.assertEqual(set(list(Foo())), set([10, 20, "2000"])) + self.assertEqual(set([10, 20, "2000"]), set(list(Foo()))) def test_with_underscore(self): @@ -67,7 +67,7 @@ class EnumMixinTestCase(test.TestCase): b = 20 _CC = "2000" - self.assertEqual(set(list(Foo())), set([10, 20])) + self.assertEqual(set([10, 20]), set(list(Foo()))) class StdIOCaptureTestCase(test.TestCase): @@ -79,8 +79,8 @@ class StdIOCaptureTestCase(test.TestCase): for msg in messages: print(msg) - self.assertEqual(out.getvalue().rstrip("\n").split("\n"), messages) - self.assertEqual(stdout, sys.stdout) + self.assertEqual(messages, out.getvalue().rstrip("\n").split("\n")) + self.assertEqual(sys.stdout, stdout) def test_stderr_capture(self): stderr = sys.stderr @@ -89,8 +89,8 @@ class StdIOCaptureTestCase(test.TestCase): for msg in messages: print(msg, file=sys.stderr) - self.assertEqual(err.getvalue().rstrip("\n").split("\n"), messages) - self.assertEqual(stderr, sys.stderr) + self.assertEqual(messages, err.getvalue().rstrip("\n").split("\n")) + self.assertEqual(sys.stderr, stderr) class TimerTestCase(test.TestCase): @@ -141,9 +141,9 @@ class FirstIndexTestCase(test.TestCase): def test_list_with_existing_matching_element(self): lst = [1, 3, 5, 7] - self.assertEqual(utils.first_index(lst, lambda e: e == 1), 0) - self.assertEqual(utils.first_index(lst, lambda e: e == 5), 2) - self.assertEqual(utils.first_index(lst, lambda e: e == 7), 3) + self.assertEqual(0, utils.first_index(lst, lambda e: e == 1)) + self.assertEqual(2, utils.first_index(lst, lambda e: e == 5)) + self.assertEqual(3, utils.first_index(lst, lambda e: e == 7)) def test_list_with_non_existing_matching_element(self): lst = [1, 3, 5, 7] @@ -242,7 +242,7 @@ class RandomNameTestCase(test.TestCase): generator = FakeNameGenerator() mock_choice.side_effect = iter("blarglesdweebled") - self.assertEqual(generator.generate_random_name(), expected) + self.assertEqual(expected, generator.generate_random_name()) class FakeNameGenerator(utils.RandomNameGeneratorMixin): RESOURCE_NAME_FORMAT = fmt @@ -251,7 +251,7 @@ class RandomNameTestCase(test.TestCase): generator = FakeNameGenerator() mock_choice.side_effect = iter("blarglesdweebled") - self.assertEqual(generator.generate_random_name(), expected) + self.assertEqual(expected, generator.generate_random_name()) def test_generate_random_name_bogus_name_format(self): class FakeNameGenerator(utils.RandomNameGeneratorMixin): @@ -393,13 +393,13 @@ class RandomNameTestCase(test.TestCase): names = [generator.generate_random_name() for i in range(100)] task_id_parts = set([n.split("_")[0] for n in names]) - self.assertEqual(len(task_id_parts), 1) + self.assertEqual(1, len(task_id_parts)) generator.task = {"uuid": "bogus! task! id!"} names = [generator.generate_random_name() for i in range(100)] task_id_parts = set([n.split("_")[0] for n in names]) - self.assertEqual(len(task_id_parts), 1) + self.assertEqual(1, len(task_id_parts)) def test_make_name_matcher(self): matcher = utils.make_name_matcher("foo", "bar") @@ -457,7 +457,7 @@ class MergeTestCase(test.TestCase): in_iters = [iter(src) for src in sources] out = list(utils.merge(10, *in_iters)) - self.assertEqual(out, expected_output) + self.assertEqual(expected_output, out) class TimeoutThreadTestCase(test.TestCase): @@ -506,10 +506,10 @@ class LockedDictTestCase(test.TestCase): d = utils.LockedDict() self.assertIsInstance(d, dict) - self.assertEqual(d, {}) + self.assertEqual({}, d) d = utils.LockedDict(foo="bar", spam={"a": ["b", {"c": "d"}]}) - self.assertEqual(d, {"foo": "bar", "spam": {"a": ("b", {"c": "d"})}}) + self.assertEqual({"foo": "bar", "spam": {"a": ("b", {"c": "d"})}}, d) self.assertIsInstance(d["spam"], utils.LockedDict) self.assertIsInstance(d["spam"]["a"][1], utils.LockedDict) self.assertRaises(RuntimeError, setitem, d, 123, 456) @@ -521,21 +521,21 @@ class LockedDictTestCase(test.TestCase): self.assertRaises(RuntimeError, d.pop, "foo") self.assertRaises(RuntimeError, d.popitem) self.assertRaises(RuntimeError, d.clear) - self.assertEqual(d, {"foo": "bar", "spam": {"a": ("b", {"c": "d"})}}) + self.assertEqual({"foo": "bar", "spam": {"a": ("b", {"c": "d"})}}, d) with d.unlocked(): d["spam"] = 42 - self.assertEqual(d, {"foo": "bar", "spam": 42}) + self.assertEqual({"foo": "bar", "spam": 42}, d) d.clear() - self.assertEqual(d, {}) + self.assertEqual({}, d) d.setdefault("foo", 42) d.update({"bar": 24}) - self.assertEqual(d, {"foo": 42, "bar": 24}) + self.assertEqual({"foo": 42, "bar": 24}, d) self.assertEqual(24, d.pop("bar")) self.assertEqual(("foo", 42), d.popitem()) d[123] = 456 - self.assertEqual(d, {123: 456}) + self.assertEqual({123: 456}, d) self.assertRaises(RuntimeError, setitem, d, 123, 456) self.assertRaises(RuntimeError, delitem, d, "foo") @@ -798,7 +798,7 @@ class BackupTestCase(test.TestCase): # it is expected behaviour pass else: - self.fail("BackupHelper context manager should not hide an " - "exception") + self.fail("BackupHelper context manager should not hide " + "an exception") self.assertTrue(mock_backup_helper_rollback.called) diff --git a/tests/unit/plugins/common/runners/test_constant.py b/tests/unit/plugins/common/runners/test_constant.py index deeb7880f8..f852d2636f 100644 --- a/tests/unit/plugins/common/runners/test_constant.py +++ b/tests/unit/plugins/common/runners/test_constant.py @@ -59,7 +59,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase): result = constant._run_scenario_once_with_unpack_args( ("FOO", ("BAR", "QUUZ"))) - self.assertEqual(mock_runner._run_scenario_once.return_value, result) + self.assertEqual(result, mock_runner._run_scenario_once.return_value) mock_runner._run_scenario_once.assert_called_once_with( "FOO", ("BAR", "QUUZ")) @@ -129,7 +129,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase): runner_obj._run_scenario( fakes.FakeScenario, "do_it", self.context, self.args) - self.assertEqual(len(runner_obj.result_queue), self.config["times"]) + self.assertEqual(self.config["times"], len(runner_obj.result_queue)) for result_batch in runner_obj.result_queue: for result in result_batch: self.assertIsNotNone(result) @@ -139,7 +139,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase): runner_obj._run_scenario(fakes.FakeScenario, "something_went_wrong", self.context, self.args) - self.assertEqual(len(runner_obj.result_queue), self.config["times"]) + self.assertEqual(self.config["times"], len(runner_obj.result_queue)) for result_batch in runner_obj.result_queue: for result in result_batch: self.assertIsNotNone(result) @@ -151,7 +151,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase): runner_obj.abort() runner_obj._run_scenario(fakes.FakeScenario, "do_it", self.context, self.args) - self.assertEqual(len(runner_obj.result_queue), 0) + self.assertEqual(0, len(runner_obj.result_queue)) @mock.patch(RUNNERS + "constant.multiprocessing.Queue") @mock.patch(RUNNERS + "constant.multiprocessing.cpu_count") @@ -287,7 +287,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase): self.context, self.args) # NOTE(mmorais): when duration is 0, scenario executes exactly 1 time expected_times = 1 - self.assertEqual(len(runner_obj.result_queue), expected_times) + self.assertEqual(expected_times, len(runner_obj.result_queue)) for result_batch in runner_obj.result_queue: for result in result_batch: self.assertIsNotNone(result) @@ -300,7 +300,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase): self.context, self.args) # NOTE(mmorais): when duration is 0, scenario executes exactly 1 time expected_times = 1 - self.assertEqual(len(runner_obj.result_queue), expected_times) + self.assertEqual(expected_times, len(runner_obj.result_queue)) for result_batch in runner_obj.result_queue: for result in result_batch: self.assertIsNotNone(result) @@ -314,7 +314,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase): self.context, self.args) # NOTE(mmorais): when duration is 0, scenario executes exactly 1 time expected_times = 1 - self.assertEqual(len(runner_obj.result_queue), expected_times) + self.assertEqual(expected_times, len(runner_obj.result_queue)) for result_batch in runner_obj.result_queue: for result in result_batch: self.assertIsNotNone(result) @@ -327,7 +327,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase): runner_obj.abort() runner_obj._run_scenario(fakes.FakeScenario, "do_it", self.context, self.args) - self.assertEqual(len(runner_obj.result_queue), 0) + self.assertEqual(0, len(runner_obj.result_queue)) def test_abort(self): runner_obj = constant.ConstantForDurationScenarioRunner(None, diff --git a/tests/unit/plugins/common/runners/test_rps.py b/tests/unit/plugins/common/runners/test_rps.py index 94c4f1b50a..efee202871 100644 --- a/tests/unit/plugins/common/runners/test_rps.py +++ b/tests/unit/plugins/common/runners/test_rps.py @@ -289,7 +289,7 @@ class RPSScenarioRunnerTestCase(test.TestCase): runner_obj._run_scenario(fakes.FakeScenario, "something_went_wrong", fakes.FakeContext({}).context, {}) - self.assertEqual(len(runner_obj.result_queue), config["times"]) + self.assertEqual(config["times"], len(runner_obj.result_queue)) for result_batch in runner_obj.result_queue: for result in result_batch: self.assertIsNotNone(result) @@ -303,7 +303,7 @@ class RPSScenarioRunnerTestCase(test.TestCase): runner_obj._run_scenario(fakes.FakeScenario, "do_it", fakes.FakeUser().context, {}) - self.assertEqual(len(runner_obj.result_queue), 0) + self.assertEqual(0, len(runner_obj.result_queue)) for result in runner_obj.result_queue: self.assertIsNotNone(result) diff --git a/tests/unit/plugins/common/runners/test_serial.py b/tests/unit/plugins/common/runners/test_serial.py index 3b102a83f1..7742fc67e6 100644 --- a/tests/unit/plugins/common/runners/test_serial.py +++ b/tests/unit/plugins/common/runners/test_serial.py @@ -39,9 +39,9 @@ class SerialScenarioRunnerTestCase(test.TestCase): runner._run_scenario(fakes.FakeScenario, "do_it", fakes.FakeContext().context, {}) - self.assertEqual(len(runner.result_queue), times) + self.assertEqual(times, len(runner.result_queue)) results = list(runner.result_queue) - self.assertEqual(results, expected_results) + self.assertEqual(expected_results, results) expected_calls = [] for i in range(times): ctxt = fakes.FakeContext().context @@ -60,7 +60,7 @@ class SerialScenarioRunnerTestCase(test.TestCase): runner.abort() runner._run_scenario(fakes.FakeScenario, "do_it", fakes.FakeContext().context, {}) - self.assertEqual(len(runner.result_queue), 0) + self.assertEqual(0, len(runner.result_queue)) def test_abort(self): runner = serial.SerialScenarioRunner(mock.MagicMock(), diff --git a/tests/unit/plugins/common/test_types.py b/tests/unit/plugins/common/test_types.py index 762c69e5eb..6538d0a80d 100644 --- a/tests/unit/plugins/common/test_types.py +++ b/tests/unit/plugins/common/test_types.py @@ -57,7 +57,7 @@ class FileTypeTestCase(test.TestCase): resource_config = "file.yaml" file_context = types.FileType.transform( clients=None, resource_config=resource_config) - self.assertEqual(file_context, "file_context") + self.assertEqual("file_context", file_context) @mock.patch("six.moves.builtins.open", side_effect=IOError, create=True) def test_transform_by_path_no_match(self, mock_open): @@ -78,7 +78,7 @@ class FileTypeDictTestCase(test.TestCase): file_context = types.FileTypeDict.transform( clients=None, resource_config=resource_config) - self.assertEqual(file_context, {"file.yaml": "file_context"}) + self.assertEqual({"file.yaml": "file_context"}, file_context) @mock.patch("six.moves.builtins.open", side_effect=IOError, create=True) def test_transform_by_path_no_match(self, mock_open): diff --git a/tests/unit/plugins/openstack/cleanup/test_base.py b/tests/unit/plugins/openstack/cleanup/test_base.py index 55e8028794..aa451f462f 100644 --- a/tests/unit/plugins/openstack/cleanup/test_base.py +++ b/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): diff --git a/tests/unit/plugins/openstack/cleanup/test_manager.py b/tests/unit/plugins/openstack/cleanup/test_manager.py index 9a58b94a5f..1a4d892378 100644 --- a/tests/unit/plugins/openstack/cleanup/test_manager.py +++ b/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) diff --git a/tests/unit/plugins/openstack/context/keystone/test_users.py b/tests/unit/plugins/openstack/context/keystone/test_users.py index 6b7b7b91c6..ba528ecae4 100644 --- a/tests/unit/plugins/openstack/context/keystone/test_users.py +++ b/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): diff --git a/tests/unit/plugins/openstack/context/manila/test_manila_security_services.py b/tests/unit/plugins/openstack/context/manila/test_manila_security_services.py index 534fef1e4b..fed16d4d1b 100644 --- a/tests/unit/plugins/openstack/context/manila/test_manila_security_services.py +++ b/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()) diff --git a/tests/unit/plugins/openstack/context/network/test_network.py b/tests/unit/plugins/openstack/context/network/test_network.py index 4b98d004ae..1ca55883ae 100644 --- a/tests/unit/plugins/openstack/context/network/test_network.py +++ b/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": []}, diff --git a/tests/unit/plugins/openstack/context/nova/test_flavors.py b/tests/unit/plugins/openstack/context/nova/test_flavors.py index 175223e9a0..e0e406ee21 100644 --- a/tests/unit/plugins/openstack/context/nova/test_flavors.py +++ b/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"]) diff --git a/tests/unit/plugins/openstack/scenarios/cinder/test_utils.py b/tests/unit/plugins/openstack/scenarios/cinder/test_utils.py index 0c6471e069..9afe498467 100644 --- a/tests/unit/plugins/openstack/scenarios/cinder/test_utils.py +++ b/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) diff --git a/tests/unit/plugins/openstack/scenarios/neutron/test_utils.py b/tests/unit/plugins/openstack/scenarios/neutron/test_utils.py index 29f0879fd6..58aab488f2 100644 --- a/tests/unit/plugins/openstack/scenarios/neutron/test_utils.py +++ b/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") diff --git a/tests/unit/plugins/openstack/services/storage/test_cinder_common.py b/tests/unit/plugins/openstack/services/storage/test_cinder_common.py index 5066398145..6a37653ecd 100644 --- a/tests/unit/plugins/openstack/services/storage/test_cinder_common.py +++ b/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) diff --git a/tests/unit/plugins/openstack/test_types.py b/tests/unit/plugins/openstack/test_types.py index e3aa400d92..14a8bf59f6 100644 --- a/tests/unit/plugins/openstack/test_types.py +++ b/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"} diff --git a/tests/unit/plugins/openstack/test_validators.py b/tests/unit/plugins/openstack/test_validators.py index e9ecd7c1a8..5b9f5b6545 100644 --- a/tests/unit/plugins/openstack/test_validators.py +++ b/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"]) diff --git a/tests/unit/plugins/openstack/verification/tempest/test_config.py b/tests/unit/plugins/openstack/verification/tempest/test_config.py index e9fa85e2e6..24b7924bd5 100644 --- a/tests/unit/plugins/openstack/verification/tempest/test_config.py +++ b/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") diff --git a/tests/unit/plugins/openstack/verification/tempest/test_context.py b/tests/unit/plugins/openstack/verification/tempest/test_context.py index 658ccc97f9..6e3aef5e21 100644 --- a/tests/unit/plugins/openstack/verification/tempest/test_context.py +++ b/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")) diff --git a/tests/unit/plugins/openstack/wrappers/test_network.py b/tests/unit/plugins/openstack/wrappers/test_network.py index 02347386ae..9e87090e1d 100644 --- a/tests/unit/plugins/openstack/wrappers/test_network.py +++ b/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() diff --git a/tests/unit/task/processing/test_plot.py b/tests/unit/task/processing/test_plot.py index 1ec0645190..40598ac654 100644 --- a/tests/unit/task/processing/test_plot.py +++ b/tests/unit/task/processing/test_plot.py @@ -186,7 +186,7 @@ class PlotTestCase(test.TestCase): "met": "dummy", "pos": str(c)}) source, p_workloads = plot._process_workloads(workloads) - self.assertEqual(source, "json_data") + self.assertEqual("json_data", source) mock_json_dumps.assert_called_once_with( {"Foo.bar_1": [{"runner": {"type": "constant", "times": 3}, "hooks": [{"hook1": "xxx"}], @@ -231,7 +231,7 @@ class PlotTestCase(test.TestCase): html = plot.plot([task_dict], **ddt_kwargs) - self.assertEqual(html, "tasks_html") + self.assertEqual("tasks_html", html) mock_get_template.assert_called_once_with("task/report.html") mock__process_workloads.assert_called_once_with(["foo", "bar"]) if "include_libs" in ddt_kwargs: diff --git a/tests/unit/task/test_atomic.py b/tests/unit/task/test_atomic.py index aa1e426a21..a969f8a1cb 100644 --- a/tests/unit/task/test_atomic.py +++ b/tests/unit/task/test_atomic.py @@ -124,13 +124,11 @@ class AtomicActionTestCase(test.TestCase): inst = TestAtomicTimer() self.assertEqual(5, inst.some_func(2, 3, atomic_action=False)) - self.assertEqual([], - inst.atomic_actions()) + self.assertEqual([], inst.atomic_actions()) inst = TestAtomicTimer() self.assertEqual(5, inst.other_func(2, 3)) - self.assertEqual([], - inst.atomic_actions()) + self.assertEqual([], inst.atomic_actions()) inst = TestAtomicTimer() self.assertEqual(5, inst.other_func(2, 3, foo=True)) diff --git a/tests/unit/task/test_context.py b/tests/unit/task/test_context.py index 56bd6324b7..8be3ea6616 100644 --- a/tests/unit/task/test_context.py +++ b/tests/unit/task/test_context.py @@ -38,9 +38,9 @@ class BaseContextTestCase(test.TestCase): def test_init(self, config, expected): ctx = {"config": {"foo": 42, "fake": config}, "task": "foo_task"} ins = fakes.FakeContext(ctx) - self.assertEqual(ins.config, expected) - self.assertEqual(ins.task, "foo_task") - self.assertEqual(ins.context, ctx) + self.assertEqual(expected, ins.config) + self.assertEqual("foo_task", ins.task) + self.assertEqual(ctx, ins.context) def test_init_with_default_config(self): @context.configure(name="foo", order=1) @@ -58,16 +58,16 @@ class BaseContextTestCase(test.TestCase): "config": {"fake": {"foo": 42}} } ctx = fakes.FakeContext(ctx0) - self.assertEqual(ctx.config, ctx0["config"]["fake"]) - self.assertEqual(ctx.task, ctx0["task"]) - self.assertEqual(ctx.context, ctx0) + self.assertEqual(ctx0["config"]["fake"], ctx.config) + self.assertEqual(ctx0["task"], ctx.task) + self.assertEqual(ctx0, ctx.context) @ddt.data(({"test": 2}, True), ({"nonexisting": 2}, False)) @ddt.unpack def test_validate(self, config, valid): results = context.Context.validate("fake", None, None, config) if valid: - self.assertEqual([], results) + self.assertEqual(results, []) else: self.assertEqual(1, len(results)) diff --git a/tests/unit/task/test_engine.py b/tests/unit/task/test_engine.py index 612a3eebf0..60db4d39db 100644 --- a/tests/unit/task/test_engine.py +++ b/tests/unit/task/test_engine.py @@ -625,7 +625,7 @@ class TaskEngineTestCase(test.TestCase): "scenario_namespace": "openstack", "config": {"a": 1, "b": 3, "c": 4, "users": {}} } - self.assertEqual(result, expected_result) + self.assertEqual(expected_result, result) mock_scenario_get.assert_called_once_with(name) diff --git a/tests/unit/task/test_runner.py b/tests/unit/task/test_runner.py index 3c53f8b5b7..44885aef5d 100644 --- a/tests/unit/task/test_runner.py +++ b/tests/unit/task/test_runner.py @@ -42,14 +42,14 @@ class ScenarioRunnerHelpersTestCase(test.TestCase): "error": mock_format_exc.return_value } - self.assertEqual(runner.format_result_on_timeout(mock_exc, 100), - expected) + self.assertEqual(expected, + runner.format_result_on_timeout(mock_exc, 100)) mock_format_exc.assert_called_once_with(mock_exc) def test_get_scenario_context(self): context_obj = {"foo": "bar"} result = runner._get_scenario_context(13, context_obj) - self.assertEqual(result, {"foo": "bar", "iteration": 14}) + self.assertEqual({"foo": "bar", "iteration": 14}, result) def test_run_scenario_once_internal_logic(self): context = runner._get_scenario_context( diff --git a/tests/unit/task/test_scenario.py b/tests/unit/task/test_scenario.py index 477ebeae3b..6e42c58a62 100644 --- a/tests/unit/task/test_scenario.py +++ b/tests/unit/task/test_scenario.py @@ -67,7 +67,7 @@ class ScenarioTestCase(test.TestCase): scenario_inst = scenario.Scenario() scenario_inst.sleep_between(0.001, 0.001) scenario_inst.sleep_between(0.004, 0.004) - self.assertEqual(scenario_inst.idle_duration(), 0.005) + self.assertEqual(0.005, scenario_inst.idle_duration()) @mock.patch("rally.common.utils.interruptable_sleep") @mock.patch("rally.task.scenario.random.uniform") diff --git a/tests/unit/task/test_utils.py b/tests/unit/task/test_utils.py index 8098f1c526..c8ddc7fd0b 100644 --- a/tests/unit/task/test_utils.py +++ b/tests/unit/task/test_utils.py @@ -87,14 +87,14 @@ class BenchmarkUtilsTestCase(test.TestCase): manager = fakes.FakeManager() resource = fakes.FakeResource(manager=manager) manager._cache(resource) - self.assertEqual(get_from_manager(resource), resource) + self.assertEqual(resource, get_from_manager(resource)) def test_get_from_manager_with_uuid_field(self): get_from_manager = utils.get_from_manager() manager = fakes.FakeManager() resource = fakes.FakeResource(manager=manager) manager._cache(resource) - self.assertEqual(get_from_manager(resource, id_attr="uuid"), resource) + self.assertEqual(resource, get_from_manager(resource, id_attr="uuid")) def test_get_from_manager_in_error_state(self): get_from_manager = utils.get_from_manager() @@ -238,10 +238,10 @@ class WaitForTestCase(test.TestCase): update_resource=self.fake_updater, timeout=self.load_secs, check_interval=self.load_secs / 3) - self.assertEqual(exc.kwargs["resource_name"], "fake_name") - self.assertEqual(exc.kwargs["resource_id"], "fake_id") - self.assertEqual(exc.kwargs["desired_status"], "fake_new_status") - self.assertEqual(exc.kwargs["resource_status"], "FAKE_STALE_STATUS") + self.assertEqual("fake_name", exc.kwargs["resource_name"]) + self.assertEqual("fake_id", exc.kwargs["resource_id"]) + self.assertEqual("fake_new_status", exc.kwargs["desired_status"]) + self.assertEqual("FAKE_STALE_STATUS", exc.kwargs["resource_status"]) self.assertIn("FakeResource", str(exc)) self.assertIn("fake_new_status", str(exc)) diff --git a/tests/unit/task/test_validation.py b/tests/unit/task/test_validation.py index bc5a0d6959..96375ca0a6 100755 --- a/tests/unit/task/test_validation.py +++ b/tests/unit/task/test_validation.py @@ -301,7 +301,7 @@ class ValidatorsTestCase(test.TestCase): result = validation._get_validated_flavor({"args": {"a": "test"}}, clients, "a") 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="test") clients.nova().flavors.get.assert_called_once_with(flavor="flavor_id") diff --git a/tests/unit/test_hacking.py b/tests/unit/test_hacking.py index 42e0fb0c8c..6debaff660 100644 --- a/tests/unit/test_hacking.py +++ b/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 = [ diff --git a/tests/unit/test_osclients.py b/tests/unit/test_osclients.py index 92dc0f1828..e17d89c2d4 100644 --- a/tests/unit/test_osclients.py +++ b/tests/unit/test_osclients.py @@ -355,7 +355,7 @@ class OSClientsTestCase(test.TestCase): def test_keystone(self): self.assertNotIn("keystone", self.clients.cache) client = self.clients.keystone() - self.assertEqual(client, self.fake_keystone) + self.assertEqual(self.fake_keystone, client) credential = {"timeout": cfg.CONF.openstack_client_http_timeout, "insecure": False, "cacert": None} kwargs = self.credential.to_dict() @@ -760,7 +760,7 @@ class OSClientsTestCase(test.TestCase): self.assertNotIn("swift", self.clients.cache) with mock.patch.dict("sys.modules", {"swiftclient": mock_swift}): client = self.clients.swift() - self.assertEqual(client, fake_swift) + self.assertEqual(fake_swift, client) self.service_catalog.url_for.assert_called_once_with( service_type="object-store", region_name=self.credential.region_name) @@ -773,7 +773,7 @@ class OSClientsTestCase(test.TestCase): "tenant_name": self.credential.tenant_name, } mock_swift.client.Connection.assert_called_once_with(**kw) - self.assertEqual(self.clients.cache["swift"], fake_swift) + self.assertEqual(fake_swift, self.clients.cache["swift"]) @mock.patch("rally.osclients.EC2._get_endpoint") def test_ec2(self, mock_ec2__get_endpoint): diff --git a/tests/unit/test_test_ddt.py b/tests/unit/test_test_ddt.py index 1a9b3a0001..5bacef44ad 100644 --- a/tests/unit/test_test_ddt.py +++ b/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, - "message": "Class Test has functions that use DDT, " - "but is not decorated with `ddt.ddt`"}}) + self.assertEqual({"Test": {"lineno": 3, + "message": "Class Test has functions that use DDT, " + "but is not decorated with `ddt.ddt`"}}, + visitor.errors)