Fixed order of arguments in assertEqual

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

Partial-Bug: #1259292

Change-Id: I944b72f743a21d0908d17485c25aeb0e7ee70cba
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

View File

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

View File

@ -112,7 +112,7 @@ class PluginCommandsTestCase(test.TestCase):
def test_show_not_found(self, name, namespace, text): def test_show_not_found(self, name, namespace, text):
with utils.StdOutCapture() as out: with utils.StdOutCapture() as out:
plugin_cmd.PluginCommands().show(None, name, namespace) 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") @mock.patch("rally.cli.commands.plugin.PluginCommands._print_plugins_list")
def test_show_many(self, mock_plugin_commands__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: "get_all") as mock_plugin_get_all:
mock_plugin_get_all.return_value = [self.Plugin2, self.Plugin3] mock_plugin_get_all.return_value = [self.Plugin2, self.Plugin3]
plugin_cmd.PluginCommands().show(None, "p", "p2_ns") 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_get_all.assert_called_once_with(platform="p2_ns")
mock_plugin_commands__print_plugins_list.assert_called_once_with([ mock_plugin_commands__print_plugins_list.assert_called_once_with([
@ -144,7 +144,7 @@ class PluginCommandsTestCase(test.TestCase):
with utils.StdOutCapture() as out: with utils.StdOutCapture() as out:
plugin_cmd.PluginCommands().list(None, name, namespace) 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") @mock.patch("rally.cli.commands.plugin.PluginCommands._print_plugins_list")
def test_list(self, mock_plugin_commands__print_plugins_list): def test_list(self, mock_plugin_commands__print_plugins_list):

View File

@ -61,7 +61,7 @@ class TaskCommandsTestCase(test.TestCase):
] ]
task_conf = self.task._load_and_validate_task( task_conf = self.task._load_and_validate_task(
self.real_api, "in_task", raw_args=input_args) 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_open.side_effect = [
mock.mock_open(read_data=input_task).return_value, 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( task_conf = self.task._load_and_validate_task(
self.real_api, "in_task", raw_args=input_args, self.real_api, "in_task", raw_args=input_args,
args_file="any_file") args_file="any_file")
self.assertEqual(task_conf, {"ab": 2}) self.assertEqual({"ab": 2}, task_conf)
mock_open.side_effect = [ mock_open.side_effect = [
mock.mock_open(read_data=input_task).return_value, 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( task_conf = self.task._load_and_validate_task(
self.real_api, "in_task", raw_args="test=2", self.real_api, "in_task", raw_args="test=2",
args_file="any_file") 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) @mock.patch("rally.cli.commands.task.open", create=True)
def test__load_task_wrong_task_args_file(self, mock_open): 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): def test_old_report_exceptions(self, mock_open, mock_path_exists):
ret = self.task._old_report(self.real_api, tasks="/tmp/task.json", ret = self.task._old_report(self.real_api, tasks="/tmp/task.json",
out="/tmp/tmp.hsml") out="/tmp/tmp.hsml")
self.assertEqual(ret, 1) self.assertEqual(1, ret)
@mock.patch("rally.cli.commands.task.os.path.exists", return_value=True) @mock.patch("rally.cli.commands.task.os.path.exists", return_value=True)
def test_report(self, mock_path_exists): def test_report(self, mock_path_exists):

View File

@ -149,7 +149,7 @@ class CliUtilsTestCase(test.TestCase):
def test_make_header(self): def test_make_header(self):
h1 = cliutils.make_header("msg", size=4, symbol="=") 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): def test_make_table_header(self):
actual = cliutils.make_table_header("Response Times (sec)", 40) actual = cliutils.make_table_header("Response Times (sec)", 40)
@ -253,7 +253,7 @@ class CliUtilsTestCase(test.TestCase):
pass pass
mock_obj = fake_class() mock_obj = fake_class()
result = cliutils._methods_of(mock_obj) result = cliutils._methods_of(mock_obj)
self.assertEqual(result, []) self.assertEqual([], result)
def _unregister_opts(self): def _unregister_opts(self):
CONF.reset() CONF.reset()
@ -267,19 +267,19 @@ class CliUtilsTestCase(test.TestCase):
side_effect=exceptions.RallyException("config_file")) side_effect=exceptions.RallyException("config_file"))
def test_run_fails(self, mock_rally_api_api): def test_run_fails(self, mock_rally_api_api):
ret = cliutils.run(["rally", "version"], self.categories) ret = cliutils.run(["rally", "version"], self.categories)
self.assertEqual(ret, 2) self.assertEqual(2, ret)
mock_rally_api_api.assert_called_once_with( mock_rally_api_api.assert_called_once_with(
config_args=["version"], skip_db_check=True) config_args=["version"], skip_db_check=True)
@mock.patch("rally.api.API.check_db_revision") @mock.patch("rally.api.API.check_db_revision")
def test_run_version(self, mock_api_check_db_revision): def test_run_version(self, mock_api_check_db_revision):
ret = cliutils.run(["rally", "version"], self.categories) ret = cliutils.run(["rally", "version"], self.categories)
self.assertEqual(ret, 0) self.assertEqual(0, ret)
@mock.patch("rally.api.API.check_db_revision") @mock.patch("rally.api.API.check_db_revision")
def test_run_bash_completion(self, mock_api_check_db_revision): def test_run_bash_completion(self, mock_api_check_db_revision):
ret = cliutils.run(["rally", "bash-completion"], self.categories) 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.api.API.check_db_revision")
@mock.patch("rally.common.db.api.task_get", @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], ret = cliutils.run(["rally", "task", "status", "%s" % FAKE_TASK_UUID],
self.categories) self.categories)
self.assertTrue(mock_task_get.called) 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.api.API.check_db_revision")
@mock.patch("rally.cli.cliutils.validate_args", @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], ret = cliutils.run(["rally", "task", "status", "%s" % FAKE_TASK_UUID],
self.categories) self.categories)
self.assertTrue(mock_validate_args.called) self.assertTrue(mock_validate_args.called)
self.assertEqual(ret, 1) self.assertEqual(1, ret)
@mock.patch("rally.api.API.check_db_revision") @mock.patch("rally.api.API.check_db_revision")
def test_run_failed_to_open_file(self, mock_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") alias_fn = mock.Mock(name="alias_fn")
cmd_name = "test-command" cmd_name = "test-command"
wrapped = cliutils.alias(cmd_name) 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): class CategoryParserTestCase(test.TestCase):

View File

