openstack
/
taskflow
Code Issues Proposed changes

Fix order of assertEqual for unit.worker_based 

First parameter should be the expected value.

Change-Id: I209cc4be621c62f60fca3584a21457988129c014
Partial-Bug: #1357117
This commit is contained in:
lin-hua-cheng 2015-10-17 02:03:44 -07:00 committed by Lin Hua Cheng
parent dd22aff707
commit 4052c98165
7 changed files with 60 additions and 60 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
taskflow/tests/unit/worker_based/test_creation.py
View File

@ -52,7 +52,7 @@ class TestWorkerBasedActionEngine(test.MockTestCase):
transition_timeout=mock.ANY,
retry_options=None)
]
self.assertEqual(self.master_mock.mock_calls, expected_calls)
self.assertEqual(expected_calls, self.master_mock.mock_calls)
def test_creation_custom(self):
executor_mock, executor_inst_mock = self._patch_in_executor()
@ -77,7 +77,7 @@ class TestWorkerBasedActionEngine(test.MockTestCase):
transition_timeout=200,
retry_options={})
]
self.assertEqual(self.master_mock.mock_calls, expected_calls)
self.assertEqual(expected_calls, self.master_mock.mock_calls)
def test_creation_custom_executor(self):
ex = executor.WorkerTaskExecutor('a', 'test-exchange', ['test-topic'])

14
taskflow/tests/unit/worker_based/test_endpoint.py
View File

@ -44,16 +44,16 @@ class TestEndpoint(test.TestCase):
def test_creation(self):
task = self.task_ep.generate()
self.assertEqual(self.task_ep.name, self.task_cls_name)
self.assertEqual(self.task_cls_name, self.task_ep.name)
self.assertIsInstance(task, self.task_cls)
self.assertEqual(task.name, self.task_cls_name)
self.assertEqual(self.task_cls_name, task.name)
def test_creation_with_task_name(self):
task_name = 'test'
task = self.task_ep.generate(name=task_name)
self.assertEqual(self.task_ep.name, self.task_cls_name)
self.assertEqual(self.task_cls_name, self.task_ep.name)
self.assertIsInstance(task, self.task_cls)
self.assertEqual(task.name, task_name)
self.assertEqual(task_name, task.name)
def test_creation_task_with_constructor_args(self):
# NOTE(skudriashev): Exception is expected here since task
@ -62,7 +62,7 @@ class TestEndpoint(test.TestCase):
self.assertRaises(TypeError, endpoint.generate)
def test_to_str(self):
self.assertEqual(str(self.task_ep), self.task_cls_name)
self.assertEqual(self.task_cls_name, str(self.task_ep))
def test_execute(self):
task = self.task_ep.generate(self.task_cls_name)
@ -70,7 +70,7 @@ class TestEndpoint(test.TestCase):
task_uuid=self.task_uuid,
arguments=self.task_args,
progress_callback=None)
self.assertEqual(result, self.task_result)
self.assertEqual(self.task_result, result)
def test_revert(self):
task = self.task_ep.generate(self.task_cls_name)
@ -80,4 +80,4 @@ class TestEndpoint(test.TestCase):
progress_callback=None,
result=self.task_result,
failures={})
self.assertEqual(result, None)
self.assertEqual(None, result)

28
taskflow/tests/unit/worker_based/test_executor.py
View File

