diff --git a/ironic/tests/api/test_acl.py b/ironic/tests/api/test_acl.py index 144f7d9935..57056fc4ec 100644 --- a/ironic/tests/api/test_acl.py +++ b/ironic/tests/api/test_acl.py @@ -51,7 +51,7 @@ class TestACL(base.FunctionalTest): def test_non_authenticated(self): response = self.get_json(self.node_path, expect_errors=True) - self.assertEqual(response.status_int, 401) + self.assertEqual(401, response.status_int) def test_authenticated(self): with mock.patch.object(self.dbapi, 'get_node', @@ -61,7 +61,7 @@ class TestACL(base.FunctionalTest): response = self.get_json(self.node_path, headers={'X-Auth-Token': utils.ADMIN_TOKEN}) - self.assertEqual(response['uuid'], self.fake_node['uuid']) + self.assertEqual(self.fake_node['uuid'], response['uuid']) mock_get_node.assert_called_once_with(self.fake_node['uuid']) def test_non_admin(self): @@ -69,7 +69,7 @@ class TestACL(base.FunctionalTest): headers={'X-Auth-Token': utils.MEMBER_TOKEN}, expect_errors=True) - self.assertEqual(response.status_int, 403) + self.assertEqual(403, response.status_int) def test_non_admin_with_admin_header(self): response = self.get_json(self.node_path, @@ -77,7 +77,7 @@ class TestACL(base.FunctionalTest): 'X-Roles': 'admin'}, expect_errors=True) - self.assertEqual(response.status_int, 403) + self.assertEqual(403, response.status_int) def test_public_api(self): # expect_errors should be set to True: If expect_errors is set to False @@ -85,4 +85,4 @@ class TestACL(base.FunctionalTest): # code so easy. response = self.get_json('/', expect_errors=True) - self.assertEqual(response.status_int, 200) + self.assertEqual(200, response.status_int) diff --git a/ironic/tests/api/test_base.py b/ironic/tests/api/test_base.py index e7557ebcd7..829478b5ef 100644 --- a/ironic/tests/api/test_base.py +++ b/ironic/tests/api/test_base.py @@ -25,6 +25,6 @@ class TestBase(base.FunctionalTest): response = self.get_json('/bad/path', expect_errors=True, headers={"Accept": "application/json"}) - self.assertEqual(response.status_int, 404) - self.assertEqual(response.content_type, "application/json") + self.assertEqual(404, response.status_int) + self.assertEqual("application/json", response.content_type) self.assertTrue(response.json['error_message']) diff --git a/ironic/tests/api/test_chassis.py b/ironic/tests/api/test_chassis.py index 92a7933a1d..9c1a103a95 100644 --- a/ironic/tests/api/test_chassis.py +++ b/ironic/tests/api/test_chassis.py @@ -64,9 +64,9 @@ class TestListChassis(base.FunctionalTest): chassis = self.dbapi.create_chassis(ndict) ch_list.append(chassis['uuid']) data = self.get_json('/chassis') - self.assertEqual(len(data['chassis']), len(ch_list)) + self.assertEqual(len(ch_list), len(data['chassis'])) uuids = [n['uuid'] for n in data['chassis']] - self.assertEqual(uuids.sort(), ch_list.sort()) + self.assertEqual(ch_list.sort(), uuids.sort()) def test_links(self): uuid = utils.generate_uuid() diff --git a/ironic/tests/api/test_root.py b/ironic/tests/api/test_root.py index a1f6030b71..91cf528db6 100644 --- a/ironic/tests/api/test_root.py +++ b/ironic/tests/api/test_root.py @@ -20,7 +20,7 @@ class TestRoot(base.FunctionalTest): def test_get_root(self): data = self.get_json('/', path_prefix='') - self.assertEqual(data['default_version']['id'], 'v1') + self.assertEqual('v1', data['default_version']['id']) # Check fields are not empty [self.assertNotIn(f, ['', []]) for f in data.keys()] @@ -29,7 +29,7 @@ class TestV1Root(base.FunctionalTest): def test_get_v1_root(self): data = self.get_json('/') - self.assertEqual(data['id'], 'v1') + self.assertEqual('v1', data['id']) # Check fields are not empty for f in data.keys(): self.assertNotIn(f, ['', []]) diff --git a/ironic/tests/conductor/test_conductor_utils.py b/ironic/tests/conductor/test_conductor_utils.py index a82c92c41b..faa645dc45 100644 --- a/ironic/tests/conductor/test_conductor_utils.py +++ b/ironic/tests/conductor/test_conductor_utils.py @@ -51,7 +51,7 @@ class NodePowerActionTestCase(base.DbTestCase): node.refresh(self.context) get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) - self.assertEqual(node['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) @@ -72,7 +72,7 @@ class NodePowerActionTestCase(base.DbTestCase): node.refresh(self.context) get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) - self.assertEqual(node['power_state'], states.POWER_OFF) + self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) @@ -90,7 +90,7 @@ class NodePowerActionTestCase(base.DbTestCase): node.refresh(self.context) reboot_mock.assert_called_once_with(mock.ANY, mock.ANY) - self.assertEqual(node['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) @@ -116,7 +116,7 @@ class NodePowerActionTestCase(base.DbTestCase): node.refresh(self.context) get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) - self.assertEqual(node['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error']) @@ -124,7 +124,7 @@ class NodePowerActionTestCase(base.DbTestCase): conductor_utils.node_power_action(task, task.node, states.POWER_OFF) node.refresh(self.context) - self.assertEqual(node['power_state'], states.POWER_OFF) + self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) @@ -146,8 +146,8 @@ class NodePowerActionTestCase(base.DbTestCase): states.POWER_OFF) node.refresh(self.context) - self.assertEqual(node['power_state'], states.POWER_OFF) - self.assertEqual(node['target_power_state'], states.NOSTATE) + self.assertEqual(states.POWER_OFF, node['power_state']) + self.assertEqual(states.NOSTATE, node['target_power_state']) self.assertIsNone(node['last_error']) def test_node_power_action_in_same_state(self): @@ -174,7 +174,7 @@ class NodePowerActionTestCase(base.DbTestCase): get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) self.assertFalse(set_power_mock.called, "set_power_state unexpectedly called") - self.assertEqual(node['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNone(node['last_error']) @@ -201,7 +201,7 @@ class NodePowerActionTestCase(base.DbTestCase): node.refresh(self.context) validate_mock.assert_called_once_with(mock.ANY, mock.ANY) - self.assertEqual(node['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_ON, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error']) @@ -233,6 +233,6 @@ class NodePowerActionTestCase(base.DbTestCase): get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) set_power_mock.assert_called_once_with(mock.ANY, mock.ANY, states.POWER_ON) - self.assertEqual(node['power_state'], states.POWER_OFF) + self.assertEqual(states.POWER_OFF, node['power_state']) self.assertIsNone(node['target_power_state']) self.assertIsNotNone(node['last_error']) diff --git a/ironic/tests/conductor/test_manager.py b/ironic/tests/conductor/test_manager.py index e7aedc1de3..46091f3685 100644 --- a/ironic/tests/conductor/test_manager.py +++ b/ironic/tests/conductor/test_manager.py @@ -59,7 +59,7 @@ class ManagerTestCase(base.DbTestCase): 'test-host') self.service.start() res = self.dbapi.get_conductor('test-host') - self.assertEqual(res['hostname'], 'test-host') + self.assertEqual('test-host', res['hostname']) def test_start_registers_driver_names(self): init_names = ['fake1', 'fake2'] @@ -71,13 +71,13 @@ class ManagerTestCase(base.DbTestCase): mock_names.return_value = init_names self.service.start() res = self.dbapi.get_conductor('test-host') - self.assertEqual(res['drivers'], init_names) + self.assertEqual(init_names, res['drivers']) # verify that restart registers new driver names mock_names.return_value = restart_names self.service.start() res = self.dbapi.get_conductor('test-host') - self.assertEqual(res['drivers'], restart_names) + self.assertEqual(restart_names, res['drivers']) def test__conductor_service_record_keepalive(self): self.service.start() @@ -95,7 +95,7 @@ class ManagerTestCase(base.DbTestCase): self.service._sync_power_states(self.context) get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) node = self.dbapi.get_node(n['id']) - self.assertEqual(node['power_state'], 'fake-power') + self.assertEqual('fake-power', node['power_state']) def test__sync_power_state_not_set(self): self.service.start() @@ -107,7 +107,7 @@ class ManagerTestCase(base.DbTestCase): self.service._sync_power_states(self.context) get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) node = self.dbapi.get_node(n['id']) - self.assertEqual(node['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_ON, node['power_state']) @mock.patch.object(objects.node.Node, 'save') def test__sync_power_state_unchanged(self, save_mock): @@ -213,8 +213,8 @@ class ManagerTestCase(base.DbTestCase): get_power_mock.assert_called_once_with(mock.ANY, mock.ANY) n1 = self.dbapi.get_node(nodes[0]) n3 = self.dbapi.get_node(nodes[2]) - self.assertEqual(n1['power_state'], states.POWER_OFF) - self.assertEqual(n3['power_state'], states.POWER_ON) + self.assertEqual(states.POWER_OFF, n1['power_state']) + self.assertEqual(states.POWER_ON, n3['power_state']) def test__sync_power_state_node_no_power_state(self): self.service.start() @@ -249,7 +249,7 @@ class ManagerTestCase(base.DbTestCase): final = [states.POWER_ON, states.POWER_OFF, states.POWER_ON] for i in range(0, 3): n = self.dbapi.get_node(nodes[i]) - self.assertEqual(n.power_state, final[i]) + self.assertEqual(final[i], n.power_state) def test__sync_power_state_node_deploywait(self): self.service.start() @@ -386,7 +386,7 @@ class ManagerTestCase(base.DbTestCase): # check that ManagerService.update_node actually updates the node node['extra'] = {'test': 'two'} res = self.service.update_node(self.context, node) - self.assertEqual(res['extra'], {'test': 'two'}) + self.assertEqual({'test': 'two'}, res['extra']) def test_update_node_already_locked(self): ndict = utils.get_test_node(driver='fake', extra={'test': 'one'}) @@ -402,7 +402,7 @@ class ManagerTestCase(base.DbTestCase): # verify change did not happen res = objects.Node.get_by_uuid(self.context, node['uuid']) - self.assertEqual(res['extra'], {'test': 'one'}) + self.assertEqual({'test': 'one'}, res['extra']) def test_associate_node_invalid_state(self): ndict = utils.get_test_node(driver='fake', @@ -437,7 +437,7 @@ class ManagerTestCase(base.DbTestCase): # Check if the change was applied res = objects.Node.get_by_uuid(self.context, node['uuid']) - self.assertEqual(res['instance_uuid'], 'fake-uuid') + self.assertEqual('fake-uuid', res['instance_uuid']) def test_update_node_invalid_driver(self): existing_driver = 'fake' @@ -457,7 +457,7 @@ class ManagerTestCase(base.DbTestCase): # verify change did not happen res = objects.Node.get_by_uuid(self.context, node['uuid']) - self.assertEqual(res['driver'], existing_driver) + self.assertEqual(existing_driver, res['driver']) def test_vendor_action(self): n = utils.get_test_node(driver='fake') @@ -535,8 +535,8 @@ class ManagerTestCase(base.DbTestCase): self.service.do_node_deploy, self.context, node['uuid']) node.refresh(self.context) - self.assertEqual(node['provision_state'], states.DEPLOYFAIL) - self.assertEqual(node['target_provision_state'], states.NOSTATE) + self.assertEqual(states.DEPLOYFAIL, node['provision_state']) + self.assertEqual(states.NOSTATE, node['target_provision_state']) self.assertIsNotNone(node['last_error']) deploy.assert_called_once_with(mock.ANY, mock.ANY) @@ -551,8 +551,8 @@ class ManagerTestCase(base.DbTestCase): deploy.return_value = states.DEPLOYDONE self.service.do_node_deploy(self.context, node['uuid']) node.refresh(self.context) - self.assertEqual(node['provision_state'], states.ACTIVE) - self.assertEqual(node['target_provision_state'], states.NOSTATE) + self.assertEqual(states.ACTIVE, node['provision_state']) + self.assertEqual(states.NOSTATE, node['target_provision_state']) self.assertIsNone(node['last_error']) deploy.assert_called_once_with(mock.ANY, mock.ANY) @@ -567,8 +567,8 @@ class ManagerTestCase(base.DbTestCase): deploy.return_value = states.DEPLOYING self.service.do_node_deploy(self.context, node['uuid']) node.refresh(self.context) - self.assertEqual(node['provision_state'], states.DEPLOYING) - self.assertEqual(node['target_provision_state'], states.DEPLOYDONE) + self.assertEqual(states.DEPLOYING, node['provision_state']) + self.assertEqual(states.DEPLOYDONE, node['target_provision_state']) self.assertIsNone(node['last_error']) deploy.assert_called_once_with(mock.ANY, mock.ANY) @@ -594,8 +594,8 @@ class ManagerTestCase(base.DbTestCase): self.service.do_node_tear_down, self.context, node['uuid']) node.refresh(self.context) - self.assertEqual(node['provision_state'], states.ERROR) - self.assertEqual(node['target_provision_state'], states.NOSTATE) + self.assertEqual(states.ERROR, node['provision_state']) + self.assertEqual(states.NOSTATE, node['target_provision_state']) self.assertIsNotNone(node['last_error']) deploy.assert_called_once_with(mock.ANY, mock.ANY) @@ -610,8 +610,8 @@ class ManagerTestCase(base.DbTestCase): deploy.return_value = states.DELETED self.service.do_node_tear_down(self.context, node['uuid']) node.refresh(self.context) - self.assertEqual(node['provision_state'], states.NOSTATE) - self.assertEqual(node['target_provision_state'], states.NOSTATE) + self.assertEqual(states.NOSTATE, node['provision_state']) + self.assertEqual(states.NOSTATE, node['target_provision_state']) self.assertIsNone(node['last_error']) deploy.assert_called_once_with(mock.ANY, mock.ANY) @@ -627,7 +627,7 @@ class ManagerTestCase(base.DbTestCase): self.service.do_node_tear_down(self.context, node['uuid']) node.refresh(self.context) self.assertEqual(node['provision_state'], states.DELETING) - self.assertEqual(node['target_provision_state'], states.DELETED) + self.assertEqual(states.DELETED, node['target_provision_state']) self.assertIsNone(node['last_error']) deploy.assert_called_once_with(mock.ANY, mock.ANY) diff --git a/ironic/tests/conductor/test_rpcapi.py b/ironic/tests/conductor/test_rpcapi.py index 8c63027cf7..7b393403d0 100644 --- a/ironic/tests/conductor/test_rpcapi.py +++ b/ironic/tests/conductor/test_rpcapi.py @@ -100,10 +100,10 @@ class RPCAPITestCase(base.DbTestCase): retval = getattr(rpcapi, method)(ctxt, **kwargs) - self.assertEqual(retval, expected_retval) + self.assertEqual(expected_retval, retval) expected_args = [ctxt, expected_topic, expected_msg] for arg, expected_arg in zip(self.fake_args, expected_args): - self.assertEqual(arg, expected_arg) + self.assertEqual(expected_arg, arg) def test_update_node(self): self._test_rpcapi('update_node', @@ -128,7 +128,7 @@ class RPCAPITestCase(base.DbTestCase): 'ironic.openstack.common.rpc.call', _fake_rpc_method)) retval = rpcapi.vendor_passthru(ctxt, node_id=self.fake_node['uuid'], driver_method='foo', info={'bar': 'baz'}) - self.assertEqual(retval, expected_retval) + self.assertEqual(expected_retval, retval) def test_do_node_deploy(self): self._test_rpcapi('do_node_deploy', diff --git a/ironic/tests/conductor/test_utils.py b/ironic/tests/conductor/test_utils.py index cfbfe04cdc..201682ac29 100644 --- a/ironic/tests/conductor/test_utils.py +++ b/ironic/tests/conductor/test_utils.py @@ -42,11 +42,11 @@ class UtilsTestCase(base.TestCase): # confirm that stevedore did not scan the actual entrypoints self.assertNotEqual(mgr._extension_manager.namespace, 'ironic.drivers') # confirm mgr has only one extension - self.assertEqual(len(mgr._extension_manager.extensions), 1) + self.assertEqual(1, len(mgr._extension_manager.extensions)) # confirm that we got a reference to the extension in this manager - self.assertEqual(mgr._extension_manager.extensions[0], ext) + self.assertEqual(ext, mgr._extension_manager.extensions[0]) # confirm that it is the "fake" driver we asked for - self.assertEqual("%s" % ext.entry_point, - "fake = ironic.drivers.fake:FakeDriver") + self.assertEqual("fake = ironic.drivers.fake:FakeDriver", + "%s" % ext.entry_point) # Confirm driver is loaded self.assertIn('fake', mgr.names) diff --git a/ironic/tests/db/sqlalchemy/test_migrations.py b/ironic/tests/db/sqlalchemy/test_migrations.py index b3a33aedbd..71ae6e7e9c 100644 --- a/ironic/tests/db/sqlalchemy/test_migrations.py +++ b/ironic/tests/db/sqlalchemy/test_migrations.py @@ -448,7 +448,7 @@ class TestMigrations(BaseMigrationTestCase, WalkVersionsMixin): "and TABLE_NAME!='alembic_version'" % database) count = noninnodb.scalar() - self.assertEqual(count, 0, "%d non InnoDB tables created" % count) + self.assertEqual(0, count, "%d non InnoDB tables created" % count) connection.close() def _test_postgresql_opportunistically(self): diff --git a/ironic/tests/db/test_chassis.py b/ironic/tests/db/test_chassis.py index c0ad8d0faa..b67641323c 100644 --- a/ironic/tests/db/test_chassis.py +++ b/ironic/tests/db/test_chassis.py @@ -54,13 +54,13 @@ class DbChassisTestCase(base.DbTestCase): ch = self._create_test_chassis() chassis = self.dbapi.get_chassis(ch['id']) - self.assertEqual(chassis.uuid, ch['uuid']) + self.assertEqual(ch['uuid'], chassis.uuid) def test_get_chassis_by_uuid(self): ch = self._create_test_chassis() chassis = self.dbapi.get_chassis(ch['uuid']) - self.assertEqual(chassis.id, ch['id']) + self.assertEqual(ch['id'], chassis.id) def test_get_chassis_that_does_not_exist(self): self.assertRaises(exception.ChassisNotFound, @@ -73,7 +73,7 @@ class DbChassisTestCase(base.DbTestCase): ch['uuid'] = new_uuid res = self.dbapi.update_chassis(ch['id'], {'uuid': new_uuid}) - self.assertEqual(res.uuid, new_uuid) + self.assertEqual(new_uuid, res.uuid) def test_update_chassis_that_does_not_exist(self): new_uuid = ironic_utils.generate_uuid() diff --git a/ironic/tests/drivers/test_deploy_utils.py b/ironic/tests/drivers/test_deploy_utils.py index b88a0b48f4..ed1ea75791 100644 --- a/ironic/tests/drivers/test_deploy_utils.py +++ b/ironic/tests/drivers/test_deploy_utils.py @@ -301,7 +301,7 @@ class SwitchPxeConfigTestCase(tests_base.TestCase): '12345678-1234-1234-1234-1234567890abcdef') with open(self.fname, 'r') as f: pxeconf = f.read() - self.assertEqual(pxeconf, _PXECONF_BOOT) + self.assertEqual(_PXECONF_BOOT, pxeconf) class OtherFunctionTestCase(tests_base.TestCase): @@ -319,13 +319,13 @@ class OtherFunctionTestCase(tests_base.TestCase): self.useFixture(fixtures.MonkeyPatch('os.path.getsize', fake_getsize)) size = 0 - self.assertEqual(utils.get_image_mb('x'), 0) + self.assertEqual(0, utils.get_image_mb('x')) size = 1 - self.assertEqual(utils.get_image_mb('x'), 1) + self.assertEqual(1, utils.get_image_mb('x')) size = mb - self.assertEqual(utils.get_image_mb('x'), 1) + self.assertEqual(1, utils.get_image_mb('x')) size = mb + 1 - self.assertEqual(utils.get_image_mb('x'), 2) + self.assertEqual(2, utils.get_image_mb('x')) class WorkOnDiskTestCase(tests_base.TestCase): diff --git a/ironic/tests/drivers/test_ipminative.py b/ironic/tests/drivers/test_ipminative.py index cd8138a204..e5405e41f7 100644 --- a/ironic/tests/drivers/test_ipminative.py +++ b/ironic/tests/drivers/test_ipminative.py @@ -75,7 +75,7 @@ class IPMINativePrivateMethodTestCase(base.TestCase): state = ipminative._power_status(self.info) ipmicmd.get_power.assert_called_once_with() - self.assertEqual(state, states.POWER_ON) + self.assertEqual(states.POWER_ON, state) def test__power_status_off(self): ipmicmd = self.ipmi_mock.return_value @@ -83,7 +83,7 @@ class IPMINativePrivateMethodTestCase(base.TestCase): state = ipminative._power_status(self.info) ipmicmd.get_power.assert_called_once_with() - self.assertEqual(state, states.POWER_OFF) + self.assertEqual(states.POWER_OFF, state) def test__power_status_error(self): ipmicmd = self.ipmi_mock.return_value @@ -91,7 +91,7 @@ class IPMINativePrivateMethodTestCase(base.TestCase): state = ipminative._power_status(self.info) ipmicmd.get_power.assert_called_once_with() - self.assertEqual(state, states.ERROR) + self.assertEqual(states.ERROR, state) def test__power_on(self): ipmicmd = self.ipmi_mock.return_value @@ -100,7 +100,7 @@ class IPMINativePrivateMethodTestCase(base.TestCase): self.config(retry_timeout=400, group='ipmi') state = ipminative._power_on(self.info) ipmicmd.set_power.assert_called_once_with('on', 400) - self.assertEqual(state, states.POWER_ON) + self.assertEqual(states.POWER_ON, state) def test__power_off(self): ipmicmd = self.ipmi_mock.return_value @@ -109,7 +109,7 @@ class IPMINativePrivateMethodTestCase(base.TestCase): self.config(retry_timeout=500, group='ipmi') state = ipminative._power_off(self.info) ipmicmd.set_power.assert_called_once_with('off', 500) - self.assertEqual(state, states.POWER_OFF) + self.assertEqual(states.POWER_OFF, state) def test__reboot(self): ipmicmd = self.ipmi_mock.return_value @@ -118,7 +118,7 @@ class IPMINativePrivateMethodTestCase(base.TestCase): self.config(retry_timeout=600, group='ipmi') state = ipminative._reboot(self.info) ipmicmd.set_power.assert_called_once_with('boot', 600) - self.assertEqual(state, states.POWER_ON) + self.assertEqual(states.POWER_ON, state) class IPMINativeDriverTestCase(db_base.DbTestCase): @@ -152,13 +152,13 @@ class IPMINativeDriverTestCase(db_base.DbTestCase): get_power_mock.side_effect = lambda: return_values.pop() pstate = self.driver.power.get_power_state(None, self.node) - self.assertEqual(pstate, states.POWER_OFF) + self.assertEqual(states.POWER_OFF, pstate) pstate = self.driver.power.get_power_state(None, self.node) - self.assertEqual(pstate, states.POWER_ON) + self.assertEqual(states.POWER_ON, pstate) pstate = self.driver.power.get_power_state(None, self.node) - self.assertEqual(pstate, states.ERROR) + self.assertEqual(states.ERROR, pstate) self.assertEqual(3, get_power_mock.call_count, "pyghmi.ipmi.command.Command.get_power was not" " called 3 times.") diff --git a/ironic/tests/drivers/test_ipmitool.py b/ironic/tests/drivers/test_ipmitool.py index 1e4edf23d0..a0872941d6 100644 --- a/ironic/tests/drivers/test_ipmitool.py +++ b/ironic/tests/drivers/test_ipmitool.py @@ -57,10 +57,10 @@ class IPMIToolPrivateMethodTestCase(base.TestCase): with ipmi._make_password_file(self.info.get('password')) as pw_file: del_chk_pw_file = pw_file self.assertTrue(os.path.isfile(pw_file)) - self.assertEqual(os.stat(pw_file)[stat.ST_MODE] & 0o777, 0o600) + self.assertEqual(0o600, os.stat(pw_file)[stat.ST_MODE] & 0o777) with open(pw_file, "r") as f: password = f.read() - self.assertEqual(password, self.info.get('password')) + self.assertEqual(self.info.get('password'), password) self.assertFalse(os.path.isfile(del_chk_pw_file)) def test__parse_driver_info(self): @@ -208,7 +208,7 @@ class IPMIToolPrivateMethodTestCase(base.TestCase): state = ipmi._power_status(self.info) mock_exec.assert_called_once_with(self.info, "power status") - self.assertEqual(state, states.POWER_ON) + self.assertEqual(states.POWER_ON, state) def test__power_status_off(self): with mock.patch.object(ipmi, '_exec_ipmitool', @@ -218,7 +218,7 @@ class IPMIToolPrivateMethodTestCase(base.TestCase): state = ipmi._power_status(self.info) mock_exec.assert_called_once_with(self.info, "power status") - self.assertEqual(state, states.POWER_OFF) + self.assertEqual(states.POWER_OFF, state) def test__power_status_error(self): with mock.patch.object(ipmi, '_exec_ipmitool', @@ -228,7 +228,7 @@ class IPMIToolPrivateMethodTestCase(base.TestCase): state = ipmi._power_status(self.info) mock_exec.assert_called_once_with(self.info, "power status") - self.assertEqual(state, states.ERROR) + self.assertEqual(states.ERROR, state) def test__power_status_exception(self): with mock.patch.object(ipmi, '_exec_ipmitool', @@ -260,7 +260,7 @@ class IPMIToolPrivateMethodTestCase(base.TestCase): state = ipmi._power_on(self.info) self.assertEqual(mock_exec.call_args_list, expected) - self.assertEqual(state, states.ERROR) + self.assertEqual(states.ERROR, state) class IPMIToolDriverTestCase(db_base.DbTestCase): @@ -289,13 +289,13 @@ class IPMIToolDriverTestCase(db_base.DbTestCase): autospec=True) as mock_exec: pstate = self.driver.power.get_power_state(None, self.node) - self.assertEqual(pstate, states.POWER_OFF) + self.assertEqual(states.POWER_OFF, pstate) pstate = self.driver.power.get_power_state(None, self.node) - self.assertEqual(pstate, states.POWER_ON) + self.assertEqual(states.POWER_ON, pstate) pstate = self.driver.power.get_power_state(None, self.node) - self.assertEqual(pstate, states.ERROR) + self.assertEqual(states.ERROR, pstate) self.assertEqual(mock_exec.call_args_list, expected) diff --git a/ironic/tests/drivers/test_pxe.py b/ironic/tests/drivers/test_pxe.py index 3aaa2009f0..ae756df6b6 100644 --- a/ironic/tests/drivers/test_pxe.py +++ b/ironic/tests/drivers/test_pxe.py @@ -175,8 +175,8 @@ class PXEValidateParametersTestCase(base.TestCase): def test__get_pxe_mac_path(self): mac = '00:11:22:33:44:55:66' - self.assertEqual(pxe._get_pxe_mac_path(mac), - '/tftpboot/pxelinux.cfg/01-00-11-22-33-44-55-66') + self.assertEqual('/tftpboot/pxelinux.cfg/01-00-11-22-33-44-55-66', + pxe._get_pxe_mac_path(mac)) def test__link_master_image(self): temp_dir = tempfile.mkdtemp() @@ -185,7 +185,7 @@ class PXEValidateParametersTestCase(base.TestCase): open(orig_path, 'w').close() pxe._link_master_image(orig_path, dest_path) self.assertIsNotNone(os.path.exists(dest_path)) - self.assertEqual(os.stat(dest_path).st_nlink, 2) + self.assertEqual(2, os.stat(dest_path).st_nlink) def test__unlink_master_image(self): temp_dir = tempfile.mkdtemp() @@ -204,7 +204,7 @@ class PXEValidateParametersTestCase(base.TestCase): self.assertTrue(os.path.exists(master_path)) self.assertTrue(os.path.exists(instance_path)) self.assertFalse(os.path.exists(tmp_path)) - self.assertEqual(os.stat(master_path).st_nlink, 2) + self.assertEqual(2, os.stat(master_path).st_nlink) def test__download_in_progress(self): temp_dir = tempfile.mkdtemp() @@ -248,8 +248,8 @@ class PXEValidateParametersTestCase(base.TestCase): self.assertFalse(os.path.exists(lock_file)) self.assertTrue(os.path.exists(os.path.join(instance_path, 'node_uuid'))) - self.assertEqual(os.stat(os.path.join(master_path, 'node_uuid')). - st_nlink, 2) + self.assertEqual(2, os.stat(os.path.join(master_path, 'node_uuid')). + st_nlink) class PXEPrivateMethodsTestCase(db_base.DbTestCase): @@ -303,7 +303,7 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): image_info = pxe._get_tftp_image_info(self.node, self.context) show_mock.assert_called_once_with('glance://image_uuid', method='get') - self.assertEqual(image_info, expected_info) + self.assertEqual(expected_info, image_info) def test__build_pxe_config(self): self.config(pxe_append_params='test_param', group='pxe') @@ -339,12 +339,12 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): self.context) random_alnum_mock.assert_called_once_with(32) - self.assertEqual(pxe_config, pxe_config_template) + self.assertEqual(pxe_config_template, pxe_config) # test that deploy_key saved db_node = self.dbapi.get_node(self.node['uuid']) db_key = db_node['driver_info'].get('pxe_deploy_key') - self.assertEqual(db_key, fake_key) + self.assertEqual(fake_key, db_key) def test__get_nodes_mac_addresses(self): self._create_test_port(node_id=self.node.id, @@ -470,8 +470,8 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): def test_get_token_file_path(self): node_uuid = self.node['uuid'] - self.assertEqual(pxe._get_token_file_path(node_uuid), - '/tftpboot/token-' + node_uuid) + self.assertEqual('/tftpboot/token-' + node_uuid, + pxe._get_token_file_path(node_uuid)) def test__cache_tftp_images_master_path(self): temp_dir = tempfile.mkdtemp() @@ -532,9 +532,9 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): 'glance://image_uuid', os.path.join(temp_dir, self.node.uuid, 'disk'), None) - self.assertEqual(uuid, 'glance://image_uuid') - self.assertEqual(image_path, - os.path.join(temp_dir, self.node.uuid, 'disk')) + self.assertEqual('glance://image_uuid', uuid) + self.assertEqual(os.path.join(temp_dir, self.node.uuid, 'disk'), + image_path) def test__cache_instance_images_master_path(self): temp_dir = tempfile.mkdtemp() @@ -568,11 +568,11 @@ class PXEPrivateMethodsTestCase(db_base.DbTestCase): None) parse_image_ref_mock.assert_called_once_with( 'glance://image_uuid') - self.assertEqual(uuid, 'glance://image_uuid') - self.assertEqual(image_path, - os.path.join(temp_dir, + self.assertEqual('glance://image_uuid', uuid) + self.assertEqual(os.path.join(temp_dir, self.node.uuid, - 'disk')) + 'disk'), + image_path) def test__get_image_download_in_progress(self): def _create_instance_path(*args): @@ -664,7 +664,7 @@ class PXEDriverTestCase(db_base.DbTestCase): node_id='123'))) with task_manager.acquire(self.context, [self.node['uuid']]) as task: node_macs = pxe._get_node_mac_addresses(task, self.node) - self.assertEqual(sorted(node_macs), sorted([p.address for p in ports])) + self.assertEqual(sorted([p.address for p in ports]), sorted(node_macs)) def test_vendor_passthru_validate_good(self): with task_manager.acquire(self.context, [self.node['uuid']], @@ -720,7 +720,7 @@ class PXEDriverTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, self.node['uuid'], shared=False) as task: state = task.driver.deploy.deploy(task, self.node) - self.assertEqual(state, states.DEPLOYWAIT) + self.assertEqual(states.DEPLOYWAIT, state) update_neutron_mock.assert_called_once_with(task, self.node) node_power_mock.assert_called_once_with(task, self.node, @@ -737,7 +737,7 @@ class PXEDriverTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, self.node['uuid']) as task: state = task.driver.deploy.tear_down(task, self.node) - self.assertEqual(state, states.DELETED) + self.assertEqual(states.DELETED, state) node_power_mock.assert_called_once_with(task, self.node, states.POWER_OFF) diff --git a/ironic/tests/drivers/test_ssh.py b/ironic/tests/drivers/test_ssh.py index 872c465d3d..15dfab0028 100644 --- a/ironic/tests/drivers/test_ssh.py +++ b/ironic/tests/drivers/test_ssh.py @@ -115,12 +115,12 @@ class SSHValidateParametersTestCase(base.TestCase): def test__normalize_mac_string(self): mac_raw = "0A:1B-2C-3D:4F" mac_clean = ssh._normalize_mac(mac_raw) - self.assertEqual(mac_clean, "0a1b2c3d4f") + self.assertEqual("0a1b2c3d4f", mac_clean) def test__normalize_mac_unicode(self): mac_raw = u"0A:1B-2C-3D:4F" mac_clean = ssh._normalize_mac(mac_raw) - self.assertEqual(mac_clean, "0a1b2c3d4f") + self.assertEqual("0a1b2c3d4f", mac_clean) def test__parse_driver_info_with_custom_libvirt_uri(self): CONF.set_override('libvirt_uri', 'qemu:///foo', 'ssh') @@ -202,7 +202,7 @@ class SSHPrivateMethodsTestCase(base.TestCase): ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_running']) - self.assertEqual(pstate, states.POWER_ON) + self.assertEqual(states.POWER_ON, pstate) self.exec_ssh_mock.assert_called_once_with( self.sshclient, ssh_cmd) get_hosts_name_mock.assert_called_once_with(self.sshclient, @@ -220,7 +220,7 @@ class SSHPrivateMethodsTestCase(base.TestCase): ssh_cmd = "%s %s" % (info['cmd_set']['base_cmd'], info['cmd_set']['list_running']) - self.assertEqual(pstate, states.POWER_OFF) + self.assertEqual(states.POWER_OFF, pstate) self.exec_ssh_mock.assert_called_once_with(self.sshclient, ssh_cmd) get_hosts_name_mock.assert_called_once_with(self.sshclient, @@ -277,8 +277,8 @@ class SSHPrivateMethodsTestCase(base.TestCase): found_name = ssh._get_hosts_name_for_node(self.sshclient, info) - self.assertEqual(found_name, 'NodeName') - self.assertEqual(self.exec_ssh_mock.call_args_list, expected) + self.assertEqual('NodeName', found_name) + self.assertEqual(expected, self.exec_ssh_mock.call_args_list) def test__get_hosts_name_for_node_no_match(self): info = ssh._parse_driver_info(self.node) @@ -299,7 +299,7 @@ class SSHPrivateMethodsTestCase(base.TestCase): found_name = ssh._get_hosts_name_for_node(self.sshclient, info) self.assertIsNone(found_name) - self.assertEqual(self.exec_ssh_mock.call_args_list, expected) + self.assertEqual(expected, self.exec_ssh_mock.call_args_list) def test__get_hosts_name_for_node_exception(self): info = ssh._parse_driver_info(self.node) @@ -341,9 +341,9 @@ class SSHPrivateMethodsTestCase(base.TestCase): cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_on(self.sshclient, info) - self.assertEqual(current_state, states.POWER_ON) - self.assertEqual(get_power_status_mock.call_args_list, - expected) + self.assertEqual(states.POWER_ON, current_state) + self.assertEqual(expected, + get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) self.exec_ssh_mock.assert_called_once_with(self.sshclient, @@ -367,9 +367,9 @@ class SSHPrivateMethodsTestCase(base.TestCase): cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_on(self.sshclient, info) - self.assertEqual(current_state, states.ERROR) - self.assertEqual(get_power_status_mock.call_args_list, - expected) + self.assertEqual(states.ERROR, current_state) + self.assertEqual(expected, + get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) self.exec_ssh_mock.assert_called_once_with(self.sshclient, @@ -421,9 +421,9 @@ class SSHPrivateMethodsTestCase(base.TestCase): cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_off(self.sshclient, info) - self.assertEqual(current_state, states.POWER_OFF) - self.assertEqual(get_power_status_mock.call_args_list, - expected) + self.assertEqual(states.POWER_OFF, current_state) + self.assertEqual(expected, + get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) self.exec_ssh_mock.assert_called_once_with(self.sshclient, @@ -447,9 +447,9 @@ class SSHPrivateMethodsTestCase(base.TestCase): cmd_to_exec = cmd_to_exec.replace('{_NodeName_}', 'NodeName') current_state = ssh._power_off(self.sshclient, info) - self.assertEqual(current_state, states.ERROR) - self.assertEqual(get_power_status_mock.call_args_list, - expected) + self.assertEqual(states.ERROR, current_state) + self.assertEqual(expected, + get_power_status_mock.call_args_list) get_hosts_name_mock.assert_called_once_with(self.sshclient, info) self.exec_ssh_mock.assert_called_once_with(self.sshclient, @@ -513,7 +513,7 @@ class SSHPrivateMethodsTestCase(base.TestCase): stdout, stderr = processutils.ssh_execute(self.sshclient, "command") - self.assertEqual(stdout, 'hello') + self.assertEqual('hello', stdout) exec_command_mock.assert_called_once_with("command") def test_exec_ssh_command_fail(self): @@ -612,7 +612,7 @@ class SSHDriverTestCase(db_base.DbTestCase): with task_manager.acquire(self.context, [self.node['uuid']]) as task: node_macs = ssh._get_nodes_mac_addresses(task, self.node) - self.assertEqual(sorted(node_macs), sorted([p.address for p in ports])) + self.assertEqual(sorted([p.address for p in ports]), sorted(node_macs)) def test__validate_info_ssh_connect_failed(self): info = ssh._parse_driver_info(self.node) diff --git a/ironic/tests/objects/test_chassis.py b/ironic/tests/objects/test_chassis.py index 16a79a214e..b80a6ac4fb 100644 --- a/ironic/tests/objects/test_chassis.py +++ b/ironic/tests/objects/test_chassis.py @@ -66,10 +66,10 @@ class TestChassisObject(base.DbTestCase): with mock.patch.object(self.dbapi, 'get_chassis', side_effect=returns, autospec=True) as mock_get_chassis: c = objects.Chassis.get_by_uuid(self.context, uuid) - self.assertEqual(c.uuid, uuid) + self.assertEqual(uuid, c.uuid) c.refresh() - self.assertEqual(c.uuid, new_uuid) - self.assertEqual(mock_get_chassis.call_args_list, expected) + self.assertEqual(new_uuid, c.uuid) + self.assertEqual(expected, mock_get_chassis.call_args_list) def test_objectify(self): def _get_db_chassis(): diff --git a/ironic/tests/objects/test_conductor.py b/ironic/tests/objects/test_conductor.py index 8b0139668f..4851249adc 100644 --- a/ironic/tests/objects/test_conductor.py +++ b/ironic/tests/objects/test_conductor.py @@ -78,10 +78,10 @@ class TestConductorObject(base.DbTestCase): autospec=True) as mock_get_cdr: c = objects.Conductor.get_by_hostname(self.context, host) # ensure timestamps have tzinfo - self.assertEqual(c.updated_at, obj_utils.datetime_or_none(t0)) + self.assertEqual(obj_utils.datetime_or_none(t0), c.updated_at) c.refresh() - self.assertEqual(c.updated_at, obj_utils.datetime_or_none(t1)) - self.assertEqual(mock_get_cdr.call_args_list, expected) + self.assertEqual(obj_utils.datetime_or_none(t1), c.updated_at) + self.assertEqual(expected, mock_get_cdr.call_args_list) def test_objectify(self): def _get_db_conductor(): diff --git a/ironic/tests/objects/test_node.py b/ironic/tests/objects/test_node.py index 5f8bf00210..ef2af956ba 100644 --- a/ironic/tests/objects/test_node.py +++ b/ironic/tests/objects/test_node.py @@ -66,10 +66,10 @@ class TestNodeObject(base.DbTestCase): with mock.patch.object(self.dbapi, 'get_node', side_effect=returns, autospec=True) as mock_get_node: n = objects.Node.get_by_uuid(self.context, uuid) - self.assertEqual(n.properties, {"fake": "first"}) + self.assertEqual({"fake": "first"}, n.properties) n.refresh() - self.assertEqual(n.properties, {"fake": "second"}) - self.assertEqual(mock_get_node.call_args_list, expected) + self.assertEqual({"fake": "second"}, n.properties) + self.assertEqual(expected, mock_get_node.call_args_list) def test_objectify(self): def _get_db_node(): diff --git a/ironic/tests/objects/test_objects.py b/ironic/tests/objects/test_objects.py index 7f60204ad5..eafdadc8f6 100644 --- a/ironic/tests/objects/test_objects.py +++ b/ironic/tests/objects/test_objects.py @@ -166,7 +166,7 @@ class TestUtils(test_base.TestCase): obj = Obj() obj.bar = timeutils.parse_isotime('1955-11-05T00:00:00Z') - self.assertEqual(obj.foo(), '1955-11-05T00:00:00Z') + self.assertEqual('1955-11-05T00:00:00Z', obj.foo()) obj.bar = None self.assertIsNone(obj.foo()) obj.bar = 'foo' @@ -218,7 +218,7 @@ class _LocalTest(_BaseTestCase): base.IronicObject.indirection_api = None def assertRemotes(self): - self.assertEqual(self.remote_object_calls, []) + self.assertEqual([], self.remote_object_calls) @contextlib.contextmanager @@ -245,7 +245,7 @@ class _TestObject(object): 'ironic_object.version': '1.5', 'ironic_object.data': {'foo': 1}} obj = MyObj.obj_from_primitive(primitive) - self.assertEqual(obj.foo, 1) + self.assertEqual(1, obj.foo) def test_hydration_bad_ns(self): primitive = {'ironic_object.name': 'MyObj', @@ -263,7 +263,7 @@ class _TestObject(object): obj = MyObj() obj.foo = 1 obj.obj_reset_changes() - self.assertEqual(obj.obj_to_primitive(), expected) + self.assertEqual(expected, obj.obj_to_primitive()) def test_get_updates(self): obj = MyObj() @@ -278,7 +278,7 @@ class _TestObject(object): def test_object_property(self): obj = MyObj() obj.foo = 1 - self.assertEqual(obj.foo, 1) + self.assertEqual(1, obj.foo) def test_object_property_type_error(self): obj = MyObj() @@ -291,15 +291,15 @@ class _TestObject(object): obj = MyObj() obj.foo = 123 obj.bar = 'bar' - self.assertEqual(obj['foo'], 123) - self.assertEqual(sorted(obj.items(), key=lambda x: x[0]), - [('bar', 'bar'), ('foo', 123)]) - self.assertEqual(sorted(list(obj.iteritems()), key=lambda x: x[0]), - [('bar', 'bar'), ('foo', 123)]) + self.assertEqual(123, obj['foo']) + self.assertEqual([('bar', 'bar'), ('foo', 123)], + sorted(obj.items(), key=lambda x: x[0])) + self.assertEqual([('bar', 'bar'), ('foo', 123)], + sorted(list(obj.iteritems()), key=lambda x: x[0])) def test_load(self): obj = MyObj() - self.assertEqual(obj.bar, 'loaded!') + self.assertEqual('loaded!', obj.bar) def test_load_in_base(self): class Foo(base.IronicObject): @@ -318,25 +318,25 @@ class _TestObject(object): obj = MyObj() obj.foo = 1 obj.obj_reset_changes() - self.assertEqual(obj.bar, 'loaded!') + self.assertEqual('loaded!', obj.bar) expected = {'ironic_object.name': 'MyObj', 'ironic_object.namespace': 'ironic', 'ironic_object.version': '1.5', 'ironic_object.changes': ['bar'], 'ironic_object.data': {'foo': 1, 'bar': 'loaded!'}} - self.assertEqual(obj.obj_to_primitive(), expected) + self.assertEqual(expected, obj.obj_to_primitive()) def test_changes_in_primitive(self): obj = MyObj() obj.foo = 123 - self.assertEqual(obj.obj_what_changed(), set(['foo'])) + self.assertEqual(set(['foo']), obj.obj_what_changed()) primitive = obj.obj_to_primitive() self.assertTrue('ironic_object.changes' in primitive) obj2 = MyObj.obj_from_primitive(primitive) - self.assertEqual(obj2.obj_what_changed(), set(['foo'])) + self.assertEqual(set(['foo']), obj2.obj_what_changed()) obj2.obj_reset_changes() - self.assertEqual(obj2.obj_what_changed(), set()) + self.assertEqual(set(), obj2.obj_what_changed()) def test_unknown_objtype(self): self.assertRaises(exception.UnsupportedObjectError, @@ -347,7 +347,7 @@ class _TestObject(object): ctxt2 = context.RequestContext('bar', tenant='alternate') obj = MyObj.get(ctxt1) obj.update_test(ctxt2) - self.assertEqual(obj.bar, 'alternate-context') + self.assertEqual('alternate-context', obj.bar) self.assertRemotes() def test_orphaned_object(self): @@ -362,58 +362,58 @@ class _TestObject(object): ctxt = context.get_admin_context() obj = MyObj.get(ctxt) obj.foo = 123 - self.assertEqual(obj.obj_what_changed(), set(['foo'])) + self.assertEqual(set(['foo']), obj.obj_what_changed()) obj.update_test(ctxt) - self.assertEqual(obj.obj_what_changed(), set(['foo', 'bar'])) - self.assertEqual(obj.foo, 123) + self.assertEqual(set(['foo', 'bar']), obj.obj_what_changed()) + self.assertEqual(123, obj.foo) self.assertRemotes() def test_changed_2(self): ctxt = context.get_admin_context() obj = MyObj.get(ctxt) obj.foo = 123 - self.assertEqual(obj.obj_what_changed(), set(['foo'])) + self.assertEqual(set(['foo']), obj.obj_what_changed()) obj.save(ctxt) - self.assertEqual(obj.obj_what_changed(), set([])) - self.assertEqual(obj.foo, 123) + self.assertEqual(set([]), obj.obj_what_changed()) + self.assertEqual(123, obj.foo) self.assertRemotes() def test_changed_3(self): ctxt = context.get_admin_context() obj = MyObj.get(ctxt) obj.foo = 123 - self.assertEqual(obj.obj_what_changed(), set(['foo'])) + self.assertEqual(set(['foo']), obj.obj_what_changed()) obj.refresh(ctxt) - self.assertEqual(obj.obj_what_changed(), set([])) - self.assertEqual(obj.foo, 321) - self.assertEqual(obj.bar, 'refreshed') + self.assertEqual(set([]), obj.obj_what_changed()) + self.assertEqual(321, obj.foo) + self.assertEqual('refreshed', obj.bar) self.assertRemotes() def test_changed_4(self): ctxt = context.get_admin_context() obj = MyObj.get(ctxt) obj.bar = 'something' - self.assertEqual(obj.obj_what_changed(), set(['bar'])) + self.assertEqual(set(['bar']), obj.obj_what_changed()) obj.modify_save_modify(ctxt) - self.assertEqual(obj.obj_what_changed(), set(['foo'])) - self.assertEqual(obj.foo, 42) - self.assertEqual(obj.bar, 'meow') + self.assertEqual(set(['foo']), obj.obj_what_changed()) + self.assertEqual(42, obj.foo) + self.assertEqual('meow', obj.bar) self.assertRemotes() def test_static_result(self): ctxt = context.get_admin_context() obj = MyObj.get(ctxt) - self.assertEqual(obj.bar, 'bar') + self.assertEqual('bar', obj.bar) result = obj.marco() - self.assertEqual(result, 'polo') + self.assertEqual('polo', result) self.assertRemotes() def test_updates(self): ctxt = context.get_admin_context() obj = MyObj.get(ctxt) - self.assertEqual(obj.foo, 1) + self.assertEqual(1, obj.foo) obj.update_test() - self.assertEqual(obj.bar, 'updated') + self.assertEqual('updated', obj.bar) self.assertRemotes() def test_base_attributes(self): @@ -431,7 +431,7 @@ class _TestObject(object): 'updated_at': timeutils.isotime(dt), } } - self.assertEqual(obj.obj_to_primitive(), expected) + self.assertEqual(expected, obj.obj_to_primitive()) def test_contains(self): obj = MyObj() @@ -454,13 +454,13 @@ class TestObjectListBase(test_base.TestCase): objlist._context = 'foo' objlist.objects = [1, 2, 3] self.assertEqual(list(objlist), objlist.objects) - self.assertEqual(len(objlist), 3) + self.assertEqual(3, len(objlist)) self.assertIn(2, objlist) - self.assertEqual(list(objlist[:1]), [1]) - self.assertEqual(objlist[:1]._context, 'foo') - self.assertEqual(objlist[2], 3) - self.assertEqual(objlist.count(1), 1) - self.assertEqual(objlist.index(2), 1) + self.assertEqual([1], list(objlist[:1])) + self.assertEqual('foo', objlist[:1]._context) + self.assertEqual(3, objlist[2]) + self.assertEqual(1, objlist.count(1)) + self.assertEqual(1, objlist.index(2)) def test_serialization(self): class Foo(base.ObjectListBase, base.IronicObject): diff --git a/ironic/tests/objects/test_port.py b/ironic/tests/objects/test_port.py index f26dcf61b3..d599e5346e 100644 --- a/ironic/tests/objects/test_port.py +++ b/ironic/tests/objects/test_port.py @@ -62,11 +62,11 @@ class TestPortObject(base.DbTestCase): with mock.patch.object(self.dbapi, 'get_port', side_effect=returns, autospec=True) as mock_get_port: p = objects.Port.get_by_uuid(self.context, uuid) - self.assertEqual(p.address, "52:54:00:cf:2d:31") + self.assertEqual("52:54:00:cf:2d:31", p.address) p.refresh() - self.assertEqual(p.address, "c3:54:00:cf:2d:40") + self.assertEqual("c3:54:00:cf:2d:40", p.address) - self.assertEqual(mock_get_port.call_args_list, expected) + self.assertEqual(expected, mock_get_port.call_args_list) def test_objectify(self): def _get_db_port(): diff --git a/ironic/tests/test_glance_service.py b/ironic/tests/test_glance_service.py index 5ef670de5e..0d77194146 100644 --- a/ironic/tests/test_glance_service.py +++ b/ironic/tests/test_glance_service.py @@ -73,9 +73,9 @@ class TestGlanceSerializer(testtools.TestCase): '{"virtual_device": "ephemeral0", ' '"device_name": "/dev/fake0"}]'}} converted = service_utils._convert(metadata, 'to') - self.assertEqual(converted, converted_expected) - self.assertEqual(service_utils._convert(converted, 'from'), - metadata) + self.assertEqual(converted_expected, converted) + self.assertEqual(metadata, + service_utils._convert(converted, 'from')) class TestGlanceImageService(base.TestCase): @@ -215,8 +215,8 @@ class TestGlanceImageService(base.TestCase): self.context.project_id = proj self.assertEqual(1, len(image_metas)) - self.assertEqual(image_metas[0]['name'], 'test image') - self.assertEqual(image_metas[0]['is_public'], False) + self.assertEqual('test image', image_metas[0]['name']) + self.assertEqual(False, image_metas[0]['is_public']) def test_detail_marker(self): fixtures = [] @@ -227,7 +227,7 @@ class TestGlanceImageService(base.TestCase): ids.append(self.service.create(fixture)['id']) image_metas = self.service.detail(marker=ids[1]) - self.assertEqual(len(image_metas), 8) + self.assertEqual(8, len(image_metas)) i = 2 for meta in image_metas: expected = { @@ -261,7 +261,7 @@ class TestGlanceImageService(base.TestCase): ids.append(self.service.create(fixture)['id']) image_metas = self.service.detail(limit=5) - self.assertEqual(len(image_metas), 5) + self.assertEqual(5, len(image_metas)) def test_detail_default_limit(self): fixtures = [] @@ -284,7 +284,7 @@ class TestGlanceImageService(base.TestCase): ids.append(self.service.create(fixture)['id']) image_metas = self.service.detail(marker=ids[3], limit=5) - self.assertEqual(len(image_metas), 5) + self.assertEqual(5, len(image_metas)) i = 4 for meta in image_metas: expected = { @@ -381,7 +381,7 @@ class TestGlanceImageService(base.TestCase): 'properties': {}, 'owner': None, } - self.assertEqual(image_meta, expected) + self.assertEqual(expected, image_meta) def test_show_raises_when_no_authtoken_in_the_context(self): fixture = self._make_fixture(name='image1', @@ -417,21 +417,21 @@ class TestGlanceImageService(base.TestCase): 'owner': None, }, ] - self.assertEqual(image_metas, expected) + self.assertEqual(expected, image_metas) def test_show_makes_datetimes(self): fixture = self._make_datetime_fixture() image_id = self.service.create(fixture)['id'] image_meta = self.service.show(image_id) - self.assertEqual(image_meta['created_at'], self.NOW_DATETIME) - self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME) + self.assertEqual(self.NOW_DATETIME, image_meta['created_at']) + self.assertEqual(self.NOW_DATETIME, image_meta['updated_at']) def test_detail_makes_datetimes(self): fixture = self._make_datetime_fixture() self.service.create(fixture) image_meta = self.service.detail()[0] - self.assertEqual(image_meta['created_at'], self.NOW_DATETIME) - self.assertEqual(image_meta['updated_at'], self.NOW_DATETIME) + self.assertEqual(self.NOW_DATETIME, image_meta['created_at']) + self.assertEqual(self.NOW_DATETIME, image_meta['updated_at']) def test_download_with_retries(self): tries = [0] @@ -620,7 +620,7 @@ class TestGlanceUrl(base.TestCase): generated_url = service_utils.generate_glance_url() http_url = "http://%s:%d" % (CONF.glance.glance_host, CONF.glance.glance_port) - self.assertEqual(generated_url, http_url) + self.assertEqual(http_url, generated_url) def test_generate_glance_https_url(self): self.config(glance_protocol="https", group='glance') @@ -628,7 +628,7 @@ class TestGlanceUrl(base.TestCase): generated_url = service_utils.generate_glance_url() https_url = "https://%s:%d" % (CONF.glance.glance_host, CONF.glance.glance_port) - self.assertEqual(generated_url, https_url) + self.assertEqual(https_url, generated_url) class TestServiceUtils(base.TestCase): @@ -636,12 +636,12 @@ class TestServiceUtils(base.TestCase): def test_parse_image_ref_no_ssl(self): image_href = 'http://127.0.0.1:9292/image_path/image_uuid' parsed_href = service_utils.parse_image_ref(image_href) - self.assertEqual(parsed_href, ('image_uuid', '127.0.0.1', 9292, False)) + self.assertEqual(('image_uuid', '127.0.0.1', 9292, False), parsed_href) def test_parse_image_ref_ssl(self): image_href = 'https://127.0.0.1:9292/image_path/image_uuid' parsed_href = service_utils.parse_image_ref(image_href) - self.assertEqual(parsed_href, ('image_uuid', '127.0.0.1', 9292, True)) + self.assertEqual(('image_uuid', '127.0.0.1', 9292, True), parsed_href) def test_generate_image_url(self): image_href = 'image_uuid' @@ -649,5 +649,5 @@ class TestServiceUtils(base.TestCase): self.config(glance_port=1234, group='glance') self.config(glance_protocol='https', group='glance') generated_url = service_utils.generate_image_url(image_href) - self.assertEqual(generated_url, - 'https://123.123.123.123:1234/images/image_uuid') + self.assertEqual('https://123.123.123.123:1234/images/image_uuid', + generated_url) diff --git a/ironic/tests/test_images.py b/ironic/tests/test_images.py index 6e534d6539..42e8c1e614 100644 --- a/ironic/tests/test_images.py +++ b/ironic/tests/test_images.py @@ -93,13 +93,13 @@ class IronicImagesTestCase(base.TestCase): ('rm', 't.qcow2.part'), ('mv', 't.qcow2.converted', 't.qcow2')] images.fetch_to_raw(context, image_id, target) - self.assertEqual(self.executes, expected_commands) + self.assertEqual(expected_commands, self.executes) target = 't.raw' self.executes = [] expected_commands = [('mv', 't.raw.part', 't.raw')] images.fetch_to_raw(context, image_id, target) - self.assertEqual(self.executes, expected_commands) + self.assertEqual(expected_commands, self.executes) target = 'backing.qcow2' self.executes = [] @@ -107,6 +107,6 @@ class IronicImagesTestCase(base.TestCase): self.assertRaises(exception.ImageUnacceptable, images.fetch_to_raw, context, image_id, target) - self.assertEqual(self.executes, expected_commands) + self.assertEqual(expected_commands, self.executes) del self.executes diff --git a/ironic/tests/test_keystone.py b/ironic/tests/test_keystone.py index fa9eefbbe9..b3368deb26 100644 --- a/ironic/tests/test_keystone.py +++ b/ironic/tests/test_keystone.py @@ -51,7 +51,7 @@ class KeystoneTestCase(base.TestCase): _fake_client)) res = keystone.get_service_url() - self.assertEqual(res, fake_url) + self.assertEqual(fake_url, res) def test_url_not_found(self): diff --git a/ironic/tests/test_utils.py b/ironic/tests/test_utils.py index 10cd26df3d..ae030b57bc 100644 --- a/ironic/tests/test_utils.py +++ b/ironic/tests/test_utils.py @@ -38,9 +38,9 @@ class BareMetalUtilsTestCase(base.TestCase): def test_random_alnum(self): s = utils.random_alnum(10) - self.assertEqual(len(s), 10) + self.assertEqual(10, len(s)) s = utils.random_alnum(100) - self.assertEqual(len(s), 100) + self.assertEqual(100, len(s)) def test_unlink(self): with mock.patch.object(os, "unlink") as unlink_mock: @@ -108,7 +108,7 @@ exit 1 'always get passed ' 'correctly') runs = int(runs.strip()) - self.assertEqual(runs, 10, + self.assertEqual(10, runs, 'Ran %d times instead of 10.' % (runs,)) finally: os.unlink(tmpfilename) @@ -212,14 +212,14 @@ class GenericUtilsTestCase(base.TestCase): self.reload_called = False def test_reload(reloaded_data): - self.assertEqual(reloaded_data, fake_contents) + self.assertEqual(fake_contents, reloaded_data) self.reload_called = True data = utils.read_cached_file("/this/is/a/fake", cache_data, reload_func=test_reload) - self.assertEqual(data, fake_contents) + self.assertEqual(fake_contents, data) self.assertTrue(self.reload_called) getmtime_mock.assert_called_once_with(mock.ANY) open_mock.assert_called_once_with(mock.ANY) @@ -333,8 +333,8 @@ class GenericUtilsTestCase(base.TestCase): rstripped_value = '/test' not_rstripped = '/' - self.assertEqual(utils.safe_rstrip(value, '/'), rstripped_value) - self.assertEqual(utils.safe_rstrip(not_rstripped, '/'), not_rstripped) + self.assertEqual(rstripped_value, utils.safe_rstrip(value, '/')) + self.assertEqual(not_rstripped, utils.safe_rstrip(not_rstripped, '/')) def test_safe_rstrip_not_raises_exceptions(self): # Supplying an integer should normally raise an exception because it @@ -343,7 +343,7 @@ class GenericUtilsTestCase(base.TestCase): # In the case of raising an exception safe_rstrip() should return the # original value. - self.assertEqual(utils.safe_rstrip(value), value) + self.assertEqual(value, utils.safe_rstrip(value)) class MkfsTestCase(base.TestCase): @@ -360,7 +360,7 @@ class MkfsTestCase(base.TestCase): run_as_root=True), mock.call('mkswap', '/my/swap/block/dev', run_as_root=True)] - self.assertEqual(execute_mock.call_args_list, expected) + self.assertEqual(expected, execute_mock.call_args_list) def test_mkfs_with_label(self): with mock.patch.object(utils, 'execute') as execute_mock: @@ -374,7 +374,7 @@ class MkfsTestCase(base.TestCase): '/my/msdos/block/dev', run_as_root=True), mock.call('mkswap', '-L', 'swap-vol', '/my/swap/block/dev', run_as_root=True)] - self.assertEqual(execute_mock.call_args_list, expected) + self.assertEqual(expected, execute_mock.call_args_list) class IntLikeTestCase(base.TestCase): @@ -403,9 +403,9 @@ class UUIDTestCase(base.TestCase): def test_generate_uuid(self): uuid_string = utils.generate_uuid() self.assertIsInstance(uuid_string, str) - self.assertEqual(len(uuid_string), 36) + self.assertEqual(36, len(uuid_string)) # make sure there are 4 dashes - self.assertEqual(len(uuid_string.replace('-', '')), 32) + self.assertEqual(32, len(uuid_string.replace('-', ''))) def test_is_uuid_like(self): self.assertTrue(utils.is_uuid_like(str(uuid.uuid4())))