taskflow 5.7.0__py3-none-any.whl → 5.9.0__py3-none-any.whl

taskflow/test.py

@@ -19,9 +19,7 @@ from unittest import mock
 import fixtures
 from oslotest import base
 
-from testtools import compat
 from testtools import matchers
-from testtools import testcase
 
 from taskflow import exceptions
 from taskflow.tests import fixtures as taskflow_fixtures
@@ -122,30 +120,6 @@ class TestCase(base.BaseTestCase):
 
         self.assertRaises(exc_class, access_func)
 
-    def assertRaisesRegex(self, exc_class, pattern, callable_obj,
-                          *args, **kwargs):
-        # TODO(harlowja): submit a pull/review request to testtools to add
-        # this method to there codebase instead of having it exist in ours
-        # since it really doesn't belong here.
-
-        class ReRaiseOtherTypes(object):
-            def match(self, matchee):
-                if not issubclass(matchee[0], exc_class):
-                    compat.reraise(*matchee)
-
-        class CaptureMatchee(object):
-            def match(self, matchee):
-                self.matchee = matchee[1]
-
-        capture = CaptureMatchee()
-        matcher = matchers.Raises(matchers.MatchesAll(ReRaiseOtherTypes(),
-                                  matchers.MatchesException(exc_class,
-                                                            pattern),
-                                  capture))
-        our_callable = testcase.Nullary(callable_obj, *args, **kwargs)
-        self.assertThat(our_callable, matcher)
-        return capture.matchee
-
     def assertGreater(self, first, second):
         matcher = matchers.GreaterThan(first)
         self.assertThat(second, matcher)

taskflow/tests/unit/action_engine/test_creation.py

@@ -19,7 +19,6 @@ import testtools
 
 from taskflow.engines.action_engine import engine
 from taskflow.engines.action_engine import executor
-from taskflow.engines.action_engine import process_executor
 from taskflow.patterns import linear_flow as lf
 from taskflow.persistence import backends
 from taskflow import test
@@ -27,6 +26,11 @@ from taskflow.tests import utils
 from taskflow.utils import eventlet_utils as eu
 from taskflow.utils import persistence_utils as pu
 
+try:
+    from taskflow.engines.action_engine import process_executor as pe
+except ImportError:
+    pe = None
+
 
 class ParallelCreationTest(test.TestCase):
     @staticmethod
@@ -44,11 +48,12 @@ class ParallelCreationTest(test.TestCase):
             self.assertIsInstance(eng._task_executor,
                                   executor.ParallelThreadTaskExecutor)
 
+    @testtools.skipIf(pe is None, 'process_executor is not available')
     def test_process_string_creation(self):
         for s in ['process', 'processes']:
             eng = self._create_engine(executor=s)
             self.assertIsInstance(eng._task_executor,
-                                  process_executor.ParallelProcessTaskExecutor)
+                                  pe.ParallelProcessTaskExecutor)
 
     def test_thread_executor_creation(self):
         with futurist.ThreadPoolExecutor(1) as e:
@@ -56,11 +61,12 @@ class ParallelCreationTest(test.TestCase):
             self.assertIsInstance(eng._task_executor,
                                   executor.ParallelThreadTaskExecutor)
 
+    @testtools.skipIf(pe is None, 'process_executor is not available')
     def test_process_executor_creation(self):
         with futurist.ProcessPoolExecutor(1) as e:
             eng = self._create_engine(executor=e)
             self.assertIsInstance(eng._task_executor,
-                                  process_executor.ParallelProcessTaskExecutor)
+                                  pe.ParallelProcessTaskExecutor)
 
     @testtools.skipIf(not eu.EVENTLET_AVAILABLE, 'eventlet is not available')
     def test_green_executor_creation(self):

taskflow/tests/unit/action_engine/test_process_executor.py

@@ -13,19 +13,26 @@
 #    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 asyncore
 import errno
 import socket
 import threading
 
-from taskflow.engines.action_engine import process_executor as pu
+import testtools
+
 from taskflow import task
 from taskflow import test
 from taskflow.test import mock
 from taskflow.tests import utils as test_utils
 
+try:
+    import asyncore
+    from taskflow.engines.action_engine import process_executor as pe
+except ImportError:
+    asyncore = None
+    pe = None
+
 
+@testtools.skipIf(asyncore is None, 'process_executor is not available')
 class ProcessExecutorHelpersTest(test.TestCase):
     def test_reader(self):
         capture_buf = []
