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

operaton/process_definition/tests/test_process_definition_client.py

@@ -0,0 +1,181 @@
+from http import HTTPStatus
+from unittest import TestCase
+
+import responses
+
+from operaton.process_definition.process_definition_client import ProcessDefinitionClient
+
+
+class ProcessDefinitionClientTest(TestCase):
+
+    def setUp(self):
+        self.process_client = ProcessDefinitionClient()
+
+    def test_get_process_definitions_url_params_uses_non_none_params(self):
+        url_params = self.process_client.get_process_definitions_url_params(
+            process_key="PROCESS_KEY",
+            version_tag=None,
+            tenant_ids=None,
+            sort_by="version",
+            sort_order="desc"
+        )
+        self.assertDictEqual({
+            "key": 'PROCESS_KEY',
+            "sortBy": "version",
+            "sortOrder": "desc",
+            "firstResult": 0,
+            "maxResults": 1,
+        }, url_params)
+
+    def test_get_process_definitions_url_params_uses_all_specified_params(self):
+        url_params = self.process_client.get_process_definitions_url_params(
+            process_key="PROCESS_KEY",
+            version_tag='1.2.3',
+            tenant_ids=['tenant1'],
+            sort_by="version",
+            sort_order="asc"
+        )
+        self.assertDictEqual({
+            "key": "PROCESS_KEY",
+            "versionTagLike": "1.2.3%",
+            "tenantIdIn": "tenant1",
+            "sortBy": "version",
+            "sortOrder": "asc",
+            "firstResult": 0,
+            "maxResults": 1,
+        }, url_params)
+
+    @responses.activate
+    def test_start_process_by_version_raises_exception_if_no_process_definitions_found(self):
+        get_process_definitions_resp = []
+        responses.add(responses.GET, self.process_client.get_process_definitions_url(),
+                      status=HTTPStatus.OK, json=get_process_definitions_resp)
+
+        with self.assertRaises(Exception) as context:
+            self.process_client.start_process_by_version("ORIGINATION", "3.8.3", {}, "tenant1")
+
+        self.assertEqual(f"cannot start process because no process definitions found "
+                         f"for process_key: ORIGINATION, version_tag: 3.8.3 and tenant_id: tenant1",
+                         str(context.exception))
+
+    @responses.activate
+    def test_start_process_by_version_uses_first_process_definition_id_if_more_than_one_found(self):
+        get_process_definitions_resp = [
+            {
+                "id": "process_definition_id_2",
+                "key": "ORIGINATION",
+                "category": "http://bpmn.io/schema/bpmn",
+                "description": "- Removed unwanted external tasks",
+                "name": "Origination",
+                "version": 37,
+                "resource": "bpmn/origination.bpmn",
+                "deploymentId": "05f7527e-737e-11eb-ac5c-0a58a9feac2a",
+                "diagram": None,
+                "suspended": False,
+                "tenantId": "tenant1",
+                "versionTag": "3.8.3",
+                "historyTimeToLive": None,
+                "startableInTasklist": True
+            },
+            {
+                "id": "process_definition_id_1",
+                "key": "ORIGINATION",
+                "category": "http://bpmn.io/schema/bpmn",
+                "description": "- Added new external tasks",
+                "name": "Origination",
+                "version": 36,
+                "resource": "bpmn/origination.bpmn",
+                "deploymentId": "035d3c55-5f01-11eb-bcaf-0a58a9feac2a",
+                "diagram": None,
+                "suspended": False,
+                "tenantId": "tenant1",
+                "versionTag": "3.8.3",
+                "historyTimeToLive": None,
+                "startableInTasklist": True
+            },
+        ]
+        responses.add(responses.GET, self.process_client.get_process_definitions_url(),
+                      status=HTTPStatus.OK, json=get_process_definitions_resp)
+
+        start_process_resp = {
+            "links": [
+                {
+                    "method": "GET",
+                    "href": "http://localhost:8080/engine-rest/process-instance/e07b461a-80d0-11eb-83ea-0a58a9feac2a",
+                    "rel": "self"
+                }
+            ],
+            "id": "e07b461a-80d0-11eb-83ea-0a58a9feac2a",
+            "definitionId": "process_definition_id_2",
+            "businessKey": "businessKey",
+            "caseInstanceId": None,
+            "ended": False,
+            "suspended": False,
+            "tenantId": "tenant1",
+            "variables": {
+                "applicationId": {
+                    "type": "String",
+                    "value": "30ea7b40-283b-4526-8979-371f4ffc9ee0",
+                    "valueInfo": {}
+                }
+            }
+        }
+        responses.add(responses.POST, self.process_client.get_start_process_url('process_definition_id_2'),
+                      status=HTTPStatus.OK, json=start_process_resp)
+
+        resp_json = self.process_client.start_process_by_version("ORIGINATION", "3.8.3", {}, "tenant1")
+
+        self.assertDictEqual(start_process_resp, resp_json)
+
+    @responses.activate
+    def test_start_process_by_version_returns_process_details_if_started_successfully(self):
+        get_process_definitions_resp = [
+            {
+                "id": "process_definition_id",
+                "key": "ORIGINATION",
+                "category": "http://bpmn.io/schema/bpmn",
+                "description": "- Removed unwanted external tasks",
+                "name": "Origination",
+                "version": 37,
+                "resource": "bpmn/origination.bpmn",
+                "deploymentId": "05f7527e-737e-11eb-ac5c-0a58a9feac2a",
+                "diagram": None,
+                "suspended": False,
+                "tenantId": "tenant1",
+                "versionTag": "3.8.3",
+                "historyTimeToLive": None,
+                "startableInTasklist": True
+            }
+        ]
+        responses.add(responses.GET, self.process_client.get_process_definitions_url(),
+                      status=HTTPStatus.OK, json=get_process_definitions_resp)
+
+        start_process_resp = {
+            "links": [
+                {
+                    "method": "GET",
+                    "href": "http://localhost:8080/engine-rest/process-instance/e07b461a-80d0-11eb-83ea-0a58a9feac2a",
+                    "rel": "self"
+                }
+            ],
+            "id": "e07b461a-80d0-11eb-83ea-0a58a9feac2a",
+            "definitionId": "89337817-75c9-11eb-84bb-0a58a9feac2a",
+            "businessKey": "businessKey",
+            "caseInstanceId": None,
+            "ended": False,
+            "suspended": False,
+            "tenantId": "tenant1",
+            "variables": {
+                "applicationId": {
+                    "type": "String",
+                    "value": "30ea7b40-283b-4526-8979-371f4ffc9ee0",
+                    "valueInfo": {}
+                }
+            }
+        }
+        responses.add(responses.POST, self.process_client.get_start_process_url('process_definition_id'),
+                      status=HTTPStatus.OK, json=start_process_resp)
+
+        resp_json = self.process_client.start_process_by_version("ORIGINATION", "3.8.3", {}, "tenant1")
+
+        self.assertDictEqual(start_process_resp, resp_json)