@ -91,7 +91,7 @@ class TestWorkerTaskExecutor(test.MockTestCase):
type_handlers=mock.ANY),
mock.call.proxy.dispatcher.type_handlers.update(mock.ANY),
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_on_message_response_state_running(self):
response = pr.Response(pr.RUNNING)
@ -126,7 +126,7 @@ class TestWorkerTaskExecutor(test.MockTestCase):
ex._requests_cache[self.task_uuid] = self.request_inst_mock
ex._process_response(response.to_dict(), self.message_mock)
self.assertEqual(len(ex._requests_cache), 0)
self.assertEqual(0, len(ex._requests_cache))
expected_calls = [
mock.call.transition_and_log_error(pr.FAILURE, logger=mock.ANY),
mock.call.set_result(result=test_utils.FailureMatcher(a_failure))
@ -152,7 +152,7 @@ class TestWorkerTaskExecutor(test.MockTestCase):
ex._requests_cache[self.task_uuid] = self.request_inst_mock
ex._process_response(response.to_dict(), self.message_mock)
self.assertEqual(self.request_inst_mock.mock_calls, [])
self.assertEqual([], self.request_inst_mock.mock_calls)
def test_on_message_response_unknown_task(self):
self.message_mock.properties['correlation_id'] = '<unknown>'
@ -161,7 +161,7 @@ class TestWorkerTaskExecutor(test.MockTestCase):
ex._requests_cache[self.task_uuid] = self.request_inst_mock
ex._process_response(response.to_dict(), self.message_mock)
self.assertEqual(self.request_inst_mock.mock_calls, [])
self.assertEqual([], self.request_inst_mock.mock_calls)
def test_on_message_response_no_correlation_id(self):
self.message_mock.properties = {'type': pr.RESPONSE}
@ -170,15 +170,15 @@ class TestWorkerTaskExecutor(test.MockTestCase):
ex._requests_cache[self.task_uuid] = self.request_inst_mock
ex._process_response(response.to_dict(), self.message_mock)
self.assertEqual(self.request_inst_mock.mock_calls, [])
self.assertEqual([], self.request_inst_mock.mock_calls)
def test_on_wait_task_not_expired(self):
ex = self.executor()
ex._requests_cache[self.task_uuid] = self.request_inst_mock
self.assertEqual(len(ex._requests_cache), 1)
self.assertEqual(1, len(ex._requests_cache))
ex._on_wait()
self.assertEqual(len(ex._requests_cache), 1)
self.assertEqual(1, len(ex._requests_cache))
def test_on_wait_task_expired(self):
now = timeutils.utcnow()
@ -191,24 +191,24 @@ class TestWorkerTaskExecutor(test.MockTestCase):
ex = self.executor()
ex._requests_cache[self.task_uuid] = self.request_inst_mock
self.assertEqual(len(ex._requests_cache), 1)
self.assertEqual(1, len(ex._requests_cache))
ex._on_wait()
self.assertEqual(len(ex._requests_cache), 0)
self.assertEqual(0, len(ex._requests_cache))
def test_remove_task_non_existent(self):
ex = self.executor()
ex._requests_cache[self.task_uuid] = self.request_inst_mock
self.assertEqual(len(ex._requests_cache), 1)
self.assertEqual(1, len(ex._requests_cache))
del ex._requests_cache[self.task_uuid]
self.assertEqual(len(ex._requests_cache), 0)
self.assertEqual(0, len(ex._requests_cache))
# delete non-existent
try:
del ex._requests_cache[self.task_uuid]
except KeyError:
pass
self.assertEqual(len(ex._requests_cache), 0)
self.assertEqual(0, len(ex._requests_cache))
def test_execute_task(self):
ex = self.executor()
@ -255,7 +255,7 @@ class TestWorkerTaskExecutor(test.MockTestCase):
mock.call.Request(self.task, self.task_uuid, 'execute',
self.task_args, self.timeout),
]
self.assertEqual(self.master_mock.mock_calls, expected_calls)
self.assertEqual(expected_calls, self.master_mock.mock_calls)
def test_execute_task_publish_error(self):
self.proxy_inst_mock.publish.side_effect = Exception('Woot!')
@ -316,7 +316,7 @@ class TestWorkerTaskExecutor(test.MockTestCase):
def test_stop_not_running(self):
self.executor().stop()
self.assertEqual(self.master_mock.mock_calls, [])
self.assertEqual([], self.master_mock.mock_calls)
def test_stop_not_alive(self):
self.proxy_inst_mock.start.side_effect = None

20
taskflow/tests/unit/worker_based/test_protocol.py
View File