@@ -33,8 +40,8 @@ class ProcessExecutorHelpersTest(test.TestCase):
         def do_capture(identity, message_capture_func):
             capture_buf.append(message_capture_func())
 
-        r = pu.Reader(b"secret", do_capture)
-        for data in pu._encode_message(b"secret", ['hi'], b'me'):
+        r = pe.Reader(b"secret", do_capture)
+        for data in pe._encode_message(b"secret", ['hi'], b'me'):
             self.assertEqual(len(data), r.bytes_needed)
             r.feed(data)
 
@@ -42,9 +49,9 @@ class ProcessExecutorHelpersTest(test.TestCase):
         self.assertEqual(['hi'], capture_buf[0])
 
     def test_bad_hmac_reader(self):
-        r = pu.Reader(b"secret-2", lambda ident, capture_func: capture_func())
-        in_data = b"".join(pu._encode_message(b"secret", ['hi'], b'me'))
-        self.assertRaises(pu.BadHmacValueError, r.feed, in_data)
+        r = pe.Reader(b"secret-2", lambda ident, capture_func: capture_func())
+        in_data = b"".join(pe._encode_message(b"secret", ['hi'], b'me'))
+        self.assertRaises(pe.BadHmacValueError, r.feed, in_data)
 
     @mock.patch("socket.socket")
     def test_no_connect_channel(self, mock_socket_factory):
@@ -52,7 +59,7 @@ class ProcessExecutorHelpersTest(test.TestCase):
         mock_socket_factory.return_value = mock_sock
         mock_sock.connect.side_effect = socket.error(errno.ECONNREFUSED,
                                                      'broken')
-        c = pu.Channel(2222, b"me", b"secret")
+        c = pe.Channel(2222, b"me", b"secret")
         self.assertRaises(socket.error, c.send, "hi")
         self.assertTrue(c.dead)
         self.assertTrue(mock_sock.close.called)
@@ -65,7 +72,7 @@ class ProcessExecutorHelpersTest(test.TestCase):
             task.EVENT_UPDATE_PROGRESS,
             lambda _event_type, details: details_capture.append(details))
 
-        d = pu.Dispatcher({}, b'secret', b'server-josh')
+        d = pe.Dispatcher({}, b'secret', b'server-josh')
         d.setup()
         d.targets[b'child-josh'] = t
 
@@ -73,7 +80,7 @@ class ProcessExecutorHelpersTest(test.TestCase):
         s.start()
         self.addCleanup(s.join)
 
-        c = pu.Channel(d.port, b'child-josh', b'secret')
+        c = pe.Channel(d.port, b'child-josh', b'secret')
         self.addCleanup(c.close)
 
         send_what = [
@@ -87,7 +94,7 @@ class ProcessExecutorHelpersTest(test.TestCase):
             {'progress': 0.8},
             {'progress': 0.9},
         ]
-        e_s = pu.EventSender(c)
+        e_s = pe.EventSender(c)
         for details in send_what:
             e_s(task.EVENT_UPDATE_PROGRESS, details)
 

taskflow/tests/unit/jobs/test_etcd_job.py