operaton/utils/auth_basic.py

@@ -0,0 +1,28 @@
+import base64
+import copy
+from pydantic import BaseModel
+
+
+def obfuscate_password(config: dict) -> dict:
+    """Obfuscate password value in auth_basic config
+
+    :param config: config from ExternalTaskWorker or ExternalTaskClient
+    :returns: _config with obfuscated password
+    """
+    _config = copy.deepcopy(config)
+    _auth = _config.get('auth_basic')
+    if _auth is not None and 'password' in _auth.keys():
+        _auth['password'] = '***'
+    return _config
+
+class AuthBasic(BaseModel):
+    username: str
+    password: str
+    token: str = ""
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        token = f"{self.username}:{self.password}"
+        bytemsg = base64.b64encode(token.encode('utf-8'))
+        tokenb64 = str(bytemsg, "utf-8")
+        self.token = f"Basic {tokenb64}"

operaton/utils/auth_bearer.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Union
+
+from pydantic import BaseModel, validator
+
+
+class AuthBearer(BaseModel):
+    access_token: str
+
+    @validator('access_token', pre=True)
+    @classmethod
+    def get_token_from_dict(cls, value: Union[str, Dict[str, Any]]) -> str:
+        if isinstance(value, str):
+            return value
+        if not isinstance(value, dict):
+            raise ValueError('token should be dict or str')
+        if not value.get('access_token'):
+            raise KeyError(
+                'you should pass the token inside "access_token" key')
+        return value['access_token']
+
+    @validator('access_token')
+    @classmethod
+    def concat_bearer(cls, value: str) -> str:
+        if not any([
+            value.startswith('Bearer'),
+            value.startswith('bearer')
+        ]):
+            return f'Bearer {value}'