@ -133,34 +133,34 @@ class TestProtocol(test.TestCase):
def test_creation(self):
request = self.request()
self.assertEqual(request.uuid, self.task_uuid)
self.assertEqual(request.task, self.task)
self.assertEqual(self.task_uuid, request.uuid)
self.assertEqual(self.task, request.task)
self.assertIsInstance(request.result, futurist.Future)
self.assertFalse(request.result.done())
def test_to_dict_default(self):
self.assertEqual(self.request().to_dict(), self.request_to_dict())
self.assertEqual(self.request_to_dict(), self.request().to_dict())
def test_to_dict_with_result(self):
self.assertEqual(self.request(result=333).to_dict(),
self.request_to_dict(result=('success', 333)))
self.assertEqual(self.request_to_dict(result=('success', 333)),
self.request(result=333).to_dict())
def test_to_dict_with_result_none(self):
self.assertEqual(self.request(result=None).to_dict(),
self.request_to_dict(result=('success', None)))
self.assertEqual(self.request_to_dict(result=('success', None)),
self.request(result=None).to_dict())
def test_to_dict_with_result_failure(self):
a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
expected = self.request_to_dict(result=('failure',
a_failure.to_dict()))
self.assertEqual(self.request(result=a_failure).to_dict(), expected)
self.assertEqual(expected, self.request(result=a_failure).to_dict())
def test_to_dict_with_failures(self):
a_failure = failure.Failure.from_exception(RuntimeError('Woot!'))
request = self.request(failures={self.task.name: a_failure})
expected = self.request_to_dict(
failures={self.task.name: a_failure.to_dict()})
self.assertEqual(request.to_dict(), expected)
self.assertEqual(expected, request.to_dict())
@mock.patch('oslo_utils.timeutils.now')
def test_pending_not_expired(self, now):
@ -189,4 +189,4 @@ class TestProtocol(test.TestCase):
request = self.request()
request.set_result(111)
result = request.result.result()
self.assertEqual(result, (executor.EXECUTED, 111))
self.assertEqual((executor.EXECUTED, 111), result)

4
taskflow/tests/unit/worker_based/test_proxy.py
View File

@ -138,7 +138,7 @@ class TestProxy(test.MockTestCase):
durable=False,
auto_delete=True)
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_creation_custom(self):
transport_opts = {'context': 'context'}
@ -151,7 +151,7 @@ class TestProxy(test.MockTestCase):
durable=False,
auto_delete=True)
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_publish(self):
msg_mock = mock.MagicMock()

26
taskflow/tests/unit/worker_based/test_server.py
View File

@ -91,7 +91,7 @@ class TestServer(test.MockTestCase):
retry_options=mock.ANY)
]
self.master_mock.assert_has_calls(master_mock_calls)
self.assertEqual(len(s._endpoints), 3)
self.assertEqual(3, len(s._endpoints))
def test_creation_with_endpoints(self):
s = self.server(endpoints=self.endpoints)
@ -104,34 +104,34 @@ class TestServer(test.MockTestCase):
retry_options=mock.ANY)
]
self.master_mock.assert_has_calls(master_mock_calls)
self.assertEqual(len(s._endpoints), len(self.endpoints))
self.assertEqual(len(self.endpoints), len(s._endpoints))
def test_parse_request(self):
request = self.make_request()
bundle = pr.Request.from_dict(request)
task_cls, task_name, action, task_args = bundle
self.assertEqual((task_cls, task_name, action, task_args),
(self.task.name, self.task.name, self.task_action,
dict(arguments=self.task_args)))
self.assertEqual((self.task.name, self.task.name, self.task_action,
dict(arguments=self.task_args)),
(task_cls, task_name, action, task_args))
def test_parse_request_with_success_result(self):
request = self.make_request(action='revert', result=1)
bundle = pr.Request.from_dict(request)
task_cls, task_name, action, task_args = bundle
self.assertEqual((task_cls, task_name, action, task_args),
(self.task.name, self.task.name, 'revert',
self.assertEqual((self.task.name, self.task.name, 'revert',
dict(arguments=self.task_args,
result=1)))
result=1)),
(task_cls, task_name, action, task_args))
def test_parse_request_with_failure_result(self):
a_failure = failure.Failure.from_exception(Exception('test'))
request = self.make_request(action='revert', result=a_failure)
bundle = pr.Request.from_dict(request)
task_cls, task_name, action, task_args = bundle
self.assertEqual((task_cls, task_name, action, task_args),
(self.task.name, self.task.name, 'revert',
self.assertEqual((self.task.name, self.task.name, 'revert',
dict(arguments=self.task_args,
result=utils.FailureMatcher(a_failure))))
result=utils.FailureMatcher(a_failure))),
(task_cls, task_name, action, task_args))
def test_parse_request_with_failures(self):
failures = {'0': failure.Failure.from_exception(Exception('test1')),
@ -140,11 +140,11 @@ class TestServer(test.MockTestCase):
bundle = pr.Request.from_dict(request)
task_cls, task_name, action, task_args = bundle
self.assertEqual(
(task_cls, task_name, action, task_args),
(self.task.name, self.task.name, 'revert',
dict(arguments=self.task_args,
failures=dict((i, utils.FailureMatcher(f))
for i, f in six.iteritems(failures)))))
for i, f in six.iteritems(failures)))),
(task_cls, task_name, action, task_args))
@mock.patch("taskflow.engines.worker_based.server.LOG.critical")
def test_reply_publish_failure(self, mocked_exception):

