dex-python-sdk 0.0.1__py3-none-any.whl

dex/tests/test_skip_wait_until.py

@@ -0,0 +1,85 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import 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,33 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import 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,40 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import 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,58 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import 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,92 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import 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)

dex/tests/test_workflow_state_options.py

@@ -0,0 +1,123 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.dex_api.models import IDReusePolicy
+from dex.dex_api.models import (
+    PersistenceLoadingPolicy,
+    PersistenceLoadingType,
+    WorkflowStateOptions as IdlWorkflowStateOptions,
+    RetryPolicy,
+    WaitUntilApiFailurePolicy,
+)
+from dex.tests.worker_server import registry
+from dex.tests.workflows.state_options_workflow import (
+    StateOptionsWorkflow1,
+    StateOptionsWorkflow2,
+)
+from dex.workflow_options import WorkflowOptions
+from dex.workflow_state_options import WorkflowStateOptions, _to_idl_state_options
+from ..errors import WorkflowFailed
+
+
+class TestWorkflowStateOptions(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_convert_to_idl(self):
+        empty_idl = IdlWorkflowStateOptions()
+        assert empty_idl == _to_idl_state_options(False, None, {})
+
+        non_empty = WorkflowStateOptions(
+            "state-id",
+            search_attributes_loading_policy=PersistenceLoadingPolicy(
+                persistence_loading_type=PersistenceLoadingType.LOAD_ALL_WITHOUT_LOCKING
+            ),
+        )
+        non_empty_idl = IdlWorkflowStateOptions(
+            skip_wait_until=True,
+            search_attributes_loading_policy=PersistenceLoadingPolicy(
+                persistence_loading_type=PersistenceLoadingType.LOAD_ALL_WITHOUT_LOCKING
+            ),
+        )
+        assert non_empty_idl == _to_idl_state_options(True, non_empty, {})
+        non_empty.state_id = "state-id-2"
+        assert non_empty.state_id == "state-id-2"
+
+    """Test that proceed_to_execute_when_wait_until_retry_exhausted correctly handles both enum values."""
+
+    def test_proceed_to_execute_when_wait_until_retry_exhausted(self):
+        retry_policy = RetryPolicy(maximum_attempts=1)
+
+        # Test PROCEED_ON_FAILURE
+        options_proceed = WorkflowStateOptions(
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE,
+            wait_until_api_retry_policy=retry_policy,
+        )
+        result_proceed = _to_idl_state_options(False, options_proceed, {})
+        assert (
+            result_proceed.wait_until_api_failure_policy
+            == WaitUntilApiFailurePolicy.PROCEED_ON_FAILURE
+        )
+
+        # Test FAIL_WORKFLOW_ON_FAILURE
+        options_fail = WorkflowStateOptions(
+            proceed_to_execute_when_wait_until_retry_exhausted=WaitUntilApiFailurePolicy.FAIL_WORKFLOW_ON_FAILURE,
+            wait_until_api_retry_policy=retry_policy,
+        )
+        result_fail = _to_idl_state_options(False, options_fail, {})
+        assert (
+            result_fail.wait_until_api_failure_policy
+            == WaitUntilApiFailurePolicy.FAIL_WORKFLOW_ON_FAILURE
+        )
+
+        # Test with None/unset value
+        options = WorkflowStateOptions()
+        result = _to_idl_state_options(False, options, {})
+        # By default, wait_until_api_failure_policy should not be set when proceed_to_execute_when_wait_until_retry_exhausted is None
+        # The DEX service will use FAIL_WORKFLOW_ON_FAILURE by default
+        from dex.dex_api.types import Unset
+
+        self.assertTrue(isinstance(result.wait_until_api_failure_policy, Unset))
+
+    def test_proceed_on_failure(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(
+            StateOptionsWorkflow1,
+            wf_id,
+            10,
+            "input",
+            WorkflowOptions(workflow_id_reuse_policy=IDReusePolicy.DISALLOW_REUSE),
+        )
+        output = self.client.wait_for_workflow_completion(wf_id)
+
+        assert output == "InitState1_execute_completed"
+
+    def test_fail_workflow_on_failure(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(
+            StateOptionsWorkflow2,
+            wf_id,
+            10,
+            "input",
+            WorkflowOptions(workflow_id_reuse_policy=IDReusePolicy.DISALLOW_REUSE),
+        )
+
+        with self.assertRaises(WorkflowFailed):
+            self.client.wait_for_workflow_completion(wf_id, str)

dex/tests/test_workflow_state_options_override.py

@@ -0,0 +1,49 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.workflow_options import WorkflowOptions
+
+from dex.dex_api.models import IDReusePolicy
+from dex.tests.worker_server import registry
+
+from dex.tests.workflows.state_options_override_workflow import (
+    StateOptionsOverrideWorkflow,
+)
+
+
+class TestStateOptionsOverrideWorkflow(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_override(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        self.client.start_workflow(
+            StateOptionsOverrideWorkflow,
+            wf_id,
+            10,
+            "input",
+            WorkflowOptions(workflow_id_reuse_policy=IDReusePolicy.DISALLOW_REUSE),
+        )
+        output = self.client.wait_for_workflow_completion(wf_id)
+
+        assert (
+            output
+            == "input_InitState_waitUntil_completed_InitState_execute_completed_NonInitState_execute_completed"
+        )

dex/tests/worker_server.py

@@ -0,0 +1,74 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# 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 threading import Thread
+
+from flask import Flask, request
+
+from dex.dex_api.models import (
+    WorkflowStateExecuteRequest,
+    WorkflowStateWaitUntilRequest,
+    WorkflowWorkerRpcRequest,
+)
+from dex.tests import registry
+from dex.worker_service import (
+    WorkerService,
+)
+
+# NOTE: set this to true when debugging(using breakpoints)
+# so that it keep the thread running so that we can see the error in history
+debug_mode: bool = False
+
+_flask_app = Flask(__name__)
+
+_worker_service = WorkerService(registry)
+
+
+@_flask_app.route("/")
+def index():
+    return "hello"
+
+
+@_flask_app.route(WorkerService.api_path_workflow_state_wait_until, methods=["POST"])
+def handle_wait_until():
+    req = WorkflowStateWaitUntilRequest.from_dict(request.json)
+    resp = _worker_service.handle_workflow_state_wait_until(req)
+    return resp.to_dict()
+
+
+@_flask_app.route(WorkerService.api_path_workflow_state_execute, methods=["POST"])
+def handle_execute():
+    req = WorkflowStateExecuteRequest.from_dict(request.json)
+    resp = _worker_service.handle_workflow_state_execute(req)
+    return resp.to_dict()
+
+
+@_flask_app.route(WorkerService.api_path_workflow_worker_rpc, methods=["POST"])
+def handle_rpc():
+    req = WorkflowWorkerRpcRequest.from_dict(request.json)
+    resp = _worker_service.handle_workflow_worker_rpc(req)
+    return resp.to_dict()
+
+
+# this handler is extremely useful for debugging Dex
+# the WebUI will be able to show you the error with stacktrace
+@_flask_app.errorhandler(Exception)
+def internal_error(exception):
+    return _worker_service.handle_worker_error(exception), 500
+
+
+_webApp = Thread(target=_flask_app.run, args=("0.0.0.0", 8802))
+# when debugging, keep the thread running so that we can see the error in history
+_webApp.setDaemon(not debug_mode)
+_webApp.start()

dex/tests/workflows/abnormal_exit_workflow.py

@@ -0,0 +1,48 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# 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 typing import Union
+
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.dex_api.models import RetryPolicy
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+from dex.workflow_state_options import WorkflowStateOptions
+
+
+class AbnormalExitState1(WorkflowState[Union[int, str]]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        raise RuntimeError("abnormal exit state")
+
+    def get_state_options(self) -> WorkflowStateOptions:
+        return WorkflowStateOptions(
+            execute_api_retry_policy=RetryPolicy(maximum_attempts=1)
+        )
+
+
+class AbnormalExitWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(AbnormalExitState1())

dex/tests/workflows/basic_workflow.py

@@ -0,0 +1,69 @@
+# Copyright (c) 2022-2026 Super Durable, Inc.
+#
+# 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 typing import Union
+
+from dex.command_request import CommandRequest, TimerCommand
+from dex.command_results import CommandResults
+from dex.communication import Communication
+from dex.persistence import Persistence
+from dex.state_decision import StateDecision
+from dex.state_schema import StateSchema
+from dex.workflow import ObjectWorkflow
+from dex.workflow_context import WorkflowContext
+from dex.workflow_state import T, WorkflowState
+
+
+class State1(WorkflowState[Union[int, str]]):
+    def wait_until(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> CommandRequest:
+        if input != "input":
+            raise RuntimeError("input is incorrect")
+        return CommandRequest.for_all_command_completed(
+            TimerCommand.by_seconds(1),
+        )
+
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        if input != "input":
+            raise RuntimeError("input is incorrect")
+        return StateDecision.single_next_state(State2)
+
+
+class State2(WorkflowState[None]):
+    def execute(
+        self,
+        ctx: WorkflowContext,
+        input: T,
+        command_results: CommandResults,
+        persistence: Persistence,
+        communication: Communication,
+    ) -> StateDecision:
+        return StateDecision.graceful_complete_workflow("done")
+
+
+class BasicWorkflow(ObjectWorkflow):
+    def get_workflow_states(self) -> StateSchema:
+        return StateSchema.with_starting_state(State1(), State2())