operaton/utils/log_utils.py

@@ -0,0 +1,31 @@
+import logging
+
+
+def log_with_context(message, context=None, log_level='info', **kwargs):
+    context = context if context is not None else {}
+    log_function = __get_log_function(log_level)
+
+    log_context_prefix = __get_log_context_prefix(context)
+    if log_context_prefix:
+        log_function(f"{log_context_prefix} {message}", **kwargs)
+    else:
+        log_function(message, **kwargs)
+
+
+def __get_log_context_prefix(context):
+    log_context_prefix = ""
+    if context:
+        for k, v in context.items():
+            if v is not None:
+                log_context_prefix += f"[{k}:{v}]"
+    return log_context_prefix
+
+
+def __get_log_function(log_level):
+    switcher = {
+        'debug': logging.debug,
+        'info': logging.info,
+        'warning': logging.warning,
+        'error': logging.error
+    }
+    return switcher.get(log_level, logging.info)

operaton/utils/response_utils.py

@@ -0,0 +1,35 @@
+def raise_exception_if_not_ok(response):
+    # Check if the response has the `ok` attribute
+    if hasattr(response, 'ok'):
+        if response.ok:
+            return
+    else:
+        # For httpx, treat status_code < 400 as "ok"
+        if response.status_code < 400:
+            return
+
+    resp_json = __get_json_or_raise_for_status(response)
+
+    raise Exception(get_response_error_message(response.status_code, resp_json))
+
+
+def __get_json_or_raise_for_status(response):
+    try:
+        return response.json()
+    except ValueError as e:
+        # if no json available in response then use raise_for_status() to raise exception
+        response.raise_for_status()
+
+
+def get_response_error_message(status_code, resp_json):
+    error_msg = f'received {status_code}'
+
+    err_type = resp_json.get('type', '')
+    message = resp_json.get('message', '')
+    if err_type:
+        error_msg += f" : {err_type}"
+
+    if message:
+        error_msg += f" : {message}"
+
+    return error_msg

operaton/utils/tests/test_auth_basic.py

@@ -0,0 +1,30 @@
+from unittest import TestCase
+
+from operaton.utils.auth_basic import AuthBasic, obfuscate_password
+
+
+class TestAuthBasic(TestCase):
+    def test_auth_basic(self):
+        auth_basic = AuthBasic(**{
+            "username": "test",
+            "password": "test",
+        })
+        self.assertEqual(auth_basic.token, 'Basic dGVzdDp0ZXN0')
+
+
+    def test_obfuscate_password(self):
+        default_config = {
+            "auth_basic": {"username": "demo", "password": "demo"},
+            "maxTasks": 1,
+            "lockDuration": 10000,
+            "asyncResponseTimeout": 0,
+            "isDebug": True,
+        }
+        obfuscate_config = {
+            "auth_basic": {"username": "demo", "password": "***"},
+            "maxTasks": 1,
+            "lockDuration": 10000,
+            "asyncResponseTimeout": 0,
+            "isDebug": True,
+        }
+        self.assertEqual(obfuscate_password(default_config), obfuscate_config)

operaton/utils/tests/test_auth_bearer.py

@@ -0,0 +1,27 @@
+from unittest import TestCase
+
+from operaton.utils.auth_bearer import AuthBearer
+
+
+class TestAuthBasic(TestCase):
+    """Can you generate a bearer token using jwt lib.
+
+    reffer - https://pyjwt.readthedocs.io/en/stable/
+    """
+    def test_str_token_bearer(self):
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        auth_bearer = AuthBearer(access_token=token)
+        self.assertEqual(auth_bearer.access_token, f'Bearer {token}')
+
+    def test_dict_token_bearer(self):
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        auth_bearer = AuthBearer(access_token={'access_token': token})
+        self.assertEqual(auth_bearer.access_token, f'Bearer {token}')
+
+    def test_error_dict_token_bearer(self):
+        token = ('eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiJkZW1vIn0'
+                 '.NbMsjy8QQ5nrjGTXqdTrJ6g0dqawRvZAqp4XvNt437M')
+        with self.assertRaises(KeyError):
+            AuthBearer(access_token={'token': token})

operaton/utils/tests/test_response_utils.py

