8a0b972c78
* Abstract message class added - all messages types are derived from it now and have to implement the `to_dict` method, so it can be serialized and transferred with broker; * Implemented the `Response` message type, that restores failures from dictionary on creation; * Corrected and improved unit tests; Change-Id: I10e017a613f0422420d0244b9f8786f988863107
131 lines
5.0 KiB
Python
131 lines
5.0 KiB
Python
# -*- coding: utf-8 -*-
|
|
|
|
# Copyright (C) 2014 Yahoo! Inc. All Rights Reserved.
|
|
#
|
|
# Licensed under the Apache License, Version 2.0 (the "License"); you may
|
|
# not use this file except in compliance with the License. You may obtain
|
|
# a copy of the License at
|
|
#
|
|
# http://www.apache.org/licenses/LICENSE-2.0
|
|
#
|
|
# Unless required by applicable law or agreed to in writing, software
|
|
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
# License for the specific language governing permissions and limitations
|
|
# under the License.
|
|
|
|
import mock
|
|
|
|
from concurrent import futures
|
|
|
|
from taskflow.engines.worker_based import protocol as pr
|
|
from taskflow import test
|
|
from taskflow.tests import utils
|
|
from taskflow.utils import misc
|
|
from taskflow.utils import persistence_utils as pu
|
|
|
|
|
|
class TestProtocol(test.TestCase):
|
|
|
|
def setUp(self):
|
|
super(TestProtocol, self).setUp()
|
|
self.task = utils.DummyTask()
|
|
self.task_uuid = 'task-uuid'
|
|
self.task_action = 'execute'
|
|
self.task_args = {'a': 'a'}
|
|
self.timeout = 60
|
|
|
|
def request(self, **kwargs):
|
|
request_kwargs = dict(task=self.task,
|
|
uuid=self.task_uuid,
|
|
action=self.task_action,
|
|
arguments=self.task_args,
|
|
progress_callback=None,
|
|
timeout=self.timeout)
|
|
request_kwargs.update(kwargs)
|
|
return pr.Request(**request_kwargs)
|
|
|
|
def request_to_dict(self, **kwargs):
|
|
to_dict = dict(task_cls=self.task.name,
|
|
task_name=self.task.name,
|
|
task_version=self.task.version,
|
|
action=self.task_action,
|
|
arguments=self.task_args)
|
|
to_dict.update(kwargs)
|
|
return to_dict
|
|
|
|
def test_creation(self):
|
|
request = self.request()
|
|
self.assertEqual(request.uuid, self.task_uuid)
|
|
self.assertEqual(request.task_cls, self.task.name)
|
|
self.assertIsInstance(request.result, futures.Future)
|
|
self.assertFalse(request.result.done())
|
|
|
|
def test_str(self):
|
|
request = self.request()
|
|
self.assertEqual(str(request), str(request.to_dict()))
|
|
|
|
def test_repr(self):
|
|
expected = '%s:%s' % (self.task.name, self.task_action)
|
|
self.assertEqual(repr(self.request()), expected)
|
|
|
|
def test_to_dict_default(self):
|
|
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)))
|
|
|
|
def test_to_dict_with_result_none(self):
|
|
self.assertEqual(self.request(result=None).to_dict(),
|
|
self.request_to_dict(result=('success', None)))
|
|
|
|
def test_to_dict_with_result_failure(self):
|
|
failure = misc.Failure.from_exception(RuntimeError('Woot!'))
|
|
expected = self.request_to_dict(
|
|
result=('failure', pu.failure_to_dict(failure)))
|
|
self.assertEqual(self.request(result=failure).to_dict(), expected)
|
|
|
|
def test_to_dict_with_failures(self):
|
|
failure = misc.Failure.from_exception(RuntimeError('Woot!'))
|
|
request = self.request(failures={self.task.name: failure})
|
|
expected = self.request_to_dict(
|
|
failures={self.task.name: pu.failure_to_dict(failure)})
|
|
self.assertEqual(request.to_dict(), expected)
|
|
|
|
@mock.patch('taskflow.engines.worker_based.protocol.misc.wallclock')
|
|
def test_pending_not_expired(self, mocked_wallclock):
|
|
mocked_wallclock.side_effect = [1, self.timeout]
|
|
self.assertFalse(self.request().expired)
|
|
|
|
@mock.patch('taskflow.engines.worker_based.protocol.misc.wallclock')
|
|
def test_pending_expired(self, mocked_wallclock):
|
|
mocked_wallclock.side_effect = [1, self.timeout + 2]
|
|
self.assertTrue(self.request().expired)
|
|
|
|
@mock.patch('taskflow.engines.worker_based.protocol.misc.wallclock')
|
|
def test_running_not_expired(self, mocked_wallclock):
|
|
mocked_wallclock.side_effect = [1, self.timeout + 2]
|
|
request = self.request()
|
|
request.set_running()
|
|
self.assertFalse(request.expired)
|
|
|
|
def test_set_result(self):
|
|
request = self.request()
|
|
request.set_result(111)
|
|
result = request.result.result()
|
|
self.assertEqual(result, (self.task, 'executed', 111))
|
|
|
|
def test_on_progress(self):
|
|
progress_callback = mock.MagicMock(name='progress_callback')
|
|
request = self.request(task=self.task,
|
|
progress_callback=progress_callback)
|
|
request.on_progress('event_data', 0.0)
|
|
request.on_progress('event_data', 1.0)
|
|
|
|
expected_calls = [
|
|
mock.call(self.task, 'event_data', 0.0),
|
|
mock.call(self.task, 'event_data', 1.0)
|
|
]
|
|
self.assertEqual(progress_callback.mock_calls, expected_calls)
|