operaton-external-task-client-python3 1.0.0__py3-none-any.whl

operaton/external_task/tests/test_external_task.py

@@ -0,0 +1,106 @@
+from unittest import TestCase
+
+from operaton.external_task.external_task import ExternalTask
+
+
+class ExternalTaskTest(TestCase):
+
+    def test_external_task_creation_from_context(self):
+        context = {
+            "id": "123", "workerId": "321", "topicName": "my_topic", "tenantId": "tenant1",
+            "processInstanceId": "processInstanceId1",
+            "variables": {
+                "applicationId": {
+                    "type": "String",
+                    "value": "appId987",
+                    "valueInfo": {}
+                }
+            }
+        }
+        task = ExternalTask(context=context)
+
+        self.assertEqual("123", task.get_task_id())
+        self.assertEqual("321", task.get_worker_id())
+        self.assertEqual("my_topic", task.get_topic_name())
+        self.assertEqual("tenant1", task.get_tenant_id())
+        self.assertEqual("processInstanceId1", task.get_process_instance_id())
+        self.assertDictEqual({"applicationId": "appId987"}, task.get_variables())
+        self.assertEqual("empty_task_result", str(task.get_task_result()))
+
+    def test_complete_returns_success_task_result(self):
+        task = ExternalTask(context={})
+        task_result = task.complete({})
+
+        self.assertEqual(task, task_result.get_task())
+        self.assertEqual(task_result, task.get_task_result())
+
+        self.assertTrue(task_result.is_success())
+        self.assertFalse(task_result.is_failure())
+        self.assertFalse(task_result.is_bpmn_error())
+
+    def test_failure_returns_failure_task_result(self):
+        task = ExternalTask(context={})
+        task_result = task.failure(error_message="unknown error", error_details="error details here",
+                                   max_retries=3, retry_timeout=1000)
+
+        self.assertEqual(task, task_result.get_task())
+        self.assertEqual(task_result, task.get_task_result())
+
+        self.assertFalse(task_result.is_success())
+        self.assertTrue(task_result.is_failure())
+        self.assertFalse(task_result.is_bpmn_error())
+
+        self.assertEqual("unknown error", task_result.error_message)
+        self.assertEqual("error details here", task_result.error_details)
+        self.assertEqual(3, task_result.retries)
+        self.assertEqual(1000, task_result.retry_timeout)
+
+    def test_bpmn_error_returns_bpmn_error_task_result(self):
+        task = ExternalTask(context={})
+        task_result = task.bpmn_error(error_code="bpmn_error_code_1", error_message="bpmn error")
+
+        self.assertEqual(task, task_result.get_task())
+        self.assertEqual(task_result, task.get_task_result())
+
+        self.assertFalse(task_result.is_success())
+        self.assertFalse(task_result.is_failure())
+        self.assertTrue(task_result.is_bpmn_error())
+
+        self.assertEqual("bpmn_error_code_1", task_result.bpmn_error_code)
+
+    def test_task_with_retries_returns_failure_task_result_with_decremented_retries(self):
+        retries = 3
+        task = ExternalTask(context={"retries": retries})
+        task_result = task.failure(error_message="unknown error", error_details="error details here",
+                                   max_retries=10, retry_timeout=1000)
+
+        self.assertEqual(retries - 1, task_result.retries)
+
+    def test_get_variable_returns_none_for_missing_variable(self):
+        task = ExternalTask(context={})
+        variable = task.get_variable("var_name")
+        self.assertIsNone(variable)
+
+    def test_get_variable_returns_value_for_variable_present(self):
+        task = ExternalTask(context={"variables": {"var_name": {"value": 1}}})
+        variable = task.get_variable("var_name")
+        self.assertEqual(1, variable)
+
+    def test_get_variable_returns_with_meta(self):
+        task = ExternalTask(context={"variables": {"var_name": {"value": 1}}})
+        variable = task.get_variable("var_name", True)
+        self.assertEqual({"value": 1}, variable)
+
+    def test_get_variable_returns_without_meta(self):
+        task = ExternalTask(context={"variables": {"var_name": {"value": 1}}})
+        variable = task.get_variable("var_name", False)
+        self.assertEqual(1, variable)
+
+    def test_get_property_returns_value_for_property_present(self):
+        task = ExternalTask(context={"extensionProperties":  {"var1":"one","var2":"two"}})
+        prop = task.get_extension_property("var1")
+        self.assertEqual("one", prop)
+
+    def test_str(self):
+        task = ExternalTask(context={"variables": {"var_name": {"value": 1}}})
+        self.assertEqual("{'variables': {'var_name': {'value': 1}}}", str(task))