@@ -0,0 +1,43 @@
+from http import HTTPStatus
+from unittest import TestCase
+
+import requests
+
+from operaton.utils.response_utils import raise_exception_if_not_ok, get_response_error_message
+
+
+class TestRaiseExceptionIfResponseNotOk(TestCase):
+
+    def test_does_not_raise_exception_if_response_is_ok(self):
+        try:
+            raise_exception_if_not_ok(self.__mock_response(HTTPStatus.OK, {}))
+        except Exception:
+            self.fail("raise_exception_if_not_ok() should not raise Exception when response is ok")
+
+    def test_raise_exception_if_response_is_not_ok(self):
+        data = {'type': "SomeExceptionClass", "message": "a detailed message"}
+        with self.assertRaises(Exception) as context:
+            raise_exception_if_not_ok(self.__mock_response(HTTPStatus.BAD_REQUEST, data))
+
+        self.assertEqual("received 400 : SomeExceptionClass : a detailed message", str(context.exception))
+
+    def __mock_response(self, status_code, data):
+        response = requests.Response()
+        response.status_code = status_code
+        response.json = lambda: data
+        return response
+
+    def test_get_response_error_message_no_error_type_no_message(self):
+        data = {}
+        error_msg = get_response_error_message(HTTPStatus.BAD_REQUEST, data)
+        self.assertEqual("received 400", error_msg)
+
+    def test_get_response_error_message_only_type_no_msg(self):
+        data = {'type': "InvalidRequestType", "message": ""}
+        error_msg = get_response_error_message(HTTPStatus.BAD_REQUEST, data)
+        self.assertEqual("received 400 : InvalidRequestType", error_msg)
+
+    def test_get_response_error_message_only_msg_no_type(self):
+        data = {"message": "a detailed message"}
+        error_msg = get_response_error_message(HTTPStatus.BAD_REQUEST, data)
+        self.assertEqual("received 400 : a detailed message", error_msg)

operaton/utils/tests/test_utils.py

@@ -0,0 +1,21 @@
+from unittest import TestCase
+
+from operaton.utils.utils import str_to_list, join
+
+
+class TestUtils(TestCase):
+    def test_str_to_list_returns_list_as_is(self):
+        self.assertEqual([], str_to_list([]))
+        self.assertEqual([1, 2, 3], str_to_list([1, 2, 3]))
+        self.assertEqual(["a", "b", "c"], str_to_list(["a", "b", "c"]))
+
+    def test_str_to_list_returns_list_with_string_passed(self):
+        self.assertEqual(["hello"], str_to_list("hello"))
+
+    def test_join_empty_list(self):
+        self.assertEqual("", join(None, ','))
+        self.assertEqual("", join([], ','))
+
+    def test_join_non_empty_list(self):
+        self.assertEqual("1", join([1], ','))
+        self.assertEqual("1,2,3", join([1, 2, 3], ','))

operaton/utils/utils.py

@@ -0,0 +1,14 @@
+def str_to_list(values):
+    if isinstance(values, str):
+        return [values]
+    return values
+
+
+def get_exception_detail(exception):
+    return f"{type(exception)} : {str(exception)}"
+
+
+def join(list_of_values, separator):
+    if list_of_values:
+        return separator.join(str(v) for v in list_of_values)
+    return ''

operaton/variables/properties.py

@@ -0,0 +1,27 @@
+class Properties:
+    """
+    Properties are key->value pairs which acts as a kind of constant in Camunda.
+    A property can be set via Camunda Modeller's Properties Panel on the Extension tab.
+
+    Properties appear in a ExternalTask as soon as the config for an ExternalTaskClient will
+    have a configuration includeExtensionProperties: True (which is the default)
+
+    Properties will store strings only.
+    """
+    def __init__(self, properties={}):
+        self.properties = properties
+
+    def get_property(self, property_name) -> str:
+        """
+        access a single property
+        """
+        return self.properties.get(property_name, None)
+
+    def to_dict(self) -> dict:
+        """
+        Converts the properties to a simple dictionary
+        """
+        result = {}
+        for k, v in self.properties.items():
+            result[k] = v
+        return result

operaton/variables/tests/test_properties.py