@ -36,8 +36,8 @@ class EnvUtilsTestCase(test.TestCase):
with mock.patch("sys.stdout", with mock.patch("sys.stdout",
new_callable=moves.StringIO) as mock_stdout: new_callable=moves.StringIO) as mock_stdout:
test_function() test_function()
self.assertEqual(mock_stdout.getvalue(), self.assertEqual("Missing argument: --test_missing_arg\n",
"Missing argument: --test_missing_arg\n") mock_stdout.getvalue())
@mock.patch.dict(os.environ, @mock.patch.dict(os.environ,
values={envutils.ENV_DEPLOYMENT: "my_deployment_id"}, values={envutils.ENV_DEPLOYMENT: "my_deployment_id"},
@ -91,7 +91,7 @@ class EnvUtilsTestCase(test.TestCase):
envutils.clear_global(envutils.ENV_DEPLOYMENT) envutils.clear_global(envutils.ENV_DEPLOYMENT)
mock_update_env_file.assert_called_once_with(os.path.expanduser( mock_update_env_file.assert_called_once_with(os.path.expanduser(
"~/.rally/globals"), envutils.ENV_DEPLOYMENT, "\n") "~/.rally/globals"), envutils.ENV_DEPLOYMENT, "\n")
self.assertEqual(os.environ, {}) self.assertEqual({}, os.environ)
@mock.patch.dict(os.environ, @mock.patch.dict(os.environ,
values={envutils.ENV_DEPLOYMENT: "test_deployment_id", values={envutils.ENV_DEPLOYMENT: "test_deployment_id",
@ -102,7 +102,7 @@ class EnvUtilsTestCase(test.TestCase):
return_value=True) return_value=True)
def test_clear_env(self, mock_update_env_file, mock_path_exists): def test_clear_env(self, mock_update_env_file, mock_path_exists):
envutils.clear_env() envutils.clear_env()
self.assertEqual(os.environ, {}) self.assertEqual({}, os.environ)
@mock.patch.dict(os.environ, {"OS_AUTH_URL": "fake_auth_url", @mock.patch.dict(os.environ, {"OS_AUTH_URL": "fake_auth_url",
"OS_USERNAME": "fake_username", "OS_USERNAME": "fake_username",

View File

@ -68,27 +68,27 @@ class TasksTestCase(test.DBTestCase):
db_task = self._get_task(task["uuid"]) db_task = self._get_task(task["uuid"])
self.assertIsNotNone(db_task["uuid"]) self.assertIsNotNone(db_task["uuid"])
self.assertIsNotNone(db_task["id"]) 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): def test_task_create_with_tag(self):
task = self._create_task(values={"tags": ["test_tag"]}) task = self._create_task(values={"tags": ["test_tag"]})
db_task = self._get_task(task["uuid"]) db_task = self._get_task(task["uuid"])
self.assertIsNotNone(db_task["uuid"]) self.assertIsNotNone(db_task["uuid"])
self.assertIsNotNone(db_task["id"]) self.assertIsNotNone(db_task["id"])
self.assertEqual(db_task["status"], consts.TaskStatus.INIT) self.assertEqual(consts.TaskStatus.INIT, db_task["status"])
self.assertEqual(db_task["tags"], ["test_tag"]) self.assertEqual(["test_tag"], db_task["tags"])
def test_task_create_without_uuid(self): def test_task_create_without_uuid(self):
_uuid = "19be8589-48b0-4af1-a369-9bebaaa563ab" _uuid = "19be8589-48b0-4af1-a369-9bebaaa563ab"
task = self._create_task({"uuid": _uuid}) task = self._create_task({"uuid": _uuid})
db_task = self._get_task(task["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): def test_task_update(self):
task = self._create_task({}) task = self._create_task({})
db.task_update(task["uuid"], {"status": consts.TaskStatus.CRASHED}) db.task_update(task["uuid"], {"status": consts.TaskStatus.CRASHED})
db_task = self._get_task(task["uuid"]) 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): def test_task_update_with_tag(self):
task = self._create_task({}) task = self._create_task({})
@ -97,8 +97,8 @@ class TasksTestCase(test.DBTestCase):
"tags": ["test_tag"] "tags": ["test_tag"]
}) })
db_task = self._get_task(task["uuid"]) db_task = self._get_task(task["uuid"])
self.assertEqual(db_task["status"], consts.TaskStatus.CRASHED) self.assertEqual(consts.TaskStatus.CRASHED, db_task["status"])
self.assertEqual(db_task["tags"], ["test_tag"]) self.assertEqual(["test_tag"], db_task["tags"])
def test_task_update_not_found(self): def test_task_update_not_found(self):
self.assertRaises(exceptions.TaskNotFound, self.assertRaises(exceptions.TaskNotFound,
@ -116,7 +116,7 @@ class TasksTestCase(test.DBTestCase):
for status in consts.TaskStatus: for status in consts.TaskStatus:
db.task_update(_uuid, {"status": status}) db.task_update(_uuid, {"status": status})
db_task = self._get_task(_uuid) db_task = self._get_task(_uuid)
self.assertEqual(db_task["status"], status) self.assertEqual(status, db_task["status"])
def test_task_list_empty(self): def test_task_list_empty(self):
self.assertEqual([], db.task_list()) self.assertEqual([], db.task_list())
@ -308,8 +308,8 @@ class TasksTestCase(test.DBTestCase):
sla_results=sla_results) sla_results=sla_results)
detailed_task = db.task_get(task_id, detailed=True) detailed_task = db.task_get(task_id, detailed=True)
self.assertEqual(len(detailed_task["subtasks"]), 1) self.assertEqual(1, len(detailed_task["subtasks"]))
self.assertEqual(len(detailed_task["subtasks"][0]["workloads"]), 1) self.assertEqual(1, len(detailed_task["subtasks"][0]["workloads"]))
workload = detailed_task["subtasks"][0]["workloads"][0] workload = detailed_task["subtasks"][0]["workloads"][0]
self.assertEqual([ self.assertEqual([
{"error": "anError", "timestamp": 10, "duration": 1, {"error": "anError", "timestamp": 10, "duration": 1,
@ -550,71 +550,71 @@ class DeploymentTestCase(test.DBTestCase):
def test_deployment_create(self): def test_deployment_create(self):
deploy = db.deployment_create({"config": {"opt": "val"}}) deploy = db.deployment_create({"config": {"opt": "val"}})
deploys = db.deployment_list() deploys = db.deployment_list()
self.assertEqual(len(deploys), 1) self.assertEqual(1, len(deploys))
self.assertEqual(deploy["uuid"], deploys[0]["uuid"]) self.assertEqual(deploys[0]["uuid"], deploy["uuid"])
self.assertEqual(deploy["status"], consts.DeployStatus.DEPLOY_INIT) self.assertEqual(consts.DeployStatus.DEPLOY_INIT, deploy["status"])
self.assertEqual(deploy["config"], {"opt": "val"}) self.assertEqual({"opt": "val"}, deploy["config"])
self.assertEqual(deploy["credentials"], {}) self.assertEqual({}, deploy["credentials"])
def test_deployment_create_several(self): def test_deployment_create_several(self):
# Create a deployment # Create a deployment
deploys = db.deployment_list() deploys = db.deployment_list()
self.assertEqual(len(deploys), 0) self.assertEqual(0, len(deploys))
deploy_one = db.deployment_create({"config": {"opt1": "val1"}}) deploy_one = db.deployment_create({"config": {"opt1": "val1"}})
deploys = db.deployment_list() deploys = db.deployment_list()
self.assertEqual(len(deploys), 1) self.assertEqual(1, len(deploys))
self.assertEqual(deploy_one["uuid"], deploys[0]["uuid"]) self.assertEqual(deploys[0]["uuid"], deploy_one["uuid"])
self.assertEqual(deploy_one["status"], consts.DeployStatus.DEPLOY_INIT) self.assertEqual(consts.DeployStatus.DEPLOY_INIT, deploy_one["status"])
self.assertEqual(deploy_one["config"], {"opt1": "val1"}) self.assertEqual({"opt1": "val1"}, deploy_one["config"])
# Create another deployment and sure that they are different # Create another deployment and sure that they are different
deploy_two = db.deployment_create({"config": {"opt2": "val2"}}) deploy_two = db.deployment_create({"config": {"opt2": "val2"}})
deploys = db.deployment_list() deploys = db.deployment_list()
self.assertEqual(len(deploys), 2) self.assertEqual(2, len(deploys))
self.assertEqual(set([deploy_one["uuid"], deploy_two["uuid"]]), self.assertEqual(set([deploy_one["uuid"], deploy_two["uuid"]]),
set([deploy["uuid"] for deploy in deploys])) set([deploy["uuid"] for deploy in deploys]))
self.assertNotEqual(deploy_one["uuid"], deploy_two["uuid"]) self.assertNotEqual(deploy_one["uuid"], deploy_two["uuid"])
self.assertEqual(deploy_two["status"], consts.DeployStatus.DEPLOY_INIT) self.assertEqual(consts.DeployStatus.DEPLOY_INIT, deploy_two["status"])
self.assertEqual(deploy_two["config"], {"opt2": "val2"}) self.assertEqual({"opt2": "val2"}, deploy_two["config"])
def test_deployment_update(self): def test_deployment_update(self):
credentials = { credentials = {
"openstack": [{"admin": {"foo": "bar"}, "users": ["foo_user"]}]} "openstack": [{"admin": {"foo": "bar"}, "users": ["foo_user"]}]}
deploy = db.deployment_create({}) deploy = db.deployment_create({})
self.assertEqual(deploy["config"], {}) self.assertEqual({}, deploy["config"])
self.assertEqual(deploy["credentials"], {}) self.assertEqual({}, deploy["credentials"])
update_deploy = db.deployment_update( update_deploy = db.deployment_update(
deploy["uuid"], {"config": {"opt": "val"}, deploy["uuid"], {"config": {"opt": "val"},
"credentials": copy.deepcopy(credentials)}) "credentials": copy.deepcopy(credentials)})
self.assertEqual(update_deploy["uuid"], deploy["uuid"]) self.assertEqual(deploy["uuid"], update_deploy["uuid"])
self.assertEqual(update_deploy["config"], {"opt": "val"}) self.assertEqual({"opt": "val"}, update_deploy["config"])
self.assertEqual(update_deploy["credentials"], credentials) self.assertEqual(credentials, update_deploy["credentials"])
get_deploy = db.deployment_get(deploy["uuid"]) get_deploy = db.deployment_get(deploy["uuid"])
self.assertEqual(get_deploy["uuid"], deploy["uuid"]) self.assertEqual(deploy["uuid"], get_deploy["uuid"])
self.assertEqual(get_deploy["config"], {"opt": "val"}) self.assertEqual({"opt": "val"}, get_deploy["config"])
self.assertEqual(update_deploy["credentials"], credentials) self.assertEqual(credentials, update_deploy["credentials"])
def test_deployment_update_several(self): def test_deployment_update_several(self):
# Create a deployment and update it # Create a deployment and update it
deploy_one = db.deployment_create({}) deploy_one = db.deployment_create({})
self.assertEqual(deploy_one["config"], {}) self.assertEqual({}, deploy_one["config"])
update_deploy_one = db.deployment_update( update_deploy_one = db.deployment_update(
deploy_one["uuid"], {"config": {"opt1": "val1"}}) deploy_one["uuid"], {"config": {"opt1": "val1"}})
self.assertEqual(update_deploy_one["uuid"], deploy_one["uuid"]) self.assertEqual(deploy_one["uuid"], update_deploy_one["uuid"])
self.assertEqual(update_deploy_one["config"], {"opt1": "val1"}) self.assertEqual({"opt1": "val1"}, update_deploy_one["config"])
get_deploy_one = db.deployment_get(deploy_one["uuid"]) get_deploy_one = db.deployment_get(deploy_one["uuid"])
self.assertEqual(get_deploy_one["uuid"], deploy_one["uuid"]) self.assertEqual(deploy_one["uuid"], get_deploy_one["uuid"])
self.assertEqual(get_deploy_one["config"], {"opt1": "val1"}) self.assertEqual({"opt1": "val1"}, get_deploy_one["config"])
# Create another deployment # Create another deployment
deploy_two = db.deployment_create({}) deploy_two = db.deployment_create({})
update_deploy_two = db.deployment_update( update_deploy_two = db.deployment_update(
deploy_two["uuid"], {"config": {"opt2": "val2"}}) deploy_two["uuid"], {"config": {"opt2": "val2"}})
self.assertEqual(update_deploy_two["uuid"], deploy_two["uuid"]) self.assertEqual(deploy_two["uuid"], update_deploy_two["uuid"])
self.assertEqual(update_deploy_two["config"], {"opt2": "val2"}) self.assertEqual({"opt2": "val2"}, update_deploy_two["config"])
get_deploy_one_again = db.deployment_get(deploy_one["uuid"]) get_deploy_one_again = db.deployment_get(deploy_one["uuid"])
self.assertEqual(get_deploy_one_again["uuid"], deploy_one["uuid"]) self.assertEqual(deploy_one["uuid"], get_deploy_one_again["uuid"])
self.assertEqual(get_deploy_one_again["config"], {"opt1": "val1"}) self.assertEqual({"opt1": "val1"}, get_deploy_one_again["config"])
def test_deployment_get(self): def test_deployment_get(self):
deploy_one = db.deployment_create({"config": {"opt1": "val1"}}) 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_one = db.deployment_get(deploy_one["uuid"])
get_deploy_two = db.deployment_get(deploy_two["uuid"]) get_deploy_two = db.deployment_get(deploy_two["uuid"])
self.assertNotEqual(get_deploy_one["uuid"], get_deploy_two["uuid"]) self.assertNotEqual(get_deploy_one["uuid"], get_deploy_two["uuid"])
self.assertEqual(get_deploy_one["config"], {"opt1": "val1"}) self.assertEqual({"opt1": "val1"}, get_deploy_one["config"])
self.assertEqual(get_deploy_two["config"], {"opt2": "val2"}) self.assertEqual({"opt2": "val2"}, get_deploy_two["config"])
def test_deployment_get_not_found(self): def test_deployment_get_not_found(self):
self.assertRaises(exceptions.DeploymentNotFound, self.assertRaises(exceptions.DeploymentNotFound,
@ -646,17 +646,17 @@ class DeploymentTestCase(test.DBTestCase):
deploy_three = db.deployment_create({"name": "deployment_name"}) deploy_three = db.deployment_create({"name": "deployment_name"})
deploys = db.deployment_list(status=consts.DeployStatus.DEPLOY_INIT) deploys = db.deployment_list(status=consts.DeployStatus.DEPLOY_INIT)
deploys.sort(key=lambda x: x["id"]) deploys.sort(key=lambda x: x["id"])
self.assertEqual(len(deploys), 2) self.assertEqual(2, len(deploys))
self.assertEqual(deploys[0]["uuid"], deploy_one["uuid"]) self.assertEqual(deploy_one["uuid"], deploys[0]["uuid"])
deploys = db.deployment_list(status=consts.DeployStatus.DEPLOY_FAILED) deploys = db.deployment_list(status=consts.DeployStatus.DEPLOY_FAILED)
self.assertEqual(len(deploys), 1) self.assertEqual(1, len(deploys))
self.assertEqual(deploys[0]["uuid"], deploy_two["uuid"]) self.assertEqual(deploy_two["uuid"], deploys[0]["uuid"])
deploys = db.deployment_list( deploys = db.deployment_list(
status=consts.DeployStatus.DEPLOY_FINISHED) status=consts.DeployStatus.DEPLOY_FINISHED)
self.assertEqual(len(deploys), 0) self.assertEqual(0, len(deploys))
deploys = db.deployment_list(name="deployment_name") deploys = db.deployment_list(name="deployment_name")
self.assertEqual(deploys[0]["uuid"], deploy_three["uuid"]) self.assertEqual(deploy_three["uuid"], deploys[0]["uuid"])
self.assertEqual(len(deploys), 1) self.assertEqual(1, len(deploys))
def test_deployment_list_parent(self): def test_deployment_list_parent(self):
deploy = db.deployment_create({}) deploy = db.deployment_create({})
@ -673,8 +673,8 @@ class DeploymentTestCase(test.DBTestCase):
deploy_two = db.deployment_create({}) deploy_two = db.deployment_create({})
db.deployment_delete(deploy_two["uuid"]) db.deployment_delete(deploy_two["uuid"])
deploys = db.deployment_list() deploys = db.deployment_list()
self.assertEqual(len(deploys), 1) self.assertEqual(1, len(deploys))
self.assertEqual(deploys[0]["uuid"], deploy_one["uuid"]) self.assertEqual(deploy_one["uuid"], deploys[0]["uuid"])
def test_deployment_delete_not_found(self): def test_deployment_delete_not_found(self):
self.assertRaises(exceptions.DeploymentNotFound, self.assertRaises(exceptions.DeploymentNotFound,
@ -699,18 +699,18 @@ class ResourceTestCase(test.DBTestCase):
}) })
resources = db.resource_get_all(deployment["uuid"]) resources = db.resource_get_all(deployment["uuid"])
self.assertTrue(resource["id"]) self.assertTrue(resource["id"])
self.assertEqual(len(resources), 1) self.assertEqual(1, len(resources))
self.assertTrue(resource["id"], resources[0]["id"]) self.assertTrue(resources[0]["id"], resource["id"])
self.assertEqual(resource["deployment_uuid"], deployment["uuid"]) self.assertEqual(deployment["uuid"], resource["deployment_uuid"])
self.assertEqual(resource["provider_name"], "fakeprovider") self.assertEqual("fakeprovider", resource["provider_name"])
self.assertEqual(resource["type"], "faketype") self.assertEqual("faketype", resource["type"])
def test_delete(self): def test_delete(self):
deployment = db.deployment_create({}) deployment = db.deployment_create({})
res = db.resource_create({"deployment_uuid": deployment["uuid"]}) res = db.resource_create({"deployment_uuid": deployment["uuid"]})
db.resource_delete(res["id"]) db.resource_delete(res["id"])
resources = db.resource_get_all(deployment["uuid"]) resources = db.resource_get_all(deployment["uuid"])
self.assertEqual(len(resources), 0) self.assertEqual(0, len(resources))
def test_delete_not_found(self): def test_delete_not_found(self):
self.assertRaises(exceptions.ResourceNotFound, self.assertRaises(exceptions.ResourceNotFound,
@ -726,7 +726,7 @@ class ResourceTestCase(test.DBTestCase):
self.assertEqual(sorted([res1["id"], res2["id"]]), self.assertEqual(sorted([res1["id"], res2["id"]]),
sorted([r["id"] for r in resources])) sorted([r["id"] for r in resources]))
resources = db.resource_get_all(deployment0["uuid"]) resources = db.resource_get_all(deployment0["uuid"])
self.assertEqual(len(resources), 1) self.assertEqual(1, len(resources))
self.assertEqual(res0["id"], resources[0]["id"]) self.assertEqual(res0["id"], resources[0]["id"])
def test_get_all_by_provider_name(self): def test_get_all_by_provider_name(self):
@ -741,11 +741,11 @@ class ResourceTestCase(test.DBTestCase):
}) })
resources = db.resource_get_all(deployment["uuid"], resources = db.resource_get_all(deployment["uuid"],
provider_name="one") provider_name="one")
self.assertEqual(len(resources), 1) self.assertEqual(1, len(resources))
self.assertEqual(res_one["id"], resources[0]["id"]) self.assertEqual(res_one["id"], resources[0]["id"])
resources = db.resource_get_all(deployment["uuid"], resources = db.resource_get_all(deployment["uuid"],
provider_name="two") provider_name="two")
self.assertEqual(len(resources), 1) self.assertEqual(1, len(resources))
self.assertEqual(res_two["id"], resources[0]["id"]) self.assertEqual(res_two["id"], resources[0]["id"])
def test_get_all_by_provider_type(self): def test_get_all_by_provider_type(self):
@ -759,10 +759,10 @@ class ResourceTestCase(test.DBTestCase):
"type": "two", "type": "two",
}) })
resources = db.resource_get_all(deployment["uuid"], type="one") 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"]) self.assertEqual(res_one["id"], resources[0]["id"])
resources = db.resource_get_all(deployment["uuid"], type="two") 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"]) self.assertEqual(res_two["id"], resources[0]["id"])
@ -787,7 +787,7 @@ class VerifierTestCase(test.DBTestCase):
v1 = db.verifier_update(v1["uuid"], status="foo") v1 = db.verifier_update(v1["uuid"], status="foo")
vs = db.verifier_list(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"]) self.assertEqual(v1["uuid"], vs[0]["uuid"])
def test_verifier_delete(self): def test_verifier_delete(self):
@ -840,16 +840,16 @@ class VerificationTestCase(test.DBTestCase):
sorted([v["uuid"] for v in vs])) sorted([v["uuid"] for v in vs]))
vs = db.verification_list(self.verifier["uuid"], deploy["uuid"]) 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"]) self.assertEqual(v1["uuid"], vs[0]["uuid"])
vs = db.verification_list(tags=["bar"]) vs = db.verification_list(tags=["bar"])
self.assertEqual(len(vs), 1) self.assertEqual(1, len(vs))
self.assertEqual(v1["uuid"], vs[0]["uuid"]) self.assertEqual(v1["uuid"], vs[0]["uuid"])
v2 = db.verification_update(v2["uuid"], status="foo") v2 = db.verification_update(v2["uuid"], status="foo")
vs = db.verification_list(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"]) self.assertEqual(v2["uuid"], vs[0]["uuid"])
def test_verification_delete(self): def test_verification_delete(self):

View File

@ -230,7 +230,7 @@ class MigrationWalkTestCase(rtest.DBTestCase,
def assertColumnCount(self, engine, table, columns): def assertColumnCount(self, engine, table, columns):
t = db_utils.get_table(engine, table) 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): def assertColumnNotExists(self, engine, table, column):
t = db_utils.get_table(engine, table) t = db_utils.get_table(engine, table)
@ -419,7 +419,7 @@ class MigrationWalkTestCase(rtest.DBTestCase,
"name": self._08e1515a576c_deployment_uuid, "name": self._08e1515a576c_deployment_uuid,
"config": six.b("{}"), "config": six.b("{}"),
"enum_deployments_status": "enum_deployments_status":
consts.DeployStatus.DEPLOY_FINISHED, consts.DeployStatus.DEPLOY_FINISHED,
"credentials": six.b(json.dumps([])), "credentials": six.b(json.dumps([])),
"users": 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) where(task_table.c.uuid == self._e654a0648db0_task_uuid)
).fetchall() ).fetchall()
self.assertEqual(len(tasks_found), 1) self.assertEqual(1, len(tasks_found))
task_found = tasks_found[0] task_found = tasks_found[0]
self.assertEqual(task_found.uuid, self._e654a0648db0_task_uuid) self.assertEqual(self._e654a0648db0_task_uuid, task_found.uuid)
self.assertEqual(task_found.deployment_uuid, self.assertEqual(self._e654a0648db0_deployment_uuid,
self._e654a0648db0_deployment_uuid) task_found.deployment_uuid)
self.assertEqual(task_found.status, consts.TaskStatus.FINISHED) self.assertEqual(consts.TaskStatus.FINISHED, task_found.status)
# NOTE(ikhudoshyn): if for all workloads success == True # 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 # 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 # NOTE(ikhudoshyn): we have no info on validation duration in old
# schema # schema
self.assertEqual(task_found.validation_duration, 0) self.assertEqual(0, task_found.validation_duration)
self.assertEqual(json.loads(task_found.validation_result), {}) self.assertEqual({}, json.loads(task_found.validation_result))
# Check subtask # Check subtask
@ -568,16 +568,16 @@ class MigrationWalkTestCase(rtest.DBTestCase,
self._e654a0648db0_task_uuid) self._e654a0648db0_task_uuid)
).fetchall() ).fetchall()
self.assertEqual(len(subtasks_found), 1) self.assertEqual(1, len(subtasks_found))
subtask_found = subtasks_found[0] subtask_found = subtasks_found[0]
self.assertEqual(subtask_found.task_uuid, self.assertEqual(self._e654a0648db0_task_uuid,
self._e654a0648db0_task_uuid) subtask_found.task_uuid)
# NOTE(ikhudoshyn): if for all workloads success == True # 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 # 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 self._e654a0648db0_subtask_uuid = subtask_found.uuid
@ -588,9 +588,9 @@ class MigrationWalkTestCase(rtest.DBTestCase,
where(tag_table.c.uuid == self._e654a0648db0_task_uuid) where(tag_table.c.uuid == self._e654a0648db0_task_uuid)
).fetchall() ).fetchall()
self.assertEqual(len(tags_found), 1) self.assertEqual(1, len(tags_found))
self.assertEqual(tags_found[0].tag, "test_tag") self.assertEqual("test_tag", tags_found[0].tag)
self.assertEqual(tags_found[0].type, consts.TagType.TASK) self.assertEqual(consts.TagType.TASK, tags_found[0].type)
# Check workload # Check workload
@ -600,43 +600,36 @@ class MigrationWalkTestCase(rtest.DBTestCase,
self._e654a0648db0_task_uuid) self._e654a0648db0_task_uuid)
).fetchall() ).fetchall()
self.assertEqual(len(workloads_found), 1) self.assertEqual(1, len(workloads_found))
workload_found = workloads_found[0] workload_found = workloads_found[0]
self.assertEqual(workload_found.task_uuid, self.assertEqual(self._e654a0648db0_task_uuid,
self._e654a0648db0_task_uuid) workload_found.task_uuid)
self.assertEqual(workload_found.subtask_uuid, self.assertEqual(self._e654a0648db0_subtask_uuid,
self._e654a0648db0_subtask_uuid) workload_found.subtask_uuid)
self.assertEqual(workload_found.name, "test_scenario") self.assertEqual("test_scenario", workload_found.name)
self.assertEqual(workload_found.position, 0) self.assertEqual(0, workload_found.position)
self.assertEqual(workload_found.runner_type, "theRunner") self.assertEqual("theRunner", workload_found.runner_type)
self.assertEqual(workload_found.runner, self.assertEqual(json.dumps({"type": "theRunner"}),
json.dumps({"type": "theRunner"})) workload_found.runner)
self.assertEqual(workload_found.sla, self.assertEqual(json.dumps({"s": "S"}), workload_found.sla)
json.dumps({"s": "S"})) self.assertEqual(json.dumps({"a": "A"}), workload_found.args)
self.assertEqual(workload_found.args, self.assertEqual(json.dumps({"c": "C"}), workload_found.context)
json.dumps({"a": "A"})) self.assertEqual(json.dumps({
self.assertEqual(workload_found.context, "sla": [{"success": True},
json.dumps({"c": "C"})) {"success": False}]
self.assertEqual(workload_found.sla_results, }), workload_found.sla_results)
json.dumps({ self.assertEqual(json.dumps({}), workload_found.context_execution)
"sla": [ self.assertEqual(42, workload_found.load_duration)
{"success": True}, self.assertEqual(142, workload_found.full_duration)
{"success": False} self.assertEqual(1, workload_found.min_duration)
] self.assertEqual(8, workload_found.max_duration)
})) self.assertEqual(3, workload_found.total_iteration_count)
self.assertEqual(workload_found.context_execution, self.assertEqual(1, workload_found.failed_iteration_count)
json.dumps({})) self.assertFalse(workload_found.pass_sla)
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._e654a0648db0_workload_uuid = workload_found.uuid self._e654a0648db0_workload_uuid = workload_found.uuid
@ -648,23 +641,22 @@ class MigrationWalkTestCase(rtest.DBTestCase,
self._e654a0648db0_task_uuid) self._e654a0648db0_task_uuid)
).fetchall() ).fetchall()
self.assertEqual(len(workloaddata_found), 1) self.assertEqual(1, len(workloaddata_found))
wloaddata_found = workloaddata_found[0] wloaddata_found = workloaddata_found[0]
self.assertEqual(wloaddata_found.task_uuid, self.assertEqual(self._e654a0648db0_task_uuid,
self._e654a0648db0_task_uuid) wloaddata_found.task_uuid)
self.assertEqual(wloaddata_found.workload_uuid, self.assertEqual(self._e654a0648db0_workload_uuid,
self._e654a0648db0_workload_uuid) wloaddata_found.workload_uuid)
self.assertEqual(wloaddata_found.chunk_order, 0) self.assertEqual(0, wloaddata_found.chunk_order)
self.assertEqual(wloaddata_found.chunk_size, 0) self.assertEqual(0, wloaddata_found.chunk_size)
self.assertEqual(wloaddata_found.compressed_chunk_size, 0) self.assertEqual(0, wloaddata_found.compressed_chunk_size)
self.assertEqual(wloaddata_found.iteration_count, 3) self.assertEqual(3, wloaddata_found.iteration_count)
self.assertEqual(wloaddata_found.failed_iteration_count, 1) self.assertEqual(1, wloaddata_found.failed_iteration_count)
self.assertEqual( self.assertEqual(
wloaddata_found.chunk_data,
json.dumps( json.dumps(
{ {
"raw": [ "raw": [
@ -673,7 +665,7 @@ class MigrationWalkTestCase(rtest.DBTestCase,
{"duration": 8}, {"duration": 8},
] ]
} }
) ), wloaddata_found.chunk_data
) )
# Delete all stuff created at _pre_upgrade step # Delete all stuff created at _pre_upgrade step
@ -939,7 +931,7 @@ class MigrationWalkTestCase(rtest.DBTestCase,
verifications_table.insert(), verifications_table.insert(),
[{"uuid": vuuid, [{"uuid": vuuid,
"deployment_uuid": "deployment_uuid":
self._484cd9413e66_deployment_uuid, self._484cd9413e66_deployment_uuid,
"status": vstatus, "status": vstatus,
"set_name": verification["set_name"], "set_name": verification["set_name"],
"tests": verification["total"]["tests"], "tests": verification["total"]["tests"],
@ -1286,7 +1278,7 @@ class MigrationWalkTestCase(rtest.DBTestCase,
"name": self._4ef544102ba7_deployment_uuid, "name": self._4ef544102ba7_deployment_uuid,
"config": six.b(json.dumps([])), "config": six.b(json.dumps([])),
"enum_deployments_status": "enum_deployments_status":
consts.DeployStatus.DEPLOY_FINISHED, consts.DeployStatus.DEPLOY_FINISHED,
"credentials": six.b(json.dumps([])), "credentials": six.b(json.dumps([])),
"users": six.b(json.dumps([])) "users": six.b(json.dumps([]))
}]) }])

View File

@ -50,20 +50,20 @@ class DeploymentTestCase(test.TestCase):
mock_deployment_create.return_value = self.deployment mock_deployment_create.return_value = self.deployment
deploy = objects.Deployment() deploy = objects.Deployment()
mock_deployment_create.assert_called_once_with({}) 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") @mock.patch("rally.common.objects.deploy.db.deployment_create")
def test_init_without_create(self, mock_deployment_create): def test_init_without_create(self, mock_deployment_create):
deploy = objects.Deployment(deployment=self.deployment) deploy = objects.Deployment(deployment=self.deployment)
self.assertFalse(mock_deployment_create.called) 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") @mock.patch("rally.common.objects.deploy.db.deployment_get")
def test_get(self, mock_deployment_get): def test_get(self, mock_deployment_get):
mock_deployment_get.return_value = self.deployment mock_deployment_get.return_value = self.deployment
deploy = objects.Deployment.get(self.deployment["uuid"]) deploy = objects.Deployment.get(self.deployment["uuid"])
mock_deployment_get.assert_called_once_with(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_delete")
@mock.patch("rally.common.objects.deploy.db.deployment_create") @mock.patch("rally.common.objects.deploy.db.deployment_create")
@ -88,7 +88,7 @@ class DeploymentTestCase(test.TestCase):
deploy._update({"opt": "val2"}) deploy._update({"opt": "val2"})
mock_deployment_update.assert_called_once_with( mock_deployment_update.assert_called_once_with(
self.deployment["uuid"], {"opt": "val2"}) self.deployment["uuid"], {"opt": "val2"})
self.assertEqual(deploy["opt"], "val2") self.assertEqual("val2", deploy["opt"])
@mock.patch("rally.common.objects.deploy.db.deployment_update") @mock.patch("rally.common.objects.deploy.db.deployment_update")
def test_update_status(self, mock_deployment_update): def test_update_status(self, mock_deployment_update):
@ -250,7 +250,7 @@ class DeploymentTestCase(test.TestCase):
deploy = objects.Deployment(deployment=self.deployment) deploy = objects.Deployment(deployment=self.deployment)
resource = deploy.add_resource("provider", type="some", resource = deploy.add_resource("provider", type="some",
info={"key": "value"}) info={"key": "value"})
self.assertEqual(resource["id"], self.resource["id"]) self.assertEqual(self.resource["id"], resource["id"])
mock_resource_create.assert_called_once_with({ mock_resource_create.assert_called_once_with({
"deployment_uuid": self.deployment["uuid"], "deployment_uuid": self.deployment["uuid"],
"provider_name": "provider", "provider_name": "provider",
@ -268,8 +268,8 @@ class DeploymentTestCase(test.TestCase):
mock_resource_get_all.return_value = [self.resource] mock_resource_get_all.return_value = [self.resource]
deploy = objects.Deployment(deployment=self.deployment) deploy = objects.Deployment(deployment=self.deployment)
resources = deploy.get_resources(provider_name="provider", type="some") resources = deploy.get_resources(provider_name="provider", type="some")
self.assertEqual(len(resources), 1) self.assertEqual(1, len(resources))
self.assertEqual(resources[0]["id"], self.resource["id"]) self.assertEqual(self.resource["id"], resources[0]["id"])
@mock.patch("rally.common.objects.deploy.dt.datetime") @mock.patch("rally.common.objects.deploy.dt.datetime")
@mock.patch("rally.common.objects.deploy.db.deployment_update") @mock.patch("rally.common.objects.deploy.db.deployment_update")

View File

@ -66,7 +66,7 @@ class TestMetaMixinTestCase(test.TestCase):
Meta._meta_init() Meta._meta_init()
Meta._meta_set("aaa", 42) 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): def test_meta_get_default(self):
@ -74,7 +74,7 @@ class TestMetaMixinTestCase(test.TestCase):
pass pass
Meta._meta_init() 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): def test_meta_get_if_is_not_inited(self):

View File

@ -79,8 +79,8 @@ class PluginModuleTestCase(test.TestCase):
class B(SecondBase): class B(SecondBase):
pass pass
self.assertEqual(A, OneBase.get(name)) self.assertEqual(OneBase.get(name), A)
self.assertEqual(B, SecondBase.get(name)) self.assertEqual(SecondBase.get(name), B)
def test_get_multiple_chooses(self): def test_get_multiple_chooses(self):
name = "test_get_multiple_chooses" name = "test_get_multiple_chooses"
@ -221,5 +221,5 @@ class PluginTestCase(test.TestCase):
def test_is_deprecated(self): def test_is_deprecated(self):
self.assertFalse(SomePlugin.is_deprecated()) self.assertFalse(SomePlugin.is_deprecated())
self.assertEqual(DeprecatedPlugin.is_deprecated(), self.assertEqual({"reason": "some_reason", "rally_version": "0.1.1"},
{"reason": "some_reason", "rally_version": "0.1.1"}) DeprecatedPlugin.is_deprecated())

View File

@ -224,14 +224,14 @@ class LogTestCase(test.TestCase):
return x + y return x + y
t = TaskLog() t = TaskLog()
self.assertEqual(t.some_method.__name__, "some_method") self.assertEqual("some_method", t.some_method.__name__)
self.assertEqual(t.some_method(2, 2), 4) self.assertEqual(4, t.some_method(2, 2))
params = {"msg": msg % {"a": 10, "b": 20}, "uuid": t.task["uuid"]} params = {"msg": msg % {"a": 10, "b": 20}, "uuid": t.task["uuid"]}
expected = [ expected = [
mock.call(_("Task %(uuid)s | Starting: %(msg)s") % params), mock.call(_("Task %(uuid)s | Starting: %(msg)s") % params),
mock.call(_("Task %(uuid)s | Completed: %(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): def test_log_deprecated(self):
mock_log = mock.MagicMock() mock_log = mock.MagicMock()
@ -240,7 +240,7 @@ class LogTestCase(test.TestCase):
def some_method(x, y): def some_method(x, y):
return 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("some_method()", mock_log.call_args[0][0])
self.assertIn("depr42", 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]) 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): def some_method(x, y, z):
return 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("ABC42", mock_log.call_args[0][0])
self.assertIn("`z' of `some_method()'", 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]) self.assertIn("0.0.1", mock_log.call_args[0][0])
mock_log.reset_mock() 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) self.assertFalse(mock_log.called)
@rally_logging.log_deprecated_args("CBA42", "0.0.1", ("z",), @rally_logging.log_deprecated_args("CBA42", "0.0.1", ("z",),
@ -267,9 +267,9 @@ class LogTestCase(test.TestCase):
def some_method(x, y, z): def some_method(x, y, z):
return 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]) self.assertIn("CBA42", mock_log.call_args[0][0])
mock_log.reset_mock() 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]) self.assertIn("CBA42", mock_log.call_args[0][0])

View File

@ -76,7 +76,7 @@ class SSHTestCase(test.TestCase):
key = self.ssh._get_pkey("key") key = self.ssh._get_pkey("key")
dss_calls = mock_paramiko.dsskey.DSSKey.from_private_key.mock_calls dss_calls = mock_paramiko.dsskey.DSSKey.from_private_key.mock_calls
self.assertEqual([mock.call("string_key")], dss_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_string_io.assert_called_once_with("key")
@mock.patch("rally.common.sshutils.six.moves.StringIO") @mock.patch("rally.common.sshutils.six.moves.StringIO")
@ -90,7 +90,7 @@ class SSHTestCase(test.TestCase):
key = self.ssh._get_pkey("key") key = self.ssh._get_pkey("key")
rsa_calls = mock_paramiko.rsakey.RSAKey.from_private_key.mock_calls rsa_calls = mock_paramiko.rsakey.RSAKey.from_private_key.mock_calls
self.assertEqual([mock.call("string_key")], rsa_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_string_io.assert_called_once_with("key")
@mock.patch("rally.common.sshutils.SSH._get_pkey") @mock.patch("rally.common.sshutils.SSH._get_pkey")

View File

@ -46,7 +46,7 @@ class ImmutableMixinTestCase(test.TestCase):
a = A("test") a = A("test")
self.assertRaises(AttributeError, self.assertRaises(AttributeError,
a.__setattr__, "abc", "test") a.__setattr__, "abc", "test")
self.assertEqual(a.test, "test") self.assertEqual("test", a.test)
class EnumMixinTestCase(test.TestCase): class EnumMixinTestCase(test.TestCase):
@ -58,7 +58,7 @@ class EnumMixinTestCase(test.TestCase):
b = 20 b = 20
CC = "2000" 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): def test_with_underscore(self):
@ -67,7 +67,7 @@ class EnumMixinTestCase(test.TestCase):
b = 20 b = 20
_CC = "2000" _CC = "2000"
self.assertEqual(set(list(Foo())), set([10, 20])) self.assertEqual(set([10, 20]), set(list(Foo())))
class StdIOCaptureTestCase(test.TestCase): class StdIOCaptureTestCase(test.TestCase):
@ -79,8 +79,8 @@ class StdIOCaptureTestCase(test.TestCase):
for msg in messages: for msg in messages:
print(msg) print(msg)
self.assertEqual(out.getvalue().rstrip("\n").split("\n"), messages) self.assertEqual(messages, out.getvalue().rstrip("\n").split("\n"))
self.assertEqual(stdout, sys.stdout) self.assertEqual(sys.stdout, stdout)
def test_stderr_capture(self): def test_stderr_capture(self):
stderr = sys.stderr stderr = sys.stderr
@ -89,8 +89,8 @@ class StdIOCaptureTestCase(test.TestCase):
for msg in messages: for msg in messages:
print(msg, file=sys.stderr) print(msg, file=sys.stderr)
self.assertEqual(err.getvalue().rstrip("\n").split("\n"), messages) self.assertEqual(messages, err.getvalue().rstrip("\n").split("\n"))
self.assertEqual(stderr, sys.stderr) self.assertEqual(sys.stderr, stderr)
class TimerTestCase(test.TestCase): class TimerTestCase(test.TestCase):
@ -141,9 +141,9 @@ class FirstIndexTestCase(test.TestCase):
def test_list_with_existing_matching_element(self): def test_list_with_existing_matching_element(self):
lst = [1, 3, 5, 7] lst = [1, 3, 5, 7]
self.assertEqual(utils.first_index(lst, lambda e: e == 1), 0) self.assertEqual(0, utils.first_index(lst, lambda e: e == 1))
self.assertEqual(utils.first_index(lst, lambda e: e == 5), 2) self.assertEqual(2, utils.first_index(lst, lambda e: e == 5))
self.assertEqual(utils.first_index(lst, lambda e: e == 7), 3) self.assertEqual(3, utils.first_index(lst, lambda e: e == 7))
def test_list_with_non_existing_matching_element(self): def test_list_with_non_existing_matching_element(self):
lst = [1, 3, 5, 7] lst = [1, 3, 5, 7]
@ -242,7 +242,7 @@ class RandomNameTestCase(test.TestCase):
generator = FakeNameGenerator() generator = FakeNameGenerator()
mock_choice.side_effect = iter("blarglesdweebled") mock_choice.side_effect = iter("blarglesdweebled")
self.assertEqual(generator.generate_random_name(), expected) self.assertEqual(expected, generator.generate_random_name())
class FakeNameGenerator(utils.RandomNameGeneratorMixin): class FakeNameGenerator(utils.RandomNameGeneratorMixin):
RESOURCE_NAME_FORMAT = fmt RESOURCE_NAME_FORMAT = fmt
@ -251,7 +251,7 @@ class RandomNameTestCase(test.TestCase):
generator = FakeNameGenerator() generator = FakeNameGenerator()
mock_choice.side_effect = iter("blarglesdweebled") 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): def test_generate_random_name_bogus_name_format(self):
class FakeNameGenerator(utils.RandomNameGeneratorMixin): class FakeNameGenerator(utils.RandomNameGeneratorMixin):
@ -393,13 +393,13 @@ class RandomNameTestCase(test.TestCase):
names = [generator.generate_random_name() for i in range(100)] names = [generator.generate_random_name() for i in range(100)]
task_id_parts = set([n.split("_")[0] for n in names]) 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!"} generator.task = {"uuid": "bogus! task! id!"}
names = [generator.generate_random_name() for i in range(100)] names = [generator.generate_random_name() for i in range(100)]
task_id_parts = set([n.split("_")[0] for n in names]) 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): def test_make_name_matcher(self):
matcher = utils.make_name_matcher("foo", "bar") matcher = utils.make_name_matcher("foo", "bar")
@ -457,7 +457,7 @@ class MergeTestCase(test.TestCase):
in_iters = [iter(src) for src in sources] in_iters = [iter(src) for src in sources]
out = list(utils.merge(10, *in_iters)) out = list(utils.merge(10, *in_iters))
self.assertEqual(out, expected_output) self.assertEqual(expected_output, out)
class TimeoutThreadTestCase(test.TestCase): class TimeoutThreadTestCase(test.TestCase):
@ -506,10 +506,10 @@ class LockedDictTestCase(test.TestCase):
d = utils.LockedDict() d = utils.LockedDict()
self.assertIsInstance(d, dict) self.assertIsInstance(d, dict)
self.assertEqual(d, {}) self.assertEqual({}, d)
d = utils.LockedDict(foo="bar", spam={"a": ["b", {"c": "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"], utils.LockedDict)
self.assertIsInstance(d["spam"]["a"][1], utils.LockedDict) self.assertIsInstance(d["spam"]["a"][1], utils.LockedDict)
self.assertRaises(RuntimeError, setitem, d, 123, 456) 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.pop, "foo")
self.assertRaises(RuntimeError, d.popitem) self.assertRaises(RuntimeError, d.popitem)
self.assertRaises(RuntimeError, d.clear) 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(): with d.unlocked():
d["spam"] = 42 d["spam"] = 42
self.assertEqual(d, {"foo": "bar", "spam": 42}) self.assertEqual({"foo": "bar", "spam": 42}, d)
d.clear() d.clear()
self.assertEqual(d, {}) self.assertEqual({}, d)
d.setdefault("foo", 42) d.setdefault("foo", 42)
d.update({"bar": 24}) 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(24, d.pop("bar"))
self.assertEqual(("foo", 42), d.popitem()) self.assertEqual(("foo", 42), d.popitem())
d[123] = 456 d[123] = 456
self.assertEqual(d, {123: 456}) self.assertEqual({123: 456}, d)
self.assertRaises(RuntimeError, setitem, d, 123, 456) self.assertRaises(RuntimeError, setitem, d, 123, 456)
self.assertRaises(RuntimeError, delitem, d, "foo") self.assertRaises(RuntimeError, delitem, d, "foo")
@ -798,7 +798,7 @@ class BackupTestCase(test.TestCase):
# it is expected behaviour # it is expected behaviour
pass pass
else: else:
self.fail("BackupHelper context manager should not hide an " self.fail("BackupHelper context manager should not hide "
"exception") "an exception")
self.assertTrue(mock_backup_helper_rollback.called) self.assertTrue(mock_backup_helper_rollback.called)

View File

@ -59,7 +59,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase):
result = constant._run_scenario_once_with_unpack_args( result = constant._run_scenario_once_with_unpack_args(
("FOO", ("BAR", "QUUZ"))) ("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( mock_runner._run_scenario_once.assert_called_once_with(
"FOO", ("BAR", "QUUZ")) "FOO", ("BAR", "QUUZ"))
@ -129,7 +129,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase):
runner_obj._run_scenario( runner_obj._run_scenario(
fakes.FakeScenario, "do_it", self.context, self.args) 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_batch in runner_obj.result_queue:
for result in result_batch: for result in result_batch:
self.assertIsNotNone(result) self.assertIsNotNone(result)
@ -139,7 +139,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase):
runner_obj._run_scenario(fakes.FakeScenario, "something_went_wrong", runner_obj._run_scenario(fakes.FakeScenario, "something_went_wrong",
self.context, self.args) 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_batch in runner_obj.result_queue:
for result in result_batch: for result in result_batch:
self.assertIsNotNone(result) self.assertIsNotNone(result)
@ -151,7 +151,7 @@ class ConstantScenarioRunnerTestCase(test.TestCase):
runner_obj.abort() runner_obj.abort()
runner_obj._run_scenario(fakes.FakeScenario, "do_it", self.context, runner_obj._run_scenario(fakes.FakeScenario, "do_it", self.context,
self.args) 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.Queue")
@mock.patch(RUNNERS + "constant.multiprocessing.cpu_count") @mock.patch(RUNNERS + "constant.multiprocessing.cpu_count")
@ -287,7 +287,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase):
self.context, self.args) self.context, self.args)
# NOTE(mmorais): when duration is 0, scenario executes exactly 1 time # NOTE(mmorais): when duration is 0, scenario executes exactly 1 time
expected_times = 1 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_batch in runner_obj.result_queue:
for result in result_batch: for result in result_batch:
self.assertIsNotNone(result) self.assertIsNotNone(result)
@ -300,7 +300,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase):
self.context, self.args) self.context, self.args)
# NOTE(mmorais): when duration is 0, scenario executes exactly 1 time # NOTE(mmorais): when duration is 0, scenario executes exactly 1 time
expected_times = 1 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_batch in runner_obj.result_queue:
for result in result_batch: for result in result_batch:
self.assertIsNotNone(result) self.assertIsNotNone(result)
@ -314,7 +314,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase):
self.context, self.args) self.context, self.args)
# NOTE(mmorais): when duration is 0, scenario executes exactly 1 time # NOTE(mmorais): when duration is 0, scenario executes exactly 1 time
expected_times = 1 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_batch in runner_obj.result_queue:
for result in result_batch: for result in result_batch:
self.assertIsNotNone(result) self.assertIsNotNone(result)
@ -327,7 +327,7 @@ class ConstantForDurationScenarioRunnerTestCase(test.TestCase):
runner_obj.abort() runner_obj.abort()
runner_obj._run_scenario(fakes.FakeScenario, "do_it", runner_obj._run_scenario(fakes.FakeScenario, "do_it",
self.context, self.args) self.context, self.args)
self.assertEqual(len(runner_obj.result_queue), 0) self.assertEqual(0, len(runner_obj.result_queue))
def test_abort(self): def test_abort(self):
runner_obj = constant.ConstantForDurationScenarioRunner(None, runner_obj = constant.ConstantForDurationScenarioRunner(None,

View File

@ -289,7 +289,7 @@ class RPSScenarioRunnerTestCase(test.TestCase):
runner_obj._run_scenario(fakes.FakeScenario, "something_went_wrong", runner_obj._run_scenario(fakes.FakeScenario, "something_went_wrong",
fakes.FakeContext({}).context, {}) 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_batch in runner_obj.result_queue:
for result in result_batch: for result in result_batch:
self.assertIsNotNone(result) self.assertIsNotNone(result)
@ -303,7 +303,7 @@ class RPSScenarioRunnerTestCase(test.TestCase):
runner_obj._run_scenario(fakes.FakeScenario, "do_it", runner_obj._run_scenario(fakes.FakeScenario, "do_it",
fakes.FakeUser().context, {}) 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: for result in runner_obj.result_queue:
self.assertIsNotNone(result) self.assertIsNotNone(result)

View File

@ -39,9 +39,9 @@ class SerialScenarioRunnerTestCase(test.TestCase):
runner._run_scenario(fakes.FakeScenario, "do_it", runner._run_scenario(fakes.FakeScenario, "do_it",
fakes.FakeContext().context, {}) fakes.FakeContext().context, {})
self.assertEqual(len(runner.result_queue), times) self.assertEqual(times, len(runner.result_queue))
results = list(runner.result_queue) results = list(runner.result_queue)
self.assertEqual(results, expected_results) self.assertEqual(expected_results, results)
expected_calls = [] expected_calls = []
for i in range(times): for i in range(times):
ctxt = fakes.FakeContext().context ctxt = fakes.FakeContext().context
@ -60,7 +60,7 @@ class SerialScenarioRunnerTestCase(test.TestCase):
runner.abort() runner.abort()
runner._run_scenario(fakes.FakeScenario, "do_it", runner._run_scenario(fakes.FakeScenario, "do_it",
fakes.FakeContext().context, {}) fakes.FakeContext().context, {})
self.assertEqual(len(runner.result_queue), 0) self.assertEqual(0, len(runner.result_queue))
def test_abort(self): def test_abort(self):
runner = serial.SerialScenarioRunner(mock.MagicMock(), runner = serial.SerialScenarioRunner(mock.MagicMock(),

View File

@ -57,7 +57,7 @@ class FileTypeTestCase(test.TestCase):
resource_config = "file.yaml" resource_config = "file.yaml"
file_context = types.FileType.transform( file_context = types.FileType.transform(
clients=None, resource_config=resource_config) 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) @mock.patch("six.moves.builtins.open", side_effect=IOError, create=True)
def test_transform_by_path_no_match(self, mock_open): def test_transform_by_path_no_match(self, mock_open):
@ -78,7 +78,7 @@ class FileTypeDictTestCase(test.TestCase):
file_context = types.FileTypeDict.transform( file_context = types.FileTypeDict.transform(
clients=None, clients=None,
resource_config=resource_config) 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) @mock.patch("six.moves.builtins.open", side_effect=IOError, create=True)
def test_transform_by_path_no_match(self, mock_open): def test_transform_by_path_no_match(self, mock_open):

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

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

View File

@ -186,7 +186,7 @@ class PlotTestCase(test.TestCase):
"met": "dummy", "met": "dummy",
"pos": str(c)}) "pos": str(c)})
source, p_workloads = plot._process_workloads(workloads) source, p_workloads = plot._process_workloads(workloads)
self.assertEqual(source, "json_data") self.assertEqual("json_data", source)
mock_json_dumps.assert_called_once_with( mock_json_dumps.assert_called_once_with(
{"Foo.bar_1": [{"runner": {"type": "constant", "times": 3}, {"Foo.bar_1": [{"runner": {"type": "constant", "times": 3},
"hooks": [{"hook1": "xxx"}], "hooks": [{"hook1": "xxx"}],
@ -231,7 +231,7 @@ class PlotTestCase(test.TestCase):
html = plot.plot([task_dict], **ddt_kwargs) 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_get_template.assert_called_once_with("task/report.html")
mock__process_workloads.assert_called_once_with(["foo", "bar"]) mock__process_workloads.assert_called_once_with(["foo", "bar"])
if "include_libs" in ddt_kwargs: if "include_libs" in ddt_kwargs:

View File

@ -124,13 +124,11 @@ class AtomicActionTestCase(test.TestCase):
inst = TestAtomicTimer() inst = TestAtomicTimer()
self.assertEqual(5, inst.some_func(2, 3, atomic_action=False)) self.assertEqual(5, inst.some_func(2, 3, atomic_action=False))
self.assertEqual([], self.assertEqual([], inst.atomic_actions())
inst.atomic_actions())
inst = TestAtomicTimer() inst = TestAtomicTimer()
self.assertEqual(5, inst.other_func(2, 3)) self.assertEqual(5, inst.other_func(2, 3))
self.assertEqual([], self.assertEqual([], inst.atomic_actions())
inst.atomic_actions())
inst = TestAtomicTimer() inst = TestAtomicTimer()
self.assertEqual(5, inst.other_func(2, 3, foo=True)) self.assertEqual(5, inst.other_func(2, 3, foo=True))

View File

@ -38,9 +38,9 @@ class BaseContextTestCase(test.TestCase):
def test_init(self, config, expected): def test_init(self, config, expected):
ctx = {"config": {"foo": 42, "fake": config}, "task": "foo_task"} ctx = {"config": {"foo": 42, "fake": config}, "task": "foo_task"}
ins = fakes.FakeContext(ctx) ins = fakes.FakeContext(ctx)
self.assertEqual(ins.config, expected) self.assertEqual(expected, ins.config)
self.assertEqual(ins.task, "foo_task") self.assertEqual("foo_task", ins.task)
self.assertEqual(ins.context, ctx) self.assertEqual(ctx, ins.context)
def test_init_with_default_config(self): def test_init_with_default_config(self):
@context.configure(name="foo", order=1) @context.configure(name="foo", order=1)
@ -58,16 +58,16 @@ class BaseContextTestCase(test.TestCase):
"config": {"fake": {"foo": 42}} "config": {"fake": {"foo": 42}}
} }
ctx = fakes.FakeContext(ctx0) ctx = fakes.FakeContext(ctx0)
self.assertEqual(ctx.config, ctx0["config"]["fake"]) self.assertEqual(ctx0["config"]["fake"], ctx.config)
self.assertEqual(ctx.task, ctx0["task"]) self.assertEqual(ctx0["task"], ctx.task)
self.assertEqual(ctx.context, ctx0) self.assertEqual(ctx0, ctx.context)
@ddt.data(({"test": 2}, True), ({"nonexisting": 2}, False)) @ddt.data(({"test": 2}, True), ({"nonexisting": 2}, False))
@ddt.unpack @ddt.unpack
def test_validate(self, config, valid): def test_validate(self, config, valid):
results = context.Context.validate("fake", None, None, config) results = context.Context.validate("fake", None, None, config)
if valid: if valid:
self.assertEqual([], results) self.assertEqual(results, [])
else: else:
self.assertEqual(1, len(results)) self.assertEqual(1, len(results))

View File

@ -625,7 +625,7 @@ class TaskEngineTestCase(test.TestCase):
"scenario_namespace": "openstack", "scenario_namespace": "openstack",
"config": {"a": 1, "b": 3, "c": 4, "users": {}} "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) mock_scenario_get.assert_called_once_with(name)

View File

@ -42,14 +42,14 @@ class ScenarioRunnerHelpersTestCase(test.TestCase):
"error": mock_format_exc.return_value "error": mock_format_exc.return_value
} }
self.assertEqual(runner.format_result_on_timeout(mock_exc, 100), self.assertEqual(expected,
expected) runner.format_result_on_timeout(mock_exc, 100))
mock_format_exc.assert_called_once_with(mock_exc) mock_format_exc.assert_called_once_with(mock_exc)
def test_get_scenario_context(self): def test_get_scenario_context(self):
context_obj = {"foo": "bar"} context_obj = {"foo": "bar"}
result = runner._get_scenario_context(13, context_obj) 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): def test_run_scenario_once_internal_logic(self):
context = runner._get_scenario_context( context = runner._get_scenario_context(

View File

@ -67,7 +67,7 @@ class ScenarioTestCase(test.TestCase):
scenario_inst = scenario.Scenario() scenario_inst = scenario.Scenario()
scenario_inst.sleep_between(0.001, 0.001) scenario_inst.sleep_between(0.001, 0.001)
scenario_inst.sleep_between(0.004, 0.004) 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.common.utils.interruptable_sleep")
@mock.patch("rally.task.scenario.random.uniform") @mock.patch("rally.task.scenario.random.uniform")

View File

@ -87,14 +87,14 @@ class BenchmarkUtilsTestCase(test.TestCase):
manager = fakes.FakeManager() manager = fakes.FakeManager()
resource = fakes.FakeResource(manager=manager) resource = fakes.FakeResource(manager=manager)
manager._cache(resource) 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): def test_get_from_manager_with_uuid_field(self):
get_from_manager = utils.get_from_manager() get_from_manager = utils.get_from_manager()
manager = fakes.FakeManager() manager = fakes.FakeManager()
resource = fakes.FakeResource(manager=manager) resource = fakes.FakeResource(manager=manager)
manager._cache(resource) 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): def test_get_from_manager_in_error_state(self):
get_from_manager = utils.get_from_manager() get_from_manager = utils.get_from_manager()
@ -238,10 +238,10 @@ class WaitForTestCase(test.TestCase):
update_resource=self.fake_updater, timeout=self.load_secs, update_resource=self.fake_updater, timeout=self.load_secs,
check_interval=self.load_secs / 3) check_interval=self.load_secs / 3)
self.assertEqual(exc.kwargs["resource_name"], "fake_name") self.assertEqual("fake_name", exc.kwargs["resource_name"])
self.assertEqual(exc.kwargs["resource_id"], "fake_id") self.assertEqual("fake_id", exc.kwargs["resource_id"])
self.assertEqual(exc.kwargs["desired_status"], "fake_new_status") self.assertEqual("fake_new_status", exc.kwargs["desired_status"])
self.assertEqual(exc.kwargs["resource_status"], "FAKE_STALE_STATUS") self.assertEqual("FAKE_STALE_STATUS", exc.kwargs["resource_status"])
self.assertIn("FakeResource", str(exc)) self.assertIn("FakeResource", str(exc))
self.assertIn("fake_new_status", str(exc)) self.assertIn("fake_new_status", str(exc))

View File

@ -301,7 +301,7 @@ class ValidatorsTestCase(test.TestCase):
result = validation._get_validated_flavor({"args": {"a": "test"}}, result = validation._get_validated_flavor({"args": {"a": "test"}},
clients, "a") clients, "a")
self.assertTrue(result[0].is_valid, result[0].msg) self.assertTrue(result[0].is_valid, result[0].msg)
self.assertEqual(result[1], "flavor") self.assertEqual("flavor", result[1])
mock_flavor_transform.assert_called_once_with( mock_flavor_transform.assert_called_once_with(
clients=clients, resource_config="test") clients=clients, resource_config="test")
clients.nova().flavors.get.assert_called_once_with(flavor="flavor_id") clients.nova().flavors.get.assert_called_once_with(flavor="flavor_id")

View File

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

View File

@ -355,7 +355,7 @@ class OSClientsTestCase(test.TestCase):
def test_keystone(self): def test_keystone(self):
self.assertNotIn("keystone", self.clients.cache) self.assertNotIn("keystone", self.clients.cache)
client = self.clients.keystone() client = self.clients.keystone()
self.assertEqual(client, self.fake_keystone) self.assertEqual(self.fake_keystone, client)
credential = {"timeout": cfg.CONF.openstack_client_http_timeout, credential = {"timeout": cfg.CONF.openstack_client_http_timeout,
"insecure": False, "cacert": None} "insecure": False, "cacert": None}
kwargs = self.credential.to_dict() kwargs = self.credential.to_dict()
@ -760,7 +760,7 @@ class OSClientsTestCase(test.TestCase):
self.assertNotIn("swift", self.clients.cache) self.assertNotIn("swift", self.clients.cache)
with mock.patch.dict("sys.modules", {"swiftclient": mock_swift}): with mock.patch.dict("sys.modules", {"swiftclient": mock_swift}):
client = self.clients.swift() client = self.clients.swift()
self.assertEqual(client, fake_swift) self.assertEqual(fake_swift, client)
self.service_catalog.url_for.assert_called_once_with( self.service_catalog.url_for.assert_called_once_with(
service_type="object-store", service_type="object-store",
region_name=self.credential.region_name) region_name=self.credential.region_name)
@ -773,7 +773,7 @@ class OSClientsTestCase(test.TestCase):
"tenant_name": self.credential.tenant_name, "tenant_name": self.credential.tenant_name,
} }
mock_swift.client.Connection.assert_called_once_with(**kw) 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") @mock.patch("rally.osclients.EC2._get_endpoint")
def test_ec2(self, mock_ec2__get_endpoint): def test_ec2(self, mock_ec2__get_endpoint):

View File

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