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

dex/tests/__init__.py

@@ -0,0 +1,84 @@
+# 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 dex.registry import Registry
+from dex.tests.workflows.abnormal_exit_workflow import AbnormalExitWorkflow
+from dex.tests.workflows.basic_workflow import BasicWorkflow
+from dex.tests.workflows.conditional_complete_workflow import (
+    ConditionalCompleteWorkflow,
+)
+from dex.tests.workflows.describe_workflow import DescribeWorkflow
+from dex.tests.workflows.empty_data_workflow import EmptyDataWorkflow
+from dex.tests.workflows.internal_channel_workflow import InternalChannelWorkflow
+from dex.tests.workflows.internal_channel_workflow_with_no_prefix_channel import (
+    InternalChannelWorkflowWithNoPrefixChannel,
+)
+from dex.tests.workflows.java_duplicate_rpc_memo_workflow import (
+    JavaDuplicateRpcMemoWorkflow,
+)
+from dex.tests.workflows.persistence_data_attributes_workflow import (
+    PersistenceDataAttributesWorkflow,
+)
+from dex.tests.workflows.persistence_search_attributes_workflow import (
+    PersistenceSearchAttributesWorkflow,
+)
+from dex.tests.workflows.persistence_state_execution_local_workflow import (
+    PersistenceStateExecutionLocalWorkflow,
+)
+from dex.tests.workflows.recovery_workflow import RecoveryWorkflow
+from dex.tests.workflows.rpc_memo_workflow import RpcMemoWorkflow
+from dex.tests.workflows.rpc_workflow import RPCWorkflow
+from dex.tests.workflows.state_options_override_workflow import (
+    StateOptionsOverrideWorkflow,
+)
+from dex.tests.workflows.state_options_workflow import (
+    StateOptionsWorkflow1,
+    StateOptionsWorkflow2,
+)
+from dex.tests.workflows.timer_workflow import TimerWorkflow
+from dex.tests.workflows.wait_for_state_with_state_execution_id_workflow import (
+    WaitForStateWithStateExecutionIdWorkflow,
+)
+from dex.tests.workflows.wait_for_state_with_wait_for_key_workflow import (
+    WaitForStateWithWaitForKeyWorkflow,
+)
+from dex.tests.workflows.wait_internal_channel_workflow import (
+    WaitInternalChannelWorkflow,
+)
+from dex.tests.workflows.wait_signal_workflow import WaitSignalWorkflow
+
+registry = Registry()
+
+registry.add_workflow(AbnormalExitWorkflow())
+registry.add_workflow(BasicWorkflow())
+registry.add_workflow(ConditionalCompleteWorkflow())
+registry.add_workflow(DescribeWorkflow())
+registry.add_workflow(EmptyDataWorkflow())
+registry.add_workflow(InternalChannelWorkflow())
+registry.add_workflow(InternalChannelWorkflowWithNoPrefixChannel())
+registry.add_workflow(JavaDuplicateRpcMemoWorkflow())
+registry.add_workflow(PersistenceDataAttributesWorkflow())
+registry.add_workflow(PersistenceSearchAttributesWorkflow())
+registry.add_workflow(PersistenceStateExecutionLocalWorkflow())
+registry.add_workflow(RecoveryWorkflow())
+registry.add_workflow(RpcMemoWorkflow())
+registry.add_workflow(RPCWorkflow())
+registry.add_workflow(StateOptionsOverrideWorkflow())
+registry.add_workflow(StateOptionsWorkflow1())
+registry.add_workflow(StateOptionsWorkflow2())
+registry.add_workflow(TimerWorkflow())
+registry.add_workflow(WaitForStateWithStateExecutionIdWorkflow())
+registry.add_workflow(WaitForStateWithWaitForKeyWorkflow())
+registry.add_workflow(WaitInternalChannelWorkflow())
+registry.add_workflow(WaitSignalWorkflow())

dex/tests/dex-service-env/.env

@@ -0,0 +1,7 @@
+CASSANDRA_VERSION=3.11.9
+ELASTICSEARCH_VERSION=7.17.27
+MYSQL_VERSION=8
+POSTGRESQL_VERSION=13
+TEMPORAL_VERSION=1.25
+TEMPORAL_UI_VERSION=2.31.2
+TEMPORAL_ADMIN_TOOLS_VERSION=1.25.2-tctl-1.18.1-cli-1.1.1

dex/tests/dex-service-env/docker-compose-init.sh