@@ -0,0 +1,421 @@
+#    Copyright (C) Red Hat
+#
+#    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.
+
+from unittest import mock
+
+from oslo_serialization import jsonutils
+from oslo_utils import uuidutils
+import testtools
+
+from taskflow import exceptions as exc
+from taskflow.jobs.backends import impl_etcd
+from taskflow.jobs import base as jobs_base
+from taskflow import test
+from taskflow.tests.unit.jobs import base
+from taskflow.tests import utils as test_utils
+
+ETCD_AVAILABLE = test_utils.etcd_available()
+
+
+class EtcdJobBoardMixin:
+    def create_board(self, conf=None, persistence=None):
+        self.path = f"test-{uuidutils.generate_uuid()}"
+        board_conf = {
+            "path": self.path,
+        }
+        if conf:
+            board_conf.update(conf)
+        board = impl_etcd.EtcdJobBoard("etcd", board_conf,
+                                       persistence=persistence)
+        return board._client, board
+
+
+class MockedEtcdJobBoard(test.TestCase, EtcdJobBoardMixin):
+
+    def test_create_board(self):
+        _, jobboard = self.create_board()
+        self.assertEqual(f"/taskflow/jobs/{self.path}", jobboard._root_path)
+
+        _, jobboard = self.create_board({"path": "/testpath"})
+        self.assertEqual("/taskflow/jobs/testpath", jobboard._root_path)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard.incr")
+    @mock.patch("threading.Condition")
+    @mock.patch("oslo_utils.uuidutils.generate_uuid")
+    @mock.patch("oslo_utils.timeutils.utcnow")
+    def test_post(self,
+                  mock_utcnow: mock.Mock,
+                  mock_generated_uuid: mock.Mock,
+                  mock_cond: mock.Mock,
+                  mock_incr: mock.Mock):
+        mock_incr.return_value = 12
+        mock_generated_uuid.return_value = "uuid1"
+        mock_utcnow.return_value = "utcnow1"
+
+        mock_book = mock.Mock()
+        mock_book.name = "book1_name"
+        mock_book.uuid = "book1_uuid"
+        mock_details = mock.Mock()
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+        job = jobboard.post("post1", book=mock_book,
+                            details=mock_details,
+                            priority=jobs_base.JobPriority.NORMAL)
+
+        expected_key = (
+            f"/taskflow/jobs/{self.path}/job12")
+        expected_data_key = expected_key + jobboard.DATA_POSTFIX
+        expected_book_data = {
+            "name": "book1_name",
+            "uuid": "book1_uuid"
+        }
+        expected_job_posting = {
+            "uuid": "uuid1",
+            "name": "post1",
+            "priority": "NORMAL",
+            "created_on": "utcnow1",
+            "details": mock_details,
+            "book": expected_book_data,
+            "sequence": 12,
+        }
+
+        mock_incr.assert_called_with(f"/taskflow/jobs/{self.path}/sequence")
+
+        jobboard._client.create.assert_called_with(
+            expected_data_key, jsonutils.dumps(expected_job_posting))
+
+        self.assertEqual("post1", job.name)
+        self.assertEqual(expected_key, job.key)
+        self.assertEqual(mock_details, job.details)
+        self.assertEqual(mock_book, job.book)
+        self.assertEqual(expected_book_data, job._book_data)
+        self.assertEqual(jobs_base.JobPriority.NORMAL, job.priority)
+        self.assertEqual(12, job.sequence)
+
+        self.assertEqual(1, len(jobboard._job_cache))
+        self.assertEqual(job, jobboard._job_cache[expected_key])
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "set_last_modified")
+    def test_claim(self, mock_set_last_modified):
+        who = "owner1"
+        lease_id = uuidutils.generate_uuid()
+
+        _, jobboard = self.create_board(conf={"ttl": 37})
+        jobboard._client = mock.Mock()
+
+        mock_lease = mock.Mock(id=lease_id)
+        jobboard._client.lease.return_value = mock_lease
+        jobboard._client.create.return_value = True
+        jobboard._client.get.return_value = [mock.Mock()]
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7",
+                                uuid=uuidutils.generate_uuid(),
+                                details=mock.Mock(),
+                                backend="etcd",
+                                book=mock.Mock(),
+                                book_data=mock.Mock(),
+                                priority=jobs_base.JobPriority.NORMAL,
+                                sequence=7,
+                                created_on="date")
+
+        jobboard.claim(job, who)
+
+        jobboard._client.lease.assert_called_once_with(ttl=37)
+
+        jobboard._client.create.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}",
+            jsonutils.dumps({"owner": who,
+                             "lease_id": lease_id}),
+            lease=mock_lease)
+
+        jobboard._client.get.assert_called_once_with(
+            job.key + jobboard.DATA_POSTFIX)
+        mock_lease.revoke.assert_not_called()
+
+        mock_set_last_modified.assert_called_once_with(job)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "set_last_modified")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "find_owner")
+    def test_claim_already_claimed(self, mock_find_owner,
+                                   mock_set_last_modified):
+        who = "owner1"
+        lease_id = uuidutils.generate_uuid()
+
+        mock_find_owner.return_value = who
+
+        _, jobboard = self.create_board({"ttl": 37})
+        jobboard._client = mock.Mock()
+
+        mock_lease = mock.Mock(id=lease_id)
+        jobboard._client.lease.return_value = mock_lease
+        jobboard._client.create.return_value = False
+        jobboard._client.get.return_value = []
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7",
+                                uuid=uuidutils.generate_uuid(),
+                                details=mock.Mock(),
+                                backend="etcd",
+                                book=mock.Mock(),
+                                book_data=mock.Mock(),
+                                priority=jobs_base.JobPriority.NORMAL,
+                                sequence=7,
+                                created_on="date")
+
+        self.assertRaisesRegex(exc.UnclaimableJob, "already claimed by",
+                               jobboard.claim, job, who)
+
+        jobboard._client.lease.assert_called_once_with(ttl=37)
+
+        jobboard._client.create.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}",
+            jsonutils.dumps({"owner": who,
+                             "lease_id": lease_id}),
+            lease=mock_lease)
+
+        mock_lease.revoke.assert_called_once()
+
+        mock_set_last_modified.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "set_last_modified")
+    def test_claim_deleted(self, mock_set_last_modified):
+        who = "owner1"
+        lease_id = uuidutils.generate_uuid()
+
+        _, jobboard = self.create_board({"ttl": 37})
+        jobboard._client = mock.Mock()
+
+        mock_lease = mock.Mock(id=lease_id)
+        jobboard._client.lease.return_value = mock_lease
+        jobboard._client.create.return_value = True
+        jobboard._client.get.return_value = []
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7",
+                                uuid=uuidutils.generate_uuid(),
+                                details=mock.Mock(),
+                                backend="etcd",
+                                book=mock.Mock(),
+                                book_data=mock.Mock(),
+                                priority=jobs_base.JobPriority.NORMAL,
+                                sequence=7,
+                                created_on="date")
+
+        self.assertRaisesRegex(exc.UnclaimableJob, "already deleted",
+                               jobboard.claim, job, who)
+
+        jobboard._client.lease.assert_called_once_with(ttl=37)
+
+        jobboard._client.create.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}",
+            jsonutils.dumps({"owner": who,
+                             "lease_id": lease_id}),
+            lease=mock_lease)
+
+        jobboard._client.get.assert_called_once_with(
+            job.key + jobboard.DATA_POSTFIX)
+        mock_lease.revoke.assert_called_once()
+
+        mock_set_last_modified.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_consume(self, mock__remove_job_from_cache,
+                     mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        jobboard.consume(job, "owner1")
+
+        jobboard._client.delete_prefix.assert_called_once_with(job.key + ".")
+        mock__remove_job_from_cache.assert_called_once_with(job.key)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    def test_consume_bad_owner(self, mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner2", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.JobFailure, "which is not owned",
+                               jobboard.consume, job, "owner1")
+
+        jobboard._client.delete_prefix.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    def test_abandon(self, mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        jobboard.abandon(job, "owner1")
+
+        jobboard._client.delete.assert_called_once_with(
+            f"{job.key}{jobboard.LOCK_POSTFIX}")
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    def test_abandon_bad_owner(self, mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner2", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.JobFailure, "which is not owned",
+                               jobboard.abandon, job, "owner1")
+
+        jobboard._client.delete.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_trash(self, mock__remove_job_from_cache,
+                   mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        jobboard.trash(job, "owner1")
+
+        jobboard._client.create.assert_called_once_with(
+            f"/taskflow/.trash/{self.path}/job7", mock.ANY)
+        jobboard._client.delete_prefix.assert_called_once_with(job.key + ".")
+        mock__remove_job_from_cache.assert_called_once_with(job.key)
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_trash_bad_owner(self, mock__remove_job_from_cache,
+                             mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner2", mock.Mock()]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.JobFailure, "which is not owned",
+                               jobboard.trash, job, "owner1")
+
+        jobboard._client.create.assert_not_called()
+        jobboard._client.delete_prefix.assert_not_called()
+        mock__remove_job_from_cache.assert_not_called()
+
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "get_owner_and_data")
+    @mock.patch("taskflow.jobs.backends.impl_etcd.EtcdJobBoard."
+                "_remove_job_from_cache")
+    def test_trash_deleted_job(self, mock__remove_job_from_cache,
+                               mock_get_owner_and_data):
+        mock_get_owner_and_data.return_value = ["owner1", None]
+
+        _, jobboard = self.create_board()
+        jobboard._client = mock.Mock()
+
+        job = impl_etcd.EtcdJob(jobboard,
+                                "job7",
+                                jobboard._client,
+                                f"/taskflow/jobs/{self.path}/job7")
+        self.assertRaisesRegex(exc.NotFound, "Cannot find job",
+                               jobboard.trash, job, "owner1")
+
+        jobboard._client.create.assert_not_called()
+        jobboard._client.delete_prefix.assert_not_called()
+        mock__remove_job_from_cache.assert_not_called()
+
+
+@testtools.skipIf(not ETCD_AVAILABLE, 'Etcd is not available')
+class EtcdJobBoardTest(test.TestCase, base.BoardTestMixin, EtcdJobBoardMixin):
+    def setUp(self):
+        super().setUp()
+        self.client, self.board = self.create_board()
+
+    def test__incr(self):
+        key = uuidutils.generate_uuid()
+
+        self.board.connect()
+        self.addCleanup(self.board.close)
+        self.addCleanup(self.board._client.delete, key)
+
+        self.assertEqual(1, self.board.incr(key))
+        self.assertEqual(2, self.board.incr(key))
+        self.assertEqual(3, self.board.incr(key))
+
+        self.assertEqual(b'3', self.board.get_one(key))
+        self.board.close()
+
+    def test_get_one(self):
+        key1 = uuidutils.generate_uuid()
+
+        self.board.connect()
+        self.addCleanup(self.board._client.delete, key1)
+
+        # put data and get it
+        self.board._client.put(key1, "testset1")
+        self.assertEqual(b"testset1", self.board.get_one(key1))
+
+        # delete data and check that it's not found
+        self.board._client.delete(key1)
+        self.assertIsNone(self.board.get_one(key1))
+
+        # get a non-existant data
+        key2 = uuidutils.generate_uuid()
+        # (ensure it doesn't exist)
+        self.board._client.delete(key2)
+        self.assertIsNone(self.board.get_one(key2))
+        self.board.close()

taskflow/tests/unit/test_arguments_passing.py

@@ -23,6 +23,11 @@ from taskflow import test
 from taskflow.tests import utils
 from taskflow.utils import eventlet_utils as eu
 
+try:
+    from taskflow.engines.action_engine import process_executor as pe
+except ImportError:
+    pe = None
+
 
 class ArgumentsPassingTest(utils.EngineTestBase):
 
@@ -221,6 +226,7 @@ class ParallelEngineWithEventletTest(ArgumentsPassingTest, test.TestCase):
                                      executor=executor)
 
 
+@testtools.skipIf(pe is None, 'process_executor is not available')
 class ParallelEngineWithProcessTest(ArgumentsPassingTest, test.TestCase):
     _EXECUTOR_WORKERS = 2
 

taskflow/tests/unit/test_engines.py

@@ -41,6 +41,11 @@ from taskflow.utils import eventlet_utils as eu
 from taskflow.utils import persistence_utils as p_utils
 from taskflow.utils import threading_utils as tu
 
+try:
+    from taskflow.engines.action_engine import process_executor as pe
+except ImportError:
+    pe = None
+
 
 # Expected engine transitions when empty workflows are ran...
 _EMPTY_TRANSITIONS = [
@@ -1494,6 +1499,7 @@ class ParallelEngineWithEventletTest(EngineTaskTest,
                                      store=store, **kwargs)
 
 
+@testtools.skipIf(pe is None, 'process_executor is not available')
 class ParallelEngineWithProcessTest(EngineTaskTest,
                                     EngineMultipleResultsTest,
                                     EngineLinearFlowTest,

taskflow/tests/unit/test_retries.py

@@ -28,6 +28,11 @@ from taskflow.tests import utils
 from taskflow.types import failure
 from taskflow.utils import eventlet_utils as eu
 
+try:
+    from taskflow.engines.action_engine import process_executor as pe
+except ImportError:
+    pe = None
+
 
 class FailingRetry(retry.Retry):
 
@@ -1313,6 +1318,7 @@ class ParallelEngineWithEventletTest(RetryTest, test.TestCase):
                                      defer_reverts=defer_reverts)
 
 
+@testtools.skipIf(pe is None, 'process_executor is not available')
 class ParallelEngineWithProcessTest(RetryTest, test.TestCase):
     _EXECUTOR_WORKERS = 2
 

taskflow/tests/unit/test_suspend.py

@@ -25,6 +25,11 @@ from taskflow import test
 from taskflow.tests import utils
 from taskflow.utils import eventlet_utils as eu
 
+try:
+    from taskflow.engines.action_engine import process_executor as pe
+except ImportError:
+    pe = None
+
 
 class SuspendingListener(utils.CaptureListener):
 
@@ -224,6 +229,7 @@ class ParallelEngineWithEventletTest(SuspendTest, test.TestCase):
                                      executor=executor)
 
 
+@testtools.skipIf(pe is None, 'process_executor is not available')
 class ParallelEngineWithProcessTest(SuspendTest, test.TestCase):
     _EXECUTOR_WORKERS = 2