operaton/external_task/tests/test_external_task_executor.py

@@ -0,0 +1,200 @@
+import base64
+import collections
+from http import HTTPStatus
+from unittest import TestCase
+
+import responses
+
+from operaton.client.external_task_client import ExternalTaskClient
+from operaton.external_task.external_task import TaskResult, ExternalTask
+from operaton.external_task.external_task_executor import ExternalTaskExecutor
+
+
+class ExternalTaskExecutorTest(TestCase):
+
+    @staticmethod
+    def task_success_action(task):
+        output_vars = {"var1": 1, "var2": "value", "var3": True}
+        return TaskResult.success(task, output_vars)
+
+    @responses.activate
+    def test_task_complete(self):
+        task = ExternalTask({"id": "1", "topicName": "my_topic"})
+        output_vars = {"var1": 1, "var2": "value", "var3": True}
+        expected_task_result = TaskResult.success(task, output_vars)
+
+        external_task_client = ExternalTaskClient(worker_id=1)
+        responses.add(
+            responses.POST,
+            external_task_client.get_task_complete_url(task.get_task_id()),
+            status=HTTPStatus.NO_CONTENT
+        )
+        executor = ExternalTaskExecutor(worker_id=1, external_task_client=external_task_client)
+
+        actual_task_result = executor.execute_task(task, self.task_success_action)
+        self.assertEqual(str(expected_task_result), str(actual_task_result))
+
+    @staticmethod
+    def task_failure_action(task):
+        return TaskResult.failure(task, error_message="unknown task failure", error_details="unknown error",
+                                  retries=3, retry_timeout=30000)
+
+    @responses.activate
+    def test_task_failure(self):
+        task = ExternalTask({"id": "1", "topicName": "my_topic"})
+        expected_task_result = TaskResult.failure(
+            task,
+            error_message="unknown task failure",
+            error_details="unknown error",
+            retries=3,
+            retry_timeout=30000
+        )
+
+        external_task_client = ExternalTaskClient(worker_id=1)
+        responses.add(
+            responses.POST,
+            external_task_client.get_task_failure_url(task.get_task_id()),
+            status=HTTPStatus.NO_CONTENT
+        )
+        executor = ExternalTaskExecutor(worker_id=1, external_task_client=external_task_client)
+
+        actual_task_result = executor.execute_task(task, self.task_failure_action)
+        self.assertEqual(str(expected_task_result), str(actual_task_result))
+
+    @staticmethod
+    def task_bpmn_error_action(task):
+        return TaskResult.bpmn_error(task, error_code="bpmn_err_code_1", error_message="bpmn error")
+
+    @responses.activate
+    def test_task_bpmn_error(self):
+        task = ExternalTask({"id": "1", "topicName": "my_topic"})
+        expected_task_result = TaskResult.bpmn_error(task, error_code="bpmn_err_code_1", error_message="bpmn error")
+
+        external_task_client = ExternalTaskClient(worker_id=1)
+        responses.add(
+            responses.POST,
+            external_task_client.get_task_bpmn_error_url(task.get_task_id()),
+            status=HTTPStatus.NO_CONTENT
+        )
+        executor = ExternalTaskExecutor(worker_id=1, external_task_client=external_task_client)
+
+        actual_task_result = executor.execute_task(task, self.task_bpmn_error_action)
+        self.assertEqual(str(expected_task_result), str(actual_task_result))
+
+    @staticmethod
+    def task_result_not_complete_failure_bpmn_error(task):
+        return TaskResult.empty_task_result(task)
+
+    def test_task_result_not_complete_failure_bpmn_error_raises_exception(self):
+        task = ExternalTask({"id": "1", "topicName": "my_topic"})
+        external_task_client = ExternalTaskClient(worker_id=1)
+        executor = ExternalTaskExecutor(worker_id=1, external_task_client=external_task_client)
+
+        with self.assertRaises(Exception) as exception_ctx:
+            executor.execute_task(task, self.task_result_not_complete_failure_bpmn_error)
+
+        self.assertEqual(
+            "task result for task_id=1 must be either complete/failure/BPMNError",
+            str(exception_ctx.exception)
+        )
+
+    @responses.activate
+    def test_execute_task_raises_exception_raised_when_updating_status_in_engine(self):
+        client = ExternalTaskClient(worker_id=1)
+        task = ExternalTask({"id": "1", "topicName": "my_topic"})
+        executor = ExternalTaskExecutor(worker_id=1, external_task_client=client)
+
+        TaskResultStatusInput = collections.namedtuple(
+            'TaskResultStatusInput',
+            ['task_status', 'task_action', 'task_status_url', 'error_message']
+        )
+
+        task_result_tests = [
+            TaskResultStatusInput(
+                "complete", self.task_success_action,
+                client.get_task_complete_url(task.get_task_id()),
+                "cannot update task status to complete"
+            ),
+            TaskResultStatusInput(
+                "failure", self.task_failure_action,
+                client.get_task_failure_url(task.get_task_id()),
+                "cannot update task status to failure"
+            ),
+            TaskResultStatusInput(
+                "bpmn_error", self.task_bpmn_error_action,
+                client.get_task_bpmn_error_url(task.get_task_id()),
+                "cannot update task status to BPMN err"
+            )
+        ]
+
+        for task_result_test in task_result_tests:
+            with self.subTest(task_result_test.task_status):
+                responses.add(
+                    responses.POST,
+                    task_result_test.task_status_url,
+                    body=Exception(task_result_test.error_message)
+                )
+
+                with self.assertRaises(Exception) as exception_ctx:
+                    executor.execute_task(task, task_result_test.task_action)
+
+                self.assertEqual(task_result_test.error_message, str(exception_ctx.exception))
+
+    @responses.activate
+    def test_execute_task_raises_exception_if_engine_returns_http_status_other_than_no_content_204(self):
+        client = ExternalTaskClient(worker_id=1)
+        task = ExternalTask({"id": "1", "topicName": "my_topic"})
+        executor = ExternalTaskExecutor(worker_id=1, external_task_client=client)
+
+        TaskResultStatusInput = collections.namedtuple('TaskResultStatusInput',
+                                                       ['task_status', 'task_action', 'task_status_url',
+                                                        'http_status_code', 'expected_error_message'])
+
+        task_result_tests = [
+            TaskResultStatusInput(
+                "complete", self.task_success_action,
+                client.get_task_complete_url(task.get_task_id()), HTTPStatus.OK,
+                'Not able to mark complete for task_id=1 for topic=my_topic, worker_id=1'
+            ),
+            TaskResultStatusInput(
+                "failure", self.task_failure_action,
+                client.get_task_failure_url(task.get_task_id()), HTTPStatus.CREATED,
+                'Not able to mark failure for task_id=1 for topic=my_topic, worker_id=1'
+            ),
+            TaskResultStatusInput(
+                "bpmn_error", self.task_bpmn_error_action,
+                client.get_task_bpmn_error_url(task.get_task_id()), HTTPStatus.ACCEPTED,
+                'Not able to mark BPMN Error for task_id=1 for topic=my_topic, worker_id=1'
+            )
+        ]
+
+        for task_result_test in task_result_tests:
+            with self.subTest(task_result_test.task_status):
+                responses.add(
+                    responses.POST, task_result_test.task_status_url,
+                    status=task_result_test.http_status_code
+                )
+
+                with self.assertRaises(Exception) as exception_ctx:
+                    executor.execute_task(task, task_result_test.task_action)
+
+                self.assertEqual(task_result_test.expected_error_message, str(exception_ctx.exception))
+
+    def test_strip_long_variables(self):
+        variables = {
+            "var0": "string",
+            "var1": {"value": "string"},
+            "var2": {"value": 1},
+            "var3": {"value": "{\"key\": \"value\"}", "type": "Json"},
+            "var4": {"value": base64.encodebytes(b"string"), "type": "Bytes"},
+            "var5": {"value": "some file content", "type": "File"},
+        }
+        cleaned = ExternalTaskExecutor("worker-1", None)._strip_long_variables(variables)
+        self.assertEqual({
+            "var0": "string",
+            "var1": {"value": "string"},
+            "var2": {"value": 1},
+            "var3": {"value": "{\"key\": \"value\"}", "type": "Json"},
+            "var4": {"value": "...", "type": "Bytes"},
+            "var5": {"value": "...", "type": "File"},
+        }, cleaned)