24
taskflow/tests/unit/worker_based/test_worker.py
View File

@ -99,7 +99,7 @@ class TestWorker(test.MockTestCase):
transport=mock.ANY,
retry_options=mock.ANY)
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_run_with_no_tasks(self):
self.worker(reset_master_mock=True).run()
@ -107,7 +107,7 @@ class TestWorker(test.MockTestCase):
master_mock_calls = [
mock.call.server.start()
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_run_with_tasks(self):
self.worker(reset_master_mock=True,
@ -116,7 +116,7 @@ class TestWorker(test.MockTestCase):
master_mock_calls = [
mock.call.server.start()
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_run_with_custom_executor(self):
executor_mock = mock.MagicMock(name='executor')
@ -126,7 +126,7 @@ class TestWorker(test.MockTestCase):
master_mock_calls = [
mock.call.server.start()
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_wait(self):
w = self.worker(reset_master_mock=True)
@ -137,7 +137,7 @@ class TestWorker(test.MockTestCase):
mock.call.server.start(),
mock.call.server.wait()
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_stop(self):
self.worker(reset_master_mock=True).stop()
@ -146,20 +146,20 @@ class TestWorker(test.MockTestCase):
mock.call.server.stop(),
mock.call.executor.shutdown()
]
self.assertEqual(self.master_mock.mock_calls, master_mock_calls)
self.assertEqual(master_mock_calls, self.master_mock.mock_calls)
def test_derive_endpoints_from_string_tasks(self):
endpoints = worker.Worker._derive_endpoints(
['taskflow.tests.utils:DummyTask'])
self.assertEqual(len(endpoints), 1)
self.assertEqual(1, len(endpoints))
self.assertIsInstance(endpoints[0], endpoint.Endpoint)
self.assertEqual(endpoints[0].name, self.task_name)
self.assertEqual(self.task_name, endpoints[0].name)
def test_derive_endpoints_from_string_modules(self):
endpoints = worker.Worker._derive_endpoints(['taskflow.tests.utils'])
self.assertEqual(len(endpoints), self.endpoint_count)
self.assertEqual(self.endpoint_count, len(endpoints))
def test_derive_endpoints_from_string_non_existent_module(self):
tasks = ['non.existent.module']
@ -179,9 +179,9 @@ class TestWorker(test.MockTestCase):
def test_derive_endpoints_from_tasks(self):
endpoints = worker.Worker._derive_endpoints([self.task_cls])
self.assertEqual(len(endpoints), 1)
self.assertEqual(1, len(endpoints))
self.assertIsInstance(endpoints[0], endpoint.Endpoint)
self.assertEqual(endpoints[0].name, self.task_name)
self.assertEqual(self.task_name, endpoints[0].name)
def test_derive_endpoints_from_non_task_class(self):
self.assertRaises(TypeError, worker.Worker._derive_endpoints,
@ -190,7 +190,7 @@ class TestWorker(test.MockTestCase):
def test_derive_endpoints_from_modules(self):
endpoints = worker.Worker._derive_endpoints([utils])
self.assertEqual(len(endpoints), self.endpoint_count)
self.assertEqual(self.endpoint_count, len(endpoints))
def test_derive_endpoints_unexpected_task_type(self):
self.assertRaises(TypeError, worker.Worker._derive_endpoints, [111])