@@ -0,0 +1,44 @@
+#!/bin/bash
+
+checkExists () {
+  # see https://github.com/temporalio/temporal/issues/4160
+  if temporal  operator search-attribute list | grep -q "$1"; then
+    return 0
+  else
+    return 1
+fi
+}
+
+echo "now trying to register Dex system search attributes..."
+for run in {1..120}; do
+  sleep 1
+  temporal  operator search-attribute  create --name DexWorkflowType --type Keyword
+  sleep 0.1
+  temporal  operator search-attribute  create --name DexGlobalWorkflowVersion --type Int
+  sleep 0.1
+  temporal  operator search-attribute  create --name DexExecutingStateIds --type KeywordList
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomKeywordField --type Keyword
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomIntField --type Int
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomBoolField --type Bool
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomDoubleField --type Double
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomDatetimeField --type Datetime
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomStringField --type Text
+  sleep 0.1
+  temporal  operator search-attribute  create --name CustomKeywordArrayField --type KeywordList
+  sleep 0.1
+
+  if checkExists "DexWorkflowType" && checkExists "DexGlobalWorkflowVersion" && checkExists "DexExecutingStateIds" && checkExists "CustomKeywordField" && checkExists "CustomIntField" && checkExists "CustomBoolField" && checkExists "CustomDoubleField" && checkExists "CustomDatetimeField" && checkExists "CustomStringField" && checkExists "CustomKeywordArrayField"; then
+    echo "All search attributes are registered"
+    break
+  fi
+
+done
+
+
+tail -f /dev/null

dex/tests/dex-service-env/docker-compose.yml

@@ -0,0 +1,87 @@
+version: '3.9'
+
+# see .env file for the default value of the environment variables
+services:
+  elasticsearch:
+    container_name: temporal-elasticsearch-dex
+    environment:
+    - cluster.routing.allocation.disk.threshold_enabled=true
+    - cluster.routing.allocation.disk.watermark.low=512mb
+    - cluster.routing.allocation.disk.watermark.high=256mb
+    - cluster.routing.allocation.disk.watermark.flood_stage=128mb
+    - discovery.type=single-node
+    - ES_JAVA_OPTS=-Xms512m -Xmx512m
+    - xpack.security.enabled=false
+    image: elasticsearch:${ELASTICSEARCH_VERSION}
+    networks:
+    - temporal-network
+    expose:
+    - 9200
+  postgresql:
+    container_name: temporal-postgresql-dex
+    environment:
+      POSTGRES_PASSWORD: temporal
+      POSTGRES_USER: temporal
+    image: postgres:${POSTGRESQL_VERSION}
+    networks:
+    - temporal-network
+    expose:
+    - 5432
+  temporal:
+    container_name: temporal-dex
+    depends_on:
+    - postgresql
+    - elasticsearch
+    environment:
+    - DB=postgres12
+    - DB_PORT=5432
+    - POSTGRES_USER=temporal
+    - POSTGRES_PWD=temporal
+    - POSTGRES_SEEDS=postgresql
+    - DYNAMIC_CONFIG_FILE_PATH=config/dynamicconfig/development-sql.yaml
+    - ENABLE_ES=true
+    - ES_SEEDS=elasticsearch
+    - ES_VERSION=v7
+    image: temporalio/auto-setup:${TEMPORAL_VERSION}
+    networks:
+    - temporal-network
+    ports:
+    - 7233:7233
+    labels:
+      kompose.volume.type: configMap
+    volumes:
+    - ./dynamicconfig:/etc/temporal/config/dynamicconfig
+  temporal-admin-tools:
+    container_name: temporal-admin-tools-dex
+    depends_on:
+    - temporal
+    environment:
+    - TEMPORAL_ADDRESS=temporal:7233
+    - TEMPORAL_CLI_ADDRESS=temporal:7233
+    image: temporalio/admin-tools:${TEMPORAL_ADMIN_TOOLS_VERSION}
+    networks:
+    - temporal-network
+    stdin_open: true
+    tty: true
+    volumes:
+    - ./docker-compose-init.sh:/etc/temporal/init.sh
+    entrypoint: sh -c "/etc/temporal/init.sh"
+  dex-server:
+    container_name: dex-server
+    image: ${DEX_SERVER_IMAGE:-superdurable/dex-server:latest}
+    environment:
+    # Replace localhost/127.0.0.1 worker URLs so the container can reach the host worker.
+    # host.docker.internal works on Docker Desktop and on Linux with extra_hosts below.
+    - AUTO_FIX_WORKER_URL=host.docker.internal
+    networks:
+    - temporal-network
+    ports:
+    - 8801:8801
+    depends_on:
+    - temporal
+    extra_hosts:
+    - host.docker.internal:host-gateway
+networks:
+  temporal-network:
+    driver: bridge
+    name: temporal-network

dex/tests/dex-service-env/dynamicconfig/README.md