operaton/external_task/tests/test_external_task_worker.py

@@ -0,0 +1,147 @@
+from http import HTTPStatus
+from unittest import mock, TestCase
+from unittest.mock import patch
+
+import responses
+
+from operaton.client.external_task_client import ExternalTaskClient
+from operaton.external_task.external_task import TaskResult, ExternalTask
+from operaton.external_task.external_task_worker import ExternalTaskWorker
+
+
+class ExternalTaskWorkerTest(TestCase):
+
+    @responses.activate
+    @patch('operaton.client.external_task_client.ExternalTaskClient.complete')
+    def test_fetch_and_execute_calls_task_action_for_each_task_fetched(self, _):
+        external_task_client = ExternalTaskClient(worker_id=0)
+        resp_payload = [{
+            "activityId": "anActivityId",
+            "activityInstanceId": "anActivityInstanceId",
+            "errorMessage": "anErrorMessage",
+            "errorDetails": "anErrorDetails",
+            "executionId": "anExecutionId",
+            "id": "anExternalTaskId",
+            "lockExpirationTime": "2015-10-06T16:34:42",
+            "processDefinitionId": "aProcessDefinitionId",
+            "processDefinitionKey": "aProcessDefinitionKey",
+            "processInstanceId": "aProcessInstanceId",
+            "tenantId": None,
+            "retries": 3,
+            "workerId": "aWorkerId",
+            "priority": 4,
+            "topicName": "createOrder",
+            "variables": {
+                "orderId": {
+                    "type": "String",
+                    "value": "1234",
+                    "valueInfo": {}
+                }
+            }
+        },
+            {
+                "activityId": "anActivityId",
+                "activityInstanceId": "anActivityInstanceId",
+                "errorMessage": "anErrorMessage",
+                "errorDetails": "anotherErrorDetails",
+                "executionId": "anExecutionId",
+                "id": "anExternalTaskId",
+                "lockExpirationTime": "2015-10-06T16:34:42",
+                "processDefinitionId": "aProcessDefinitionId",
+                "processDefinitionKey": "aProcessDefinitionKey",
+                "processInstanceId": "aProcessInstanceId",
+                "tenantId": None,
+                "retries": 3,
+                "workerId": "aWorkerId",
+                "priority": 0,
+                "topicName": "createOrder",
+                "variables": {
+                    "orderId": {
+                        "type": "String",
+                        "value": "3456",
+                        "valueInfo": {}
+                    }
+                }
+            }]
+        responses.add(responses.POST, external_task_client.get_fetch_and_lock_url(),
+                      status=HTTPStatus.OK, json=resp_payload)
+
+        worker = ExternalTaskWorker(worker_id=0)
+        mock_action = mock.Mock()
+        task = ExternalTask({"id": "anExternalTaskId", "workerId": "aWorkerId", "topicName": "createOrder"})
+        mock_action.return_value = TaskResult.success(task=task, global_variables={})
+
+        worker.fetch_and_execute("my_topic", mock_action)
+        self.assertEqual(2, mock_action.call_count)
+
+    @responses.activate
+    def test_fetch_and_execute_raises_exception_if_task_action_raises_exception(self):
+        external_task_client = ExternalTaskClient(worker_id=0)
+        resp_payload = [{
+            "activityId": "anActivityId",
+            "activityInstanceId": "anActivityInstanceId",
+            "errorMessage": "anErrorMessage",
+            "errorDetails": "anErrorDetails",
+            "executionId": "anExecutionId",
+            "id": "anExternalTaskId",
+            "lockExpirationTime": "2015-10-06T16:34:42",
+            "processDefinitionId": "aProcessDefinitionId",
+            "processDefinitionKey": "aProcessDefinitionKey",
+            "processInstanceId": "aProcessInstanceId",
+            "tenantId": None,
+            "retries": 3,
+            "workerId": "aWorkerId",
+            "priority": 4,
+            "topicName": "createOrder",
+            "variables": {
+                "orderId": {
+                    "type": "String",
+                    "value": "1234",
+                    "valueInfo": {}
+                }
+            }
+        }]
+        responses.add(responses.POST, external_task_client.get_fetch_and_lock_url(),
+                      status=HTTPStatus.OK, json=resp_payload)
+
+        worker = ExternalTaskWorker(worker_id=0)
+        mock_action = mock.Mock()
+        mock_action.side_effect = Exception("error executing task action")
+
+        with self.assertRaises(Exception) as exception_ctx:
+            worker.fetch_and_execute("my_topic", mock_action)
+
+        self.assertEqual("error executing task action", str(exception_ctx.exception))
+
+    @responses.activate
+    def test_fetch_and_execute_raises_exception_if_no_tasks_found(self):
+        external_task_client = ExternalTaskClient(worker_id=0)
+        resp_payload = []
+        responses.add(responses.POST, external_task_client.get_fetch_and_lock_url(),
+                      status=HTTPStatus.OK, json=resp_payload)
+
+        worker = ExternalTaskWorker(worker_id=0)
+        mock_action = mock.Mock()
+        process_variables = {"var1": "value1", "var2": "value2"}
+        with self.assertRaises(Exception) as context:
+            worker.fetch_and_execute("my_topic", mock_action, process_variables)
+
+        self.assertEqual(f"no External Task found for Topics: my_topic, Process variables: {process_variables}",
+                         str(context.exception))
+
+    @responses.activate
+    @patch('time.sleep', return_value=None)
+    def test_fetch_and_execute_safe_raises_exception_sleep_is_called(self, mock_time_sleep):
+        external_task_client = ExternalTaskClient(worker_id=0)
+        responses.add(responses.POST, external_task_client.get_fetch_and_lock_url(),
+                      status=HTTPStatus.INTERNAL_SERVER_ERROR)
+
+        sleep_seconds = 100
+        worker = ExternalTaskWorker(worker_id=0, config={"sleepSeconds": sleep_seconds})
+        mock_action = mock.Mock()
+
+        worker._fetch_and_execute_safe("my_topic", mock_action)
+
+        self.assertEqual(0, mock_action.call_count)
+        self.assertEqual(1, mock_time_sleep.call_count)
+        mock_time_sleep.assert_called_with(sleep_seconds)

