openstack/ironic
Code Issues Proposed changes

Merge "Fix params order in assertEqual"

Browse Source
This commit is contained in:
Jenkins 2014-03-04 23:32:16 +00:00 committed by Gerrit Code Review
commit e52d6af555
24 changed files with 210 additions and 210 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
ironic/tests/api/test_acl.py
View File

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

4
ironic/tests/api/test_base.py
View File

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

4
ironic/tests/api/test_chassis.py
View File

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

4
ironic/tests/api/test_root.py
View File

@ -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, ['', []])

20
ironic/tests/conductor/test_conductor_utils.py
View File

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

46
ironic/tests/conductor/test_manager.py
View File

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

6
ironic/tests/conductor/test_rpcapi.py
View File

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

8
ironic/tests/conductor/test_utils.py
View File

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

2
ironic/tests/db/sqlalchemy/test_migrations.py
View File

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

6
ironic/tests/db/test_chassis.py
View File

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

10
ironic/tests/drivers/test_deploy_utils.py
View File

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

18
ironic/tests/drivers/test_ipminative.py
View File

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

18
ironic/tests/drivers/test_ipmitool.py
View File

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

42
ironic/tests/drivers/test_pxe.py
View File

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

42
ironic/tests/drivers/test_ssh.py
View File

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

6
ironic/tests/objects/test_chassis.py
View File

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

6
ironic/tests/objects/test_conductor.py
View File

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

6
ironic/tests/objects/test_node.py
View File

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

84
ironic/tests/objects/test_objects.py
View File

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

6
ironic/tests/objects/test_port.py
View File

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

40
ironic/tests/test_glance_service.py
View File

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

6
ironic/tests/test_images.py
View File

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

2
ironic/tests/test_keystone.py
View File

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

24
ironic/tests/test_utils.py
View File

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