openstack
/
magnum
Code Issues Proposed changes

Fix order of arguments in assertEqual 

Some tests used incorrect order assertEqual(observed, expected).
The correct order expected by testtools is
assertEqual(expected, observed).
This patch fix the issue in the module magnum/tests/unit/conductor/.

Change-Id: Ib8ead5a00b8095892341e08b1662b053ac1ec36b
Partial-Bug: #1259292
This commit is contained in:
lei-zhang-99cloud 2015-10-10 17:12:38 +08:00
parent bc0c1a4644
commit 7fda571402
9 changed files with 79 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

21
magnum/tests/unit/conductor/handlers/common/test_cert_manager.py
View File

@ -45,10 +45,9 @@ class CertManagerTestCase(base.BaseTestCase):
mock_generate_ca_cert.return_value = expected_ca_cert
self.CertManager.store_cert.return_value = expected_ca_cert_ref
self.assertEqual(
cert_manager._generate_ca_cert(expected_ca_name),
(expected_ca_cert_ref, expected_ca_cert,
expected_ca_password))
self.assertEqual((expected_ca_cert_ref, expected_ca_cert,
expected_ca_password),
cert_manager._generate_ca_cert(expected_ca_name))
mock_generate_ca_cert.assert_called_once_with(
expected_ca_name, encryption_password=expected_ca_password)
@ -78,9 +77,11 @@ class CertManagerTestCase(base.BaseTestCase):
self.CertManager.store_cert.return_value = expected_cert_ref
self.assertEqual(
expected_cert_ref,
cert_manager._generate_client_cert(
expected_ca_name, expected_ca_cert, expected_ca_password),
expected_cert_ref)
expected_ca_name,
expected_ca_cert,
expected_ca_password))
mock_generate_cert.assert_called_once_with(
expected_ca_name,
@ -117,8 +118,8 @@ class CertManagerTestCase(base.BaseTestCase):
mock_generate_client_cert.return_value = expected_cert_ref
cert_manager.generate_certificates_to_bay(mock_bay)
self.assertEqual(mock_bay.ca_cert_ref, expected_ca_cert_ref)
self.assertEqual(mock_bay.magnum_cert_ref, expected_cert_ref)
self.assertEqual(expected_ca_cert_ref, mock_bay.ca_cert_ref)
self.assertEqual(expected_cert_ref, mock_bay.magnum_cert_ref)
mock_generate_ca_cert.assert_called_once_with(expected_ca_name)
mock_generate_client_cert.assert_called_once_with(
@ -143,7 +144,7 @@ class CertManagerTestCase(base.BaseTestCase):
mock_x509_sign.assert_called_once_with(mock_csr, mock_bay.name,
mock.sentinel.priv_key,
passphrase)
self.assertEqual(bay_ca_cert, mock.sentinel.signed_cert)
self.assertEqual(mock.sentinel.signed_cert, bay_ca_cert)
def test_get_bay_ca_certificate(self):
mock_bay = mock.MagicMock()
@ -155,7 +156,7 @@ class CertManagerTestCase(base.BaseTestCase):
self.CertManager.get_cert.assert_called_once_with(
mock_bay.ca_cert_ref, resource_ref=mock_bay.uuid)
self.assertEqual(bay_ca_cert, mock_ca_cert)
self.assertEqual(mock_ca_cert, bay_ca_cert)
def test_delete_certtificate(self):
mock_delete_cert = self.CertManager.delete_cert

60
magnum/tests/unit/conductor/handlers/test_bay_conductor.py
View File

@ -609,8 +609,8 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.stack_status = bay_status.CREATE_IN_PROGRESS
poller.poll_and_check()
self.assertEqual(bay.save.call_count, 0)
self.assertEqual(poller.attempts, 1)
self.assertEqual(0, bay.save.call_count)
self.assertEqual(1, poller.attempts)
def test_poll_save(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -620,10 +620,10 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.stack_status_reason = 'Create failed'
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(bay.save.call_count, 1)
self.assertEqual(bay.status, bay_status.CREATE_FAILED)
self.assertEqual(bay.status_reason, 'Create failed')
self.assertEqual(poller.attempts, 1)
self.assertEqual(1, bay.save.call_count)
self.assertEqual(bay_status.CREATE_FAILED, bay.status)
self.assertEqual('Create failed', bay.status_reason)
self.assertEqual(1, poller.attempts)
def test_poll_done(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -633,7 +633,7 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.stack_status = bay_status.CREATE_FAILED
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(poller.attempts, 2)
self.assertEqual(2, poller.attempts)
def test_poll_done_by_update(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -642,10 +642,10 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.parameters = {'number_of_minions': 2}
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(bay.save.call_count, 1)
self.assertEqual(bay.status, bay_status.UPDATE_COMPLETE)
self.assertEqual(bay.node_count, 2)
self.assertEqual(poller.attempts, 1)
self.assertEqual(1, bay.save.call_count)
self.assertEqual(bay_status.UPDATE_COMPLETE, bay.status)
self.assertEqual(2, bay.node_count)
self.assertEqual(1, poller.attempts)
def test_poll_done_by_update_failed(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -654,10 +654,10 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.parameters = {'number_of_minions': 2}
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(bay.save.call_count, 1)
self.assertEqual(bay.status, bay_status.UPDATE_FAILED)
self.assertEqual(bay.node_count, 2)
self.assertEqual(poller.attempts, 1)
self.assertEqual(1, bay.save.call_count)
self.assertEqual(bay_status.UPDATE_FAILED, bay.status)
self.assertEqual(2, bay.node_count)
self.assertEqual(1, poller.attempts)
def test_poll_destroy(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -665,20 +665,20 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.stack_status = bay_status.DELETE_FAILED
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
# Destroy method is not called when stack delete failed
self.assertEqual(bay.destroy.call_count, 0)
self.assertEqual(0, bay.destroy.call_count)
mock_heat_stack.stack_status = bay_status.DELETE_IN_PROGRESS
poller.poll_and_check()
self.assertEqual(bay.destroy.call_count, 0)
self.assertEqual(bay.status, bay_status.DELETE_IN_PROGRESS)
self.assertEqual(0, bay.destroy.call_count)
self.assertEqual(bay_status.DELETE_IN_PROGRESS, bay.status)
mock_heat_stack.stack_status = bay_status.DELETE_COMPLETE
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
# The bay status should still be DELETE_IN_PROGRESS, because
# the destroy() method may be failed. If success, this bay record
# will delete directly, change status is meaningless.
self.assertEqual(bay.status, bay_status.DELETE_IN_PROGRESS)
self.assertEqual(bay.destroy.call_count, 1)
self.assertEqual(bay_status.DELETE_IN_PROGRESS, bay.status)
self.assertEqual(1, bay.destroy.call_count)
def test_poll_delete_in_progress_timeout_set(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -751,7 +751,7 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.stack_status = bay_status.CREATE_IN_PROGRESS
poller.poll_and_check()
self.assertEqual(bay.node_count, 1)
self.assertEqual(1, bay.node_count)
def test_poll_node_count_by_update(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -760,7 +760,7 @@ class TestBayConductorWithK8s(base.TestCase):
mock_heat_stack.stack_status = bay_status.UPDATE_COMPLETE
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(bay.node_count, 2)
self.assertEqual(2, bay.node_count)
class TestHandler(db_base.DbTestCase):
@ -801,7 +801,7 @@ class TestHandler(db_base.DbTestCase):
self.context, mock_openstack_client, self.bay,
mock_scale_manager.return_value)
bay = objects.Bay.get(self.context, self.bay.uuid)
self.assertEqual(bay.node_count, 2)
self.assertEqual(2, bay.node_count)
@patch('magnum.conductor.handlers.bay_conductor.Handler._poll_and_check')
@patch('magnum.conductor.handlers.bay_conductor._update_stack')
@ -825,7 +825,7 @@ class TestHandler(db_base.DbTestCase):
self.context, self.bay)
bay = objects.Bay.get(self.context, self.bay.uuid)
self.assertEqual(bay.node_count, 1)
self.assertEqual(1, bay.node_count)
@patch('magnum.common.clients.OpenStackClients')
def test_update_bay_with_invalid_params(
@ -844,7 +844,7 @@ class TestHandler(db_base.DbTestCase):
self.context,
self.bay)
bay = objects.Bay.get(self.context, self.bay.uuid)
self.assertEqual(bay.node_count, 1)
self.assertEqual(1, bay.node_count)
@patch('magnum.conductor.handlers.bay_conductor.HeatPoller')
@patch('magnum.conductor.handlers.bay_conductor.cert_manager')
@ -863,7 +863,7 @@ class TestHandler(db_base.DbTestCase):
mock_openstack_client_class.return_value = mock.sentinel.osc
def create_stack_side_effect(context, osc, bay, timeout):
self.assertEqual(bay.uuid, str(test_uuid))
self.assertEqual(str(test_uuid), bay.uuid)
return {'stack': {'id': 'stack-id'}}
mock_create_stack.side_effect = create_stack_side_effect
@ -1028,7 +1028,7 @@ class TestBayConductorWithSwarm(base.TestCase):
mock_heat_stack.stack_status = bay_status.CREATE_IN_PROGRESS
poller.poll_and_check()
self.assertEqual(bay.node_count, 1)
self.assertEqual(1, bay.node_count)
def test_poll_node_count_by_update(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -1037,7 +1037,7 @@ class TestBayConductorWithSwarm(base.TestCase):
mock_heat_stack.stack_status = bay_status.UPDATE_COMPLETE
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(bay.node_count, 2)
self.assertEqual(2, bay.node_count)
class TestBayConductorWithMesos(base.TestCase):
@ -1143,7 +1143,7 @@ class TestBayConductorWithMesos(base.TestCase):
mock_heat_stack.stack_status = bay_status.CREATE_IN_PROGRESS
poller.poll_and_check()
self.assertEqual(bay.node_count, 1)
self.assertEqual(1, bay.node_count)
def test_poll_node_count_by_update(self):
mock_heat_stack, bay, poller = self.setup_poll_test()
@ -1152,4 +1152,4 @@ class TestBayConductorWithMesos(base.TestCase):
mock_heat_stack.stack_status = bay_status.UPDATE_COMPLETE
self.assertRaises(loopingcall.LoopingCallDone, poller.poll_and_check)
self.assertEqual(bay.node_count, 2)
self.assertEqual(2, bay.node_count)

10
magnum/tests/unit/conductor/handlers/test_ca_conductor.py
View File

@ -38,7 +38,7 @@ class TestSignConductor(base.TestCase):
mock_cert_manager.sign_node_certificate.assert_called_once_with(
mock_bay, 'fake-csr'
)
self.assertEqual(actual_cert.pem, 'fake-pem')
self.assertEqual('fake-pem', actual_cert.pem)
@patch.object(ca_conductor, 'cert_manager')
def test_get_ca_certificate(self, mock_cert_manager):
@ -53,7 +53,7 @@ class TestSignConductor(base.TestCase):
actual_cert = self.ca_handler.get_ca_certificate(self.context,
mock_bay)
self.assertEqual(actual_cert.bay_uuid, mock_bay.uuid)
self.assertEqual(actual_cert.user_id, mock_bay.user_id)
self.assertEqual(actual_cert.project_id, mock_bay.project_id)
self.assertEqual(actual_cert.pem, 'fake-pem')
self.assertEqual(mock_bay.uuid, actual_cert.bay_uuid)
self.assertEqual(mock_bay.user_id, actual_cert.user_id)
self.assertEqual(mock_bay.project_id, actual_cert.project_id)
self.assertEqual('fake-pem', actual_cert.pem)

2
magnum/tests/unit/conductor/handlers/test_conductor_listener.py
View File

@ -21,4 +21,4 @@ class TestHandler(base.BaseTestCase):
self.handler = conductor_listener.Handler()
def test_ping_conductor(self):
self.assertEqual(self.handler.ping_conductor({}), True)
self.assertEqual(True, self.handler.ping_conductor({}))

2
magnum/tests/unit/conductor/tasks/test_heat_tasks.py
View File

@ -77,7 +77,7 @@ class HeatTasksTests(base.TestCase):
result = engines.run(flow, store=flow_store)
heat_client.stacks.create.assert_called_once_with(**flow_store)
self.assertEqual(result['new_stack']['stack']['id'], stack_id)
self.assertEqual(stack_id, result['new_stack']['stack']['id'])
def test_create_stack_with_error(self):
heat_client = mock.MagicMock(name='heat_client')

22
magnum/tests/unit/conductor/test_monitors.py
View File

@ -74,9 +74,9 @@ class MonitorsTestCase(base.TestCase):
self.monitor.pull_data()
self.assertEqual(self.monitor.data['nodes'],
[{'MemTotal': 1073741824.0}])
self.assertEqual(self.monitor.data['containers'], ['test_container'])
self.assertEqual([{'MemTotal': 1073741824.0}],
self.monitor.data['nodes'])
self.assertEqual(['test_container'], self.monitor.data['containers'])
@mock.patch('magnum.common.docker_utils.docker_for_bay')
def test_swarm_monitor_pull_data_raise(self, mock_docker_for_bay):
@ -90,24 +90,24 @@ class MonitorsTestCase(base.TestCase):
self.monitor.pull_data()
self.assertEqual(self.monitor.data['nodes'],
[{'MemTotal': 1073741824.0}])
self.assertEqual(self.monitor.data['containers'], [mock_container])
self.assertEqual([{'MemTotal': 1073741824.0}],
self.monitor.data['nodes'])
self.assertEqual([mock_container], self.monitor.data['containers'])
def test_swarm_monitor_get_metric_names(self):
names = self.monitor.get_metric_names()
self.assertEqual(sorted(names), sorted(['metric1', 'metric2']))
self.assertEqual(sorted(['metric1', 'metric2']), sorted(names))
def test_swarm_monitor_get_metric_unit(self):
unit = self.monitor.get_metric_unit('metric1')
self.assertEqual(unit, 'metric1_unit')
self.assertEqual('metric1_unit', unit)
def test_swarm_monitor_compute_metric_value(self):
mock_func = mock.MagicMock()
mock_func.return_value = 'metric1_value'
self.monitor.metric1_func = mock_func
value = self.monitor.compute_metric_value('metric1')
self.assertEqual(value, 'metric1_value')
self.assertEqual('metric1_value', value)
def test_swarm_monitor_compute_memory_util(self):
test_data = {
@ -128,7 +128,7 @@ class MonitorsTestCase(base.TestCase):
}
self.monitor.data = test_data
mem_util = self.monitor.compute_memory_util()
self.assertEqual(mem_util, 50)
self.assertEqual(50, mem_util)
test_data = {
'nodes': [],
@ -136,4 +136,4 @@ class MonitorsTestCase(base.TestCase):
}
self.monitor.data = test_data
mem_util = self.monitor.compute_memory_util()
self.assertEqual(mem_util, 0)
self.assertEqual(0, mem_util)

6
magnum/tests/unit/conductor/test_rpcapi.py
View File

@ -58,7 +58,7 @@ class RPCAPITestCase(base.DbTestCase):
def _fake_prepare_method(*args, **kwargs):
for kwd in kwargs:
self.assertEqual(kwargs[kwd], target[kwd])
self.assertEqual(target[kwd], kwargs[kwd])
return rpcapi._client
def _fake_rpc_method(*args, **kwargs):
@ -73,10 +73,10 @@ class RPCAPITestCase(base.DbTestCase):
with mock.patch.object(rpcapi._client, rpc_method) as mock_method:
mock_method.side_effect = _fake_rpc_method
retval = getattr(rpcapi, method)(**kwargs)
self.assertEqual(retval, expected_retval)
self.assertEqual(expected_retval, retval)
expected_args = [None, method, 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_bay_create(self):
self._test_rpcapi('bay_create',

2
magnum/tests/unit/conductor/test_scale_manager.py
View File

@ -58,7 +58,7 @@ class TestScaleManager(base.TestCase):
scale_mgr.get_removal_nodes, mock_heat_output)
else:
removal_hosts = scale_mgr.get_removal_nodes(mock_heat_output)
self.assertEqual(removal_hosts, expected_removal_hosts)
self.assertEqual(expected_removal_hosts, removal_hosts)
@mock.patch('magnum.objects.Bay.get_by_uuid')
@mock.patch('magnum.conductor.scale_manager.ScaleManager._is_scale_down')

32
magnum/tests/unit/conductor/test_template_definition.py
View File

@ -42,12 +42,12 @@ class TemplateDefinitionTestCase(base.TestCase):
vm_atomic_k8s = defs[('vm', 'fedora-atomic', 'kubernetes')]
vm_coreos_k8s = defs[('vm', 'coreos', 'kubernetes')]
self.assertEqual(len(vm_atomic_k8s), 1)
self.assertEqual(vm_atomic_k8s['magnum_vm_atomic_k8s'],
tdef.AtomicK8sTemplateDefinition)
self.assertEqual(len(vm_coreos_k8s), 1)
self.assertEqual(vm_coreos_k8s['magnum_vm_coreos_k8s'],
tdef.CoreOSK8sTemplateDefinition)
self.assertEqual(1, len(vm_atomic_k8s))
self.assertEqual(tdef.AtomicK8sTemplateDefinition,
vm_atomic_k8s['magnum_vm_atomic_k8s'])
self.assertEqual(1, len(vm_coreos_k8s))
self.assertEqual(tdef.CoreOSK8sTemplateDefinition,
vm_coreos_k8s['magnum_vm_coreos_k8s'])
def test_get_vm_atomic_kubernetes_definition(self):
definition = tdef.TemplateDefinition.get_template_definition(
@ -126,11 +126,11 @@ class TemplateDefinitionTestCase(base.TestCase):
output = tdef.OutputMapping('key1')
value = output.get_output_value(mock_stack)
self.assertEqual(value, 'value1')
self.assertEqual('value1', value)
output = tdef.OutputMapping('key2')
value = output.get_output_value(mock_stack)
self.assertEqual(value, ["value2", "value3"])
self.assertEqual(["value2", "value3"], value)
output = tdef.OutputMapping('key3')
value = output.get_output_value(mock_stack)
@ -177,7 +177,7 @@ class TemplateDefinitionTestCase(base.TestCase):
definition.update_outputs(mock_stack, mock_baymodel, mock_bay)
self.assertEqual(mock_bay.node_addresses, expected_node_addresses)
self.assertEqual(expected_node_addresses, mock_bay.node_addresses)
class AtomicK8sTemplateDefinitionTestCase(base.TestCase):
@ -303,14 +303,14 @@ class AtomicK8sTemplateDefinitionTestCase(base.TestCase):
discovery_url = k8s_def.get_discovery_url(mock_bay)
mock_get.assert_called_once_with('http://etcd/test?size=10')
self.assertEqual(mock_bay.discovery_url, expected_discovery_url)
self.assertEqual(discovery_url, expected_discovery_url)
self.assertEqual(expected_discovery_url, mock_bay.discovery_url)
self.assertEqual(expected_discovery_url, discovery_url)
def test_k8s_get_heat_param(self):
k8s_def = tdef.AtomicK8sTemplateDefinition()
heat_param = k8s_def.get_heat_param(bay_attr='node_count')
self.assertEqual(heat_param, 'number_of_minions')
self.assertEqual('number_of_minions', heat_param)
@mock.patch('requests.get')
def test_k8s_get_discovery_url_not_found(self, mock_get):
@ -354,7 +354,7 @@ class AtomicK8sTemplateDefinitionTestCase(base.TestCase):
definition.update_outputs(mock_stack, mock_baymodel, mock_bay)
self.assertEqual(mock_bay.api_address, expected_api_address)
self.assertEqual(expected_api_address, mock_bay.api_address)
def test_update_outputs_if_baymodel_is_secure(self):
definition = tdef.TemplateDefinition.get_template_definition(
@ -384,7 +384,7 @@ class AtomicK8sTemplateDefinitionTestCase(base.TestCase):
mock_baymodel.tls_disabled = False
definition.update_outputs(mock_stack, mock_baymodel, mock_bay)
self.assertEqual(mock_bay.api_address, expected_api_address)
self.assertEqual(expected_api_address, mock_bay.api_address)
class AtomicSwarmTemplateDefinitionTestCase(base.TestCase):
@ -451,7 +451,7 @@ class AtomicSwarmTemplateDefinitionTestCase(base.TestCase):
swarm_def = tdef.AtomicSwarmTemplateDefinition()
heat_param = swarm_def.get_heat_param(bay_attr='node_count')
self.assertEqual(heat_param, 'number_of_nodes')
self.assertEqual('number_of_nodes', heat_param)
class UbuntuMesosTemplateDefinitionTestCase(base.TestCase):
@ -460,4 +460,4 @@ class UbuntuMesosTemplateDefinitionTestCase(base.TestCase):
mesos_def = tdef.UbuntuMesosTemplateDefinition()
heat_param = mesos_def.get_heat_param(bay_attr='node_count')
self.assertEqual(heat_param, 'number_of_slaves')
self.assertEqual('number_of_slaves', heat_param)