dex-python-sdk 0.0.2__cp311-abi3-win_amd64.whl

dex/tests/test_rpc_with_memo.py

@@ -0,0 +1,195 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.dex_api.models.workflow_stop_type import WorkflowStopType
+from dex.stop_workflow_options import StopWorkflowOptions
+from dex.tests import registry
+from dex.tests.workflows.rpc_memo_workflow import (
+    RpcMemoWorkflow,
+    TEST_DATA_OBJECT_KEY,
+    TEST_SEARCH_ATTRIBUTE_INT,
+    TEST_SEARCH_ATTRIBUTE_KEY,
+    RPC_INPUT,
+    RPC_OUTPUT,
+    TEST_STR,
+    TEST_DELAY,
+)
+
+class TestRpcWithMemo(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_rpc_memo_workflow_func1(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        run_id = self.client.start_workflow(RpcMemoWorkflow, wf_id, 30, 999)
+
+        self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_set_data_attribute, TEST_STR
+        )
+        value = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_get_data_attribute_strong_consistency
+        )
+        assert value == TEST_STR
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_get_data_attribute, None, str
+        )
+
+        self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_set_data_attribute, None)
+        value = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_get_data_attribute_strong_consistency
+        )
+        assert value is None
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_get_data_attribute
+        )
+        assert value is None
+
+        self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_set_keyword, TEST_STR)
+        value = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_get_keyword_strong_consistency
+        )
+        assert value == TEST_STR
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_get_keyword)
+        assert value == TEST_STR
+
+        self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_set_keyword, None)
+        value = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_get_keyword_strong_consistency
+        )
+        assert value is None
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_get_keyword)
+        assert value is None
+
+        rpc_output = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_func1, RPC_INPUT
+        )
+        assert RPC_OUTPUT == rpc_output
+
+        self.client.wait_for_workflow_completion(wf_id)
+
+        data_attributes = self.client.get_workflow_data_attributes(
+            RpcMemoWorkflow, wf_id, run_id, [TEST_DATA_OBJECT_KEY]
+        )
+        assert TEST_DATA_OBJECT_KEY in data_attributes
+        assert data_attributes[TEST_DATA_OBJECT_KEY] == RPC_INPUT
+
+        search_attributes = self.client.get_workflow_search_attributes(
+            RpcMemoWorkflow,
+            wf_id,
+            [TEST_SEARCH_ATTRIBUTE_KEY, TEST_SEARCH_ATTRIBUTE_INT],
+            run_id,
+        )
+        assert TEST_SEARCH_ATTRIBUTE_INT in search_attributes
+        assert TEST_SEARCH_ATTRIBUTE_KEY in search_attributes
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_INT] == RPC_OUTPUT
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_KEY] == RPC_INPUT
+
+    def test_rpc_memo_workflow_func0(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        run_id = self.client.start_workflow(RpcMemoWorkflow, wf_id, 30, 999)
+
+        rpc_output = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_func0, TEST_STR
+        )
+        assert RPC_OUTPUT == rpc_output
+
+        self.client.wait_for_workflow_completion(wf_id)
+
+        data_attributes = self.client.get_workflow_data_attributes(
+            RpcMemoWorkflow, wf_id, run_id, [TEST_DATA_OBJECT_KEY]
+        )
+        assert TEST_DATA_OBJECT_KEY in data_attributes
+        assert data_attributes[TEST_DATA_OBJECT_KEY] == TEST_STR
+
+        search_attributes = self.client.get_workflow_search_attributes(
+            RpcMemoWorkflow,
+            wf_id,
+            [TEST_SEARCH_ATTRIBUTE_KEY, TEST_SEARCH_ATTRIBUTE_INT],
+            run_id,
+        )
+        assert TEST_SEARCH_ATTRIBUTE_INT in search_attributes
+        assert TEST_SEARCH_ATTRIBUTE_KEY in search_attributes
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_INT] == RPC_OUTPUT
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_KEY] == TEST_STR
+
+    def test_rpc_memo_workflow_proc1(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        run_id = self.client.start_workflow(RpcMemoWorkflow, wf_id, 30, 999)
+
+        self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_proc1, RPC_INPUT)
+        self.client.wait_for_workflow_completion(wf_id)
+
+        data_attributes = self.client.get_workflow_data_attributes(
+            RpcMemoWorkflow, wf_id, run_id, [TEST_DATA_OBJECT_KEY]
+        )
+        assert TEST_DATA_OBJECT_KEY in data_attributes
+        assert data_attributes[TEST_DATA_OBJECT_KEY] == RPC_INPUT
+
+        search_attributes = self.client.get_workflow_search_attributes(
+            RpcMemoWorkflow,
+            wf_id,
+            [TEST_SEARCH_ATTRIBUTE_KEY, TEST_SEARCH_ATTRIBUTE_INT],
+            run_id,
+        )
+        assert TEST_SEARCH_ATTRIBUTE_INT in search_attributes
+        assert TEST_SEARCH_ATTRIBUTE_KEY in search_attributes
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_INT] == RPC_OUTPUT
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_KEY] == RPC_INPUT
+
+    def test_rpc_memo_workflow_proc0(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        run_id = self.client.start_workflow(RpcMemoWorkflow, wf_id, 30, 999)
+
+        self.client.invoke_rpc(wf_id, RpcMemoWorkflow.test_rpc_proc0)
+        self.client.wait_for_workflow_completion(wf_id)
+
+        data_attributes = self.client.get_workflow_data_attributes(
+            RpcMemoWorkflow, wf_id, run_id, [TEST_DATA_OBJECT_KEY]
+        )
+        assert TEST_DATA_OBJECT_KEY in data_attributes
+        assert data_attributes[TEST_DATA_OBJECT_KEY] == TEST_STR
+
+        search_attributes = self.client.get_workflow_search_attributes(
+            RpcMemoWorkflow,
+            wf_id,
+            [TEST_SEARCH_ATTRIBUTE_KEY, TEST_SEARCH_ATTRIBUTE_INT],
+            run_id,
+        )
+        assert TEST_SEARCH_ATTRIBUTE_INT in search_attributes
+        assert TEST_SEARCH_ATTRIBUTE_KEY in search_attributes
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_INT] == RPC_OUTPUT
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_KEY] == TEST_STR
+
+    def test_rpc_memo_workflow_func1_readonly(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(RpcMemoWorkflow, wf_id, 30, 999)
+
+        rpc_output = self.client.invoke_rpc(
+            wf_id, RpcMemoWorkflow.test_rpc_func1_readonly, RPC_INPUT
+        )
+        assert RPC_OUTPUT == rpc_output
+
+        self.client.stop_workflow(
+            wf_id,
+            StopWorkflowOptions(
+                workflow_stop_type=WorkflowStopType.FAIL,
+                reason=TEST_STR,
+            ),
+        )

dex/tests/test_rpc_with_memo_duplicate_java_tests.py

@@ -0,0 +1,117 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.java_duplicate_rpc_memo_workflow import (
+    JavaDuplicateRpcMemoWorkflow,
+    RpcMemoWorkflowState2,
+    TEST_DATA_OBJECT_KEY,
+    TEST_SEARCH_ATTRIBUTE_INT,
+    TEST_SEARCH_ATTRIBUTE_KEY,
+    RPC_INPUT,
+    RPC_OUTPUT,
+    TEST_STR,
+    TEST_DELAY,
+)
+
+class TestRpcWithMemo(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_rpc_memo_workflow_func1(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        run_id = self.client.start_workflow(
+            JavaDuplicateRpcMemoWorkflow, wf_id, 30, 999
+        )
+
+        self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_set_data_attribute, TEST_STR
+        )
+        value = self.client.invoke_rpc(
+            wf_id,
+            JavaDuplicateRpcMemoWorkflow.test_rpc_get_data_attribute_strong_consistency,
+        )
+        assert value == TEST_STR
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_get_data_attribute, None, str
+        )
+
+        self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_set_data_attribute, None
+        )
+        value = self.client.invoke_rpc(
+            wf_id,
+            JavaDuplicateRpcMemoWorkflow.test_rpc_get_data_attribute_strong_consistency,
+        )
+        assert value is None
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_get_data_attribute
+        )
+        assert value is None
+
+        self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_set_keyword, TEST_STR
+        )
+        value = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_get_keyword_strong_consistency
+        )
+        assert value == TEST_STR
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_get_keyword
+        )
+        assert value == TEST_STR
+
+        self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_set_keyword, None
+        )
+        value = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_get_keyword_strong_consistency
+        )
+        assert value is None
+        time.sleep(TEST_DELAY)
+        value = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_get_keyword
+        )
+        assert value is None
+
+        rpc_output = self.client.invoke_rpc(
+            wf_id, JavaDuplicateRpcMemoWorkflow.test_rpc_func1, RPC_INPUT
+        )
+        assert RPC_OUTPUT == rpc_output
+
+        output = self.client.wait_for_workflow_completion(wf_id, int)
+        RpcMemoWorkflowState2.reset_counter()
+        assert 2 == output
+
+        data_attributes = self.client.get_workflow_data_attributes(
+            JavaDuplicateRpcMemoWorkflow, wf_id, run_id, [TEST_DATA_OBJECT_KEY]
+        )
+        assert TEST_DATA_OBJECT_KEY in data_attributes
+        assert data_attributes[TEST_DATA_OBJECT_KEY] == RPC_INPUT
+
+        search_attributes = self.client.get_workflow_search_attributes(
+            JavaDuplicateRpcMemoWorkflow,
+            wf_id,
+            [TEST_SEARCH_ATTRIBUTE_KEY, TEST_SEARCH_ATTRIBUTE_INT],
+            run_id,
+        )
+        assert TEST_SEARCH_ATTRIBUTE_INT in search_attributes
+        assert TEST_SEARCH_ATTRIBUTE_KEY in search_attributes
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_INT] == RPC_OUTPUT
+        assert search_attributes[TEST_SEARCH_ATTRIBUTE_KEY] == RPC_INPUT

