openstack/rally
Code Issues Proposed changes

Fixed order of arguments in assertEqual

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

Partial-Bug: #1259292

Change-Id: I944b72f743a21d0908d17485c25aeb0e7ee70cba
This commit is contained in:
sudhir_agarwal 2017-06-30 16:43:39 +05:30 committed by Boris Pavlovic
parent d15d2c89e7
commit 0aec3cc166
42 changed files with 385 additions and 399 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
tests/functional/test_cli_task.py
View File

@ -1074,7 +1074,7 @@ class SLAExtraFlagsTestCase(unittest.TestCase):
try:
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")

6
tests/unit/cli/commands/test_plugin.py
View File

@ -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):

8
tests/unit/cli/commands/test_task.py
View File

@ -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):

16
tests/unit/cli/test_cliutils.py
View File

@ -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):

8
tests/unit/cli/test_envutils.py
View File

@ -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",

132
tests/unit/common/db/test_api.py
View File

@ -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):

122
tests/unit/common/db/test_migrations.py
View File

@ -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([]))
}])

14
tests/unit/common/objects/test_deploy.py
View File

@ -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")

4
tests/unit/common/plugin/test_meta.py
View File

@ -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):

8
tests/unit/common/plugin/test_plugin.py
View File

@ -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())

16
tests/unit/common/test_logging.py
View File

@ -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])

4
tests/unit/common/test_sshutils.py
View File

@ -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")

48
tests/unit/common/test_utils.py
View File

@ -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)

16
tests/unit/plugins/common/runners/test_constant.py
View File

@ -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,

4
tests/unit/plugins/common/runners/test_rps.py
View File

@ -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)

6
tests/unit/plugins/common/runners/test_serial.py
View File

@ -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(),

4
tests/unit/plugins/common/test_types.py
View File

@ -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):

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

@ -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):

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

@ -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)

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

@ -376,7 +376,7 @@ class UserGeneratorForNewUsersTestCase(test.ScenarioTestCase):
user_generator.context["tenants"] = {"t1": {"id": "t1", "name": "t1"},
"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):

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

@ -89,7 +89,7 @@ class SecurityServicesTestCase(test.ScenarioTestCase):
inst = manila_security_services.SecurityServices(context)
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())

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

@ -41,9 +41,9 @@ class NetworkTestCase(test.TestCase):
@mock.patch(NET + "wrap", return_value="foo_service")
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": []},

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

@ -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"])

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

@ -109,11 +109,11 @@ class CinderScenarioTestCase(test.ScenarioTestCase):
self.scenario._set_metadata(volume, sets=2, set_size=4)
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)

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

@ -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")

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

@ -158,11 +158,11 @@ class CinderMixinTestCase(test.ScenarioTestCase):
self.service.set_metadata(volume, sets=2, set_size=4)
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)

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

@ -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"}

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

@ -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"])

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

@ -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")

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

@ -136,9 +136,9 @@ class TempestContextTestCase(test.TestCase):
glanceclient = self.context.clients.glance()
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"))

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

@ -39,7 +39,7 @@ class NeutronWrapperTestCase(test.TestCase):
return network.NeutronWrapper(mock.Mock(), self.owner, config=kwargs)
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()

4
tests/unit/task/processing/test_plot.py
View File

@ -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:

6
tests/unit/task/test_atomic.py
View File

@ -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))

14
tests/unit/task/test_context.py
View File

@ -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))

2
tests/unit/task/test_engine.py
View File

@ -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)

6
tests/unit/task/test_runner.py
View File

@ -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(

2
tests/unit/task/test_scenario.py
View File

@ -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")

12
tests/unit/task/test_utils.py
View File

@ -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))

2
tests/unit/task/test_validation.py
View File

@ -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")

13
tests/unit/test_hacking.py
View File

@ -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 = [

6
tests/unit/test_osclients.py
View File

@ -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):

11
tests/unit/test_test_ddt.py
View File

@ -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)