@@ -0,0 +1,20 @@
+from unittest import TestCase
+
+from operaton.variables.properties import Properties
+
+
+class PropertiesTest(TestCase):
+
+    def test_get_variable_returns_none_when_variable_absent(self):
+        properties = Properties({})
+        self.assertIsNone(properties.get_property("var1"))
+
+    def test_get_variable_returns_value_when_variable_present(self):
+        properties = Properties({"var1": "one"})
+        self.assertEqual("one", properties.get_property("var1"))
+
+    def test_to_dict_returns_variables_as_dict(self):
+        properties = Properties({"var1": "Sample1",
+                                 "var2": "Sample2",
+                                 "var3": "Sample3"})
+        self.assertDictEqual({"var1": "Sample1", "var2": "Sample2", "var3": "Sample3"}, properties.to_dict())

operaton/variables/tests/test_variables.py

@@ -0,0 +1,60 @@
+from unittest import TestCase
+
+from operaton.variables.variables import Variables
+
+
+class VariablesTest(TestCase):
+
+    def test_get_variable_returns_none_when_variable_absent(self):
+        variables = Variables({})
+        self.assertIsNone(variables.get_variable("var1"))
+
+    def test_get_variable_returns_value_when_variable_present(self):
+        variables = Variables({"var1": {"value": 1}})
+        self.assertEqual(1, variables.get_variable("var1"))
+
+    def test_get_variable_returns_with_meta(self):
+        var1_raw = {"value": 1}
+        variables = Variables({"var1": var1_raw})
+        self.assertEqual(var1_raw, variables.get_variable("var1", True))
+
+    def test_get_variable_returns_without_meta(self):
+        var1_raw = {"value": 1}
+        variables = Variables({"var1": var1_raw})
+        self.assertEqual(1, variables.get_variable("var1", False))
+
+    def test_format_returns_empty_dict_when_none_is_passed(self):
+        variables = None
+        self.assertDictEqual({}, Variables.format(variables))
+
+    def test_format_returns_empty_dict_when_variables_absent(self):
+        variables = {}
+        self.assertDictEqual({}, Variables.format(variables))
+
+    def test_format_returns_dict_with_value_when_nested_dict(self):
+        var1_raw = {"var2": 1, "var3": "test"}
+        variables = {"var1": var1_raw}
+        self.assertDictEqual({"var1": {"value": var1_raw}}, Variables.format(variables))
+
+    def test_format_returns_formatted_variables_when_variables_present(self):
+        variables = {"var1": 1, "var2": True, "var3": "string"}
+        formatted_vars = Variables.format(variables)
+        self.assertDictEqual({"var1": {"value": 1},
+                              "var2": {"value": True},
+                              "var3": {"value": "string"}}, formatted_vars)
+
+    def test_format_returns_formatted_variables_keeps_already_formatted(self):
+        variables = {"var1": 1, "var2": True, "var3": "string", "var4": {"value": 1}}
+        formatted_vars = Variables.format(variables)
+        self.assertDictEqual({"var1": {"value": 1},
+                              "var2": {"value": True},
+                              "var3": {"value": "string"},
+                              "var4": {"value": 1}}, formatted_vars)
+
+    def test_to_dict_returns_variables_as_dict(self):
+        variables = Variables({"var1": {"value": 1},
+                               "var2": {"value": True},
+                               "var3": {"value": "string"}})
+        self.assertDictEqual({"var1": 1, "var2": True, "var3": "string"}, variables.to_dict())
+
+

operaton/variables/variables.py

@@ -0,0 +1,45 @@
+
+import json
+
+class Variables:
+    def __init__(self, variables={}):
+        self.variables = variables
+
+    def get_variable(self, variable_name, with_meta=False):
+        variable = self.variables.get(variable_name, None)
+        if not variable:
+            return None
+        if with_meta:
+            return variable
+        return variable["value"]
+
+    @classmethod
+    def format(cls, variables):
+        """
+        Gives the correct format to variables.
+        :param variables: dict - Dictionary of variable names to values.
+        :return: Dictionary of well formed variables
+            {"var1": 1, "var2": True}
+            ->
+            {"var1": {"value": 1}, "var2": {"value": True}}
+        """
+        formatted_vars = {}
+        if variables:
+            formatted_vars = {
+                k: v if (isinstance(v, dict) and "value" in v.keys()) else {"value": v}
+                for k, v in variables.items()
+            }
+        return formatted_vars
+
+    def to_dict(self):
+        """
+        Converts the variables to a simple dictionary
+        :return: dict
+            {"var1": {"value": 1}, "var2": {"value": True}}
+            ->
+            {"var1": 1, "var2": True}
+        """
+        result = {}
+        for k, v in self.variables.items():
+            result[k] = v["value"]
+        return result