@@ -0,0 +1,39 @@
+Use `docker.yaml` file to override the default dynamic config value (they are specified
+when creating the service config).
+
+Each key can have zero or more values and each value can have zero or more
+constraints. There are only three types of constraint:
+1. `namespace`: `string`
+2. `taskQueueName`: `string`
+3. `taskType`: `int` (`1`:`Workflow`, `2`:`Activity`)
+A value will be selected and returned if all its has exactly the same constraints
+as the ones specified in query filters (including the number of constraints).
+
+Please use the following format:
+```
+testGetBoolPropertyKey:
+  - value: false
+  - value: true
+    constraints:
+      namespace: "global-samples-namespace"
+  - value: false
+    constraints:
+      namespace: "samples-namespace"
+testGetDurationPropertyKey:
+  - value: "1m"
+    constraints:
+      namespace: "samples-namespace"
+      taskQueueName: "longIdleTimeTaskqueue"
+testGetFloat64PropertyKey:
+  - value: 12.0
+    constraints:
+      namespace: "samples-namespace"
+testGetMapPropertyKey:
+  - value:
+      key1: 1
+      key2: "value 2"
+      key3:
+        - false
+        - key4: true
+          key5: 2.0
+```

dex/tests/dex-service-env/dynamicconfig/development-sql.yaml

@@ -0,0 +1,6 @@
+limit.maxIDLength:
+- value: 255
+  constraints: {}
+system.forceSearchAttributesCacheRefreshOnRead:
+- value: true # Dev setup only. Please don't turn this on in production.
+  constraints: {}