operaton/process_definition/process_definition_client.py

@@ -0,0 +1,123 @@
+import logging
+
+import requests
+
+from operaton.client.engine_client import EngineClient, ENGINE_LOCAL_BASE_URL
+from operaton.utils.response_utils import raise_exception_if_not_ok
+from operaton.utils.utils import join
+from operaton.variables.variables import Variables
+
+logger = logging.getLogger(__name__)
+
+
+class ProcessDefinitionClient(EngineClient):
+    def __init__(self, engine_base_url=ENGINE_LOCAL_BASE_URL, config=None):
+        super().__init__(engine_base_url, config=config)
+
+    def get_process_definitions(
+        self,
+        process_key,
+        version_tag,
+        tenant_ids,
+        sort_by="version",
+        sort_order="desc",
+        offset=0,
+        limit=1,
+    ):
+        url = self.get_process_definitions_url()
+        url_params = self.get_process_definitions_url_params(
+            process_key, version_tag, tenant_ids, sort_by, sort_order, offset, limit
+        )
+        response = requests.get(url, headers=self._get_headers(), params=url_params)
+        raise_exception_if_not_ok(response)
+        return response.json()
+
+    def get_process_definitions_url(self):
+        return f"{self.engine_base_url}/process-definition"
+
+    def get_process_definitions_url_params(
+        self,
+        process_key,
+        version_tag=None,
+        tenant_ids=None,
+        sort_by="version",
+        sort_order="desc",
+        offset=0,
+        limit=1,
+    ):
+        """
+        offset starts with zero
+        sort_order can be "asc" or "desc
+        """
+        url_params = {
+            "key": process_key,
+            "versionTagLike": f"{version_tag}%" if version_tag else None,
+            "tenantIdIn": join(tenant_ids, ","),
+            "sortBy": sort_by,
+            "sortOrder": sort_order,
+            "firstResult": offset,
+            "maxResults": limit,
+        }
+
+        url_params = {k: v for k, v in url_params.items() if v is not None and v != ""}
+
+        return url_params
+
+    def start_process_by_version(
+        self, process_key, version_tag, variables, tenant_id=None, business_key=None
+    ):
+        """
+        Start a process instance with the process_key and specified version tag and variables passed.
+        If multiple versions with same version tag found, it triggers the latest one
+        :param process_key: Mandatory
+        :param version_tag:
+        :param variables: Mandatory - can be empty dict
+        :param tenant_id: Optional
+        :param business_key: Optional
+        :return: response json
+        """
+        tenant_ids = [tenant_id] if tenant_id else []
+        process_definitions = self.get_process_definitions(
+            process_key,
+            version_tag,
+            tenant_ids,
+            sort_by="version",
+            sort_order="desc",
+            offset=0,
+            limit=1,
+        )
+
+        if len(process_definitions) == 0:
+            raise Exception(
+                f"cannot start process because no process definitions found "
+                f"for process_key: {process_key}, version_tag: {version_tag} and tenant_id: {tenant_id}"
+            )
+
+        process_definition_id = process_definitions[0]["id"]
+        version = process_definitions[0]["version"]
+        if len(process_definitions) > 1:
+            logger.info(
+                f"multiple process definitions found for process_key: {process_key}, "
+                f"version_tag: {version_tag} and tenant_id: {tenant_id}, "
+                f"using latest process_definition_id: {process_definition_id} with version: {version}"
+            )
+        else:
+            logger.info(
+                f"exactly one process definition found for process_key: {process_key}, "
+                f"version_tag: {version_tag} and tenant_id: {tenant_id}, "
+                f"using process_definition_id: {process_definition_id} with version: {version}"
+            )
+
+        url = self.get_start_process_url(process_definition_id)
+        body = {"variables": Variables.format(variables)}
+        if business_key:
+            body["businessKey"] = business_key
+
+        response = requests.post(url, headers=self._get_headers(), json=body)
+        raise_exception_if_not_ok(response)
+        return response.json()
+
+    def get_start_process_url(self, process_definition_id):
+        return (
+            f"{self.engine_base_url}/process-definition/{process_definition_id}/start"
+        )