dex/tests/test_signal.py

@@ -0,0 +1,51 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.wait_signal_workflow import (
+    WaitSignalWorkflow,
+    test_channel_int,
+    test_channel_str,
+    test_channel_none,
+    test_channel1,
+    test_idle_channel_none,
+)
+
+class TestSignal(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_signal(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(WaitSignalWorkflow, wf_id, 10)
+        self.client.signal_workflow(wf_id, test_channel_int, 123)
+        self.client.signal_workflow(wf_id, test_channel_str, "abc")
+        self.client.signal_workflow(wf_id, test_channel_none)
+
+        self.client.signal_workflow(wf_id, test_channel1)
+        res = self.client.wait_for_workflow_completion(wf_id, str)
+        assert res == "abc"
+
+    def test_signal_channel_size(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(WaitSignalWorkflow, wf_id, 1)
+        self.client.signal_workflow(wf_id, test_idle_channel_none)
+        self.client.signal_workflow(wf_id, test_idle_channel_none)
+        self.client.signal_workflow(wf_id, test_idle_channel_none)
+        res = self.client.invoke_rpc(
+            wf_id, WaitSignalWorkflow.get_idle_signal_channel_size
+        )
+        assert res == 3

dex/tests/test_skip_wait_until.py

@@ -0,0 +1,76 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import unittest
+
+from dex.command_request import CommandRequest
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState, should_skip_wait_until
+
+class DirectStateSkip(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        raise NotImplementedError
+
+class DirectStateNotSkip(WorkflowState[int]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        raise NotImplementedError
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: int,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        raise NotImplementedError
+
+class IndirectStateSkip(DirectStateSkip):
+    pass
+
+class IndirectStateNotSkip(DirectStateSkip):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        raise NotImplementedError
+
+class TestSkipWaitUntil(unittest.TestCase):
+    def test_should_skip_wait_until(self) -> None:
+        direct_skip = DirectStateSkip()
+        direct_not_skip = DirectStateNotSkip()
+        indirect_skip = IndirectStateSkip()
+        indirect_not_skip = IndirectStateNotSkip()
+
+        assert should_skip_wait_until(direct_skip)
+        assert should_skip_wait_until(indirect_skip)
+
+        assert not should_skip_wait_until(direct_not_skip)
+        assert not should_skip_wait_until(indirect_not_skip)

dex/tests/test_state_failure_recovery.py

@@ -0,0 +1,28 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.recovery_workflow import RecoveryWorkflow
+
+class Test(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_workflow_recovery(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(RecoveryWorkflow, wf_id, 10)
+        result = self.client.wait_for_workflow_completion(wf_id, str)
+        assert result == "done"

dex/tests/test_timer.py

@@ -0,0 +1,35 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.timer_workflow import TimerWorkflow, WaitState
+
+class TestTimer(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_timer(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(TimerWorkflow, wf_id, 100, 5)
+        time.sleep(1)
+        self.client.skip_timer_at_command_index(wf_id, WaitState)
+        start_ms = time.time_ns() / 1000000
+        self.client.wait_for_workflow_completion(wf_id, None)
+        elapsed_ms = time.time_ns() / 1000000 - start_ms
+        assert (
+            3000 <= elapsed_ms <= 6000
+        ), f"expected 5000 ms timer, actual is {elapsed_ms}"

dex/tests/test_wait_for_state_execution_completion.py

@@ -0,0 +1,53 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.tests.workflows.wait_for_state_with_wait_for_key_workflow import (
+    WaitForStateWithWaitForKeyWorkflow,
+    WaitForStateWithWaitForKeyState2,
+)
+from dex.workflow_options import WorkflowOptions
+
+class TestWaitForStateWithWaitForKey(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_wait_for_state_with_wait_for_key_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        wf_opts = WorkflowOptions()
+        wf_opts.add_wait_for_completion_state_ids(WaitForStateWithWaitForKeyState2)
+
+        self.client.start_workflow(
+            WaitForStateWithWaitForKeyWorkflow, wf_id, 100, None, wf_opts
+        )
+
+        self.client.wait_for_state_execution_completion_with_wait_for_key(
+            WaitForStateWithWaitForKeyState2, wf_id, "testKey"
+        )
+
+        self.client.wait_for_workflow_completion(wf_id)
+
+        # TODO: Improve this test by verifying both workflows completed with describe_workflow method
+        # https://github.com/superdurable/dex-python-sdk/issues/22
+        #
+        # child_wf_id =
+        #
+        # wf_info = self.client.describe_workflow(wf_id);
+        # assert wf_info.workflow_status == WorkflowStatus.COMPLETED
+        #
+        # child_wf_info = self.client.describe_workflow(child_wf_id);
+        # assert child_wf_info.workflow_status == WorkflowStatus.COMPLETED

dex/tests/test_workflow_errors.py

@@ -0,0 +1,87 @@
+# Legacy Materials in this file remain under their original licenses.
+# See LEGACY_NOTICES.md.
+
+# Modifications Copyright (c) 2026 Super Durable, Inc.
+#
+# Modifications after the Legacy Cutoff are licensed under the
+# Super Durable Source License 1.0.
+# Legacy Materials remain under their original licenses.
+# See LICENSE and LEGACY_NOTICES.md.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.errors import (
+    WorkflowAlreadyStartedError,
+    WorkflowCanceled,
+    WorkflowFailed,
+    WorkflowNotExistsError,
+    WorkflowStillRunningError,
+    WorkflowTerminated,
+    WorkflowTimeout,
+)
+from dex.dex_api.models import WorkflowStopType
+from dex.stop_workflow_options import StopWorkflowOptions
+from dex.tests.worker_server import registry
+from dex.tests.workflows.wait_internal_channel_workflow import (
+    WaitInternalChannelWorkflow,
+)
+
+class TestWorkflowErrors(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_workflow_timeout(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(WaitInternalChannelWorkflow, wf_id, 1)
+        with self.assertRaises(WorkflowTimeout):
+            self.client.wait_for_workflow_completion(wf_id, str)
+        with self.assertRaises(WorkflowNotExistsError):
+            self.client.wait_for_workflow_completion("invalid_id", str)
+
+    def test_workflow_still_running_when_wait(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        # client_options = ClientOptions.local_default()
+        # client_options.api_timeout = 5
+        # TODO using a shorter api timeout will throw a different timeout error, it's better to unify it
+        self.client.start_workflow(WaitInternalChannelWorkflow, wf_id, 61)
+
+        with self.assertRaises(WorkflowAlreadyStartedError):
+            self.client.start_workflow(WaitInternalChannelWorkflow, wf_id, 61)
+
+        with self.assertRaises(WorkflowStillRunningError):
+            self.client.wait_for_workflow_completion(wf_id, str)
+
+    def test_workflow_canceled(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(WaitInternalChannelWorkflow, wf_id, 10)
+        self.client.stop_workflow(wf_id)
+        with self.assertRaises(WorkflowCanceled):
+            self.client.wait_for_workflow_completion(wf_id, str)
+
+    def test_workflow_terminated(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(WaitInternalChannelWorkflow, wf_id, 10)
+        self.client.stop_workflow(
+            wf_id,
+            StopWorkflowOptions(
+                workflow_stop_type=WorkflowStopType.TERMINATE, reason="test"
+            ),
+        )
+        with self.assertRaises(WorkflowTerminated):
+            self.client.wait_for_workflow_completion(wf_id, str)
+
+    def test_workflow_failed(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(WaitInternalChannelWorkflow, wf_id, 10)
+        self.client.stop_workflow(
+            wf_id,
+            StopWorkflowOptions(
+                workflow_stop_type=WorkflowStopType.FAIL, reason="test"
+            ),
+        )
+        with self.assertRaises(WorkflowFailed):
+            self.client.wait_for_workflow_completion(wf_id, str)