dex/tests/test_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.
+
+import inspect
+import time
+import unittest
+
+from dex.client import Client
+from dex.errors import WorkflowFailed
+from dex.dex_api.models.id_reuse_policy import IDReusePolicy
+from dex.tests.worker_server import registry
+from dex.tests.workflows.abnormal_exit_workflow import AbnormalExitWorkflow
+from dex.tests.workflows.basic_workflow import BasicWorkflow
+from dex.workflow_options import WorkflowOptions
+
+
+class TestAbnormalWorkflow(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_abnormal_exit_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        start_options = WorkflowOptions(
+            workflow_id_reuse_policy=IDReusePolicy.ALLOW_IF_PREVIOUS_EXITS_ABNORMALLY
+        )
+
+        self.client.start_workflow(
+            AbnormalExitWorkflow, wf_id, 100, "input", start_options
+        )
+        with self.assertRaises(WorkflowFailed):
+            self.client.wait_for_workflow_completion(wf_id, str)
+
+        # Starting a workflow with the same ID should be allowed since the previous failed abnormally
+        self.client.start_workflow(BasicWorkflow, wf_id, 100, "input", start_options)
+        res = self.client.wait_for_workflow_completion(wf_id, str)
+        assert res == "done"

dex/tests/test_basic_workflow.py

@@ -0,0 +1,75 @@
+# 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
+from dex.dex_api.models import WorkflowAlreadyStartedOptions
+from dex.tests.worker_server import registry
+from dex.tests.workflows.basic_workflow import BasicWorkflow
+from dex.workflow_options import WorkflowOptions
+
+
+class TestWorkflowErrors(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_basic_workflow(self):
+        original_request_id = "1"
+        later_request_id = "2"
+
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        workflow_already_started_options_1 = WorkflowAlreadyStartedOptions(
+            ignore_already_started_error=True
+        )
+        workflow_already_started_options_1.request_id = original_request_id
+
+        start_options_1 = WorkflowOptions()
+        start_options_1.workflow_already_started_options = (
+            workflow_already_started_options_1
+        )
+
+        wf_run_id = self.client.start_workflow(
+            BasicWorkflow, wf_id, 100, "input", start_options_1
+        )
+        assert wf_run_id
+
+        wf_run_id = self.client.start_workflow(
+            BasicWorkflow, wf_id, 100, "input", start_options_1
+        )
+        assert wf_run_id
+
+        workflow_already_started_options_2 = WorkflowAlreadyStartedOptions(
+            ignore_already_started_error=True
+        )
+        workflow_already_started_options_2.request_id = later_request_id
+
+        start_options_2 = WorkflowOptions()
+        start_options_2.workflow_already_started_option = (
+            workflow_already_started_options_2
+        )
+
+        with self.assertRaises(WorkflowAlreadyStartedError):
+            wf_run_id = self.client.start_workflow(
+                BasicWorkflow, wf_id, 100, "input", start_options_2
+            )
+            assert wf_run_id
+
+        res = self.client.wait_for_workflow_completion(wf_id, str)
+        assert res == "done"

dex/tests/test_conditional_complete.py

@@ -0,0 +1,56 @@
+# 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.conditional_complete_workflow import (
+    ConditionalCompleteWorkflow,
+    test_signal_channel,
+)
+
+
+class TestConditionalComplete(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_internal_channel_conditional_complete(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        do_test_conditional_workflow(self.client, wf_id, False)
+
+    def test_signal_channel_conditional_complete(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+        do_test_conditional_workflow(self.client, wf_id, True)
+
+
+def do_test_conditional_workflow(client: Client, wf_id: str, use_signal: bool):
+    client.start_workflow(ConditionalCompleteWorkflow, wf_id, 10, use_signal)
+
+    for x in range(3):
+        if use_signal:
+            client.signal_workflow(wf_id, test_signal_channel, 123)
+        else:
+            client.invoke_rpc(
+                wf_id, ConditionalCompleteWorkflow.test_rpc_publish_channel
+            )
+        if x == 0:
+            # wait for a second so that the workflow is in execute state
+            time.sleep(1)
+
+    res = client.wait_for_workflow_completion(wf_id)
+    assert res == 3

dex/tests/test_describe_workflow.py

@@ -0,0 +1,45 @@
+# 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 WorkflowNotExistsError
+from dex.dex_api.models import WorkflowStatus
+from dex.tests.workflows.describe_workflow import DescribeWorkflow
+from dex.tests.worker_server import registry
+
+
+class TestDescribeWorkflow(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_describe_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(DescribeWorkflow, wf_id, 100)
+        workflow_info = self.client.describe_workflow(wf_id)
+        assert workflow_info.workflow_status == WorkflowStatus.RUNNING
+
+        # Stop the workflow
+        self.client.stop_workflow(wf_id)
+
+    def test_describe_workflow_when_workflow_not_exists(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        with self.assertRaises(WorkflowNotExistsError):
+            self.client.describe_workflow(wf_id)

dex/tests/test_empty_data_decodes_properly.py

@@ -0,0 +1,79 @@
+# 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
+
+import httpx
+
+from dex.client import Client
+from dex.tests.worker_server import registry
+from dex.worker_service import WorkerService
+
+
+class TestBinaryNullDecodesCorrectly(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_binary_null_input_decodes_correctly(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        response = httpx.post(
+            f"http://0.0.0.0:8802/{WorkerService.api_path_workflow_state_execute}",
+            json={
+                "DataObjects": [
+                    {"key": "test-da", "value": {"encoding": "binary/null"}}
+                ],
+                "commandResults": {
+                    "interStateChannelResults": [],
+                    "stateStartApiSucceeded": True,
+                },
+                "context": {
+                    "attempt": 1,
+                    "firstAttemptTimestamp": 1747935829,
+                    "stateExecutionId": "State1-1",
+                    "workflowId": wf_id,
+                    "workflowRunId": "0196f734-d037-7432-bd63-e1136cd34dbd",
+                    "workflowStartedTimestamp": 1747904155,
+                },
+                "stateInput": {"encoding": "binary/null"},
+                "stateLocals": [],
+                "workflowStateId": "State1",
+                "workflowType": "EmptyDataWorkflow",
+            },
+        )
+        assert response.is_success
+        response_json = response.json()
+        self.assertEqual(
+            response_json,
+            {
+                "publishToInterStateChannel": [],
+                "recordEvents": [],
+                "stateDecision": {
+                    "nextStates": [
+                        {
+                            "stateId": "_SYS_GRACEFUL_COMPLETING_WORKFLOW",
+                            "stateInput": {
+                                "data": '"success"',
+                                "encoding": "json/plain",
+                            },
+                        }
+                    ]
+                },
+                "upsertDataObjects": [],
+                "upsertStateLocals": [],
+            },
+        )

dex/tests/test_internal_channel.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.internal_channel_workflow import InternalChannelWorkflow
+
+
+class TestConditionalComplete(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_internal_channel_workflow(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(InternalChannelWorkflow, wf_id, 100, None)
+        self.client.wait_for_workflow_completion(wf_id, None)

dex/tests/test_internal_channel_with_no_prefix_channel.py

@@ -0,0 +1,46 @@
+# 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.internal_channel_workflow_with_no_prefix_channel import (
+    InternalChannelWorkflowWithNoPrefixChannel,
+    test_non_prefix_channel_name_with_suffix,
+)
+
+
+class TestInternalChannelWithNoPrefix(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.client = Client(registry)
+
+    def test_internal_channel_workflow_with_no_prefix_channel(self):
+        wf_id = f"{inspect.currentframe().f_code.co_name}-{time.time_ns()}"
+
+        self.client.start_workflow(
+            InternalChannelWorkflowWithNoPrefixChannel, wf_id, 5, None
+        )
+
+        with self.assertRaises(Exception) as context:
+            self.client.wait_for_workflow_completion(wf_id, None)
+
+        self.assertIn("FAILED", context.exception.workflow_status)
+        self.assertIn(
+            f"WorkerExecutionError: InternalChannel channel_name is not defined {test_non_prefix_channel_name_with_suffix}",
+            context.exception.error_message,
+        )