Improve integration tests

Signed-off-by: Tim Li <[email protected]>

Author: timl3136

tests/integration_tests/test_client.py

@@ -6,7 +6,6 @@
 from cadence.error import EntityNotExistsError
 from tests.integration_tests.helper import CadenceHelper, DOMAIN_NAME
 
-
 @pytest.mark.usefixtures("helper")
 async def test_domain_exists(helper: CadenceHelper):
     async with helper.client() as client:
@@ -33,53 +32,36 @@ async def test_worker_stub_accessible(helper: CadenceHelper):
 # Workflow Stub Tests
 
 @pytest.mark.usefixtures("helper")
-async def test_workflow_stub_accessible(helper: CadenceHelper):
-    """Test that workflow_stub is properly initialized and accessible."""
-    async with helper.client() as client:
-        assert client.workflow_stub is not None
-        # Verify it's the correct type
-        from cadence.api.v1.service_workflow_pb2_grpc import WorkflowAPIStub
-        assert isinstance(client.workflow_stub, WorkflowAPIStub)
-
-@pytest.mark.usefixtures("helper")
-async def test_workflow_stub_start_workflow(helper: CadenceHelper):
-    """Test starting a workflow execution via workflow_stub.
+async def test_workflow_stub_start_and_describe(helper: CadenceHelper):
+    """Comprehensive test for workflow start and describe operations.
     
-    This test verifies that we can start a workflow execution using the
-    client's start_workflow method, which uses workflow_stub internally.
+    This integration test verifies:
+    1. Starting a workflow execution via workflow_stub
+    2. Describing the workflow execution
+    3. All parameters match between start request and describe response:
+       - workflow_id and run_id
+       - workflow type
+       - task list configuration
+       - execution and task timeouts
     """
     async with helper.client() as client:
-        # Start a simple workflow
-        execution = await client.start_workflow(
-            "test-workflow-type",
-            task_list="test-task-list",
-            execution_start_to_close_timeout=timedelta(minutes=5),
-            workflow_id="test-workflow-id-123",
-        )
+        # Define workflow parameters
+        workflow_type = "test-workflow-type-describe"
+        task_list_name = "test-task-list-describe"
+        workflow_id = "test-workflow-describe-456"
+        execution_timeout = timedelta(minutes=5)
+        task_timeout = timedelta(seconds=10)  # Default value
 
-        # Verify we got a valid execution response
-        assert execution is not None
-        assert execution.workflow_id == "test-workflow-id-123"
-        assert execution.run_id is not None
-        assert len(execution.run_id) > 0
-
-@pytest.mark.usefixtures("helper")
-async def test_workflow_stub_describe_workflow(helper: CadenceHelper):
-    """Test describing a workflow execution via workflow_stub.
-    
-    This test verifies that we can query workflow execution details after
-    starting a workflow.
-    """
-    async with helper.client() as client:
-        # First start a workflow
+        # Start a workflow with specific parameters
         execution = await client.start_workflow(
-            "test-workflow-type-describe",
-            task_list="test-task-list-describe",
-            execution_start_to_close_timeout=timedelta(minutes=5),
-            workflow_id="test-workflow-describe-456",
+            workflow_type,
+            task_list=task_list_name,
+            execution_start_to_close_timeout=execution_timeout,
+            task_start_to_close_timeout=task_timeout,
+            workflow_id=workflow_id,
         )
 
-        # Now describe the workflow execution
+        # Describe the workflow execution
         describe_request = DescribeWorkflowExecutionRequest(
             domain=DOMAIN_NAME,
             workflow_execution=WorkflowExecution(
@@ -90,51 +72,37 @@ async def test_workflow_stub_describe_workflow(helper: CadenceHelper):
 
         response = await client.workflow_stub.DescribeWorkflowExecution(describe_request)
 
-        # Print the run_id for debugging
-        print(f"Workflow run_id: {execution.run_id}")
+        # Assert workflow execution info matches
+        assert response is not None, "DescribeWorkflowExecution returned None"
+        assert response.workflow_execution_info is not None, "workflow_execution_info is None"
 
-        # Verify we got a valid response
-        assert response is not None
-        assert response.workflow_execution_info is not None
-        assert response.workflow_execution_info.workflow_execution.workflow_id == execution.workflow_id
-        assert response.workflow_execution_info.workflow_execution.run_id == execution.run_id
-
-# Combined Test
-
-@pytest.mark.usefixtures("helper")
-async def test_all_stubs_accessible(helper: CadenceHelper):
-    """Test that all three stubs (domain, worker, workflow) are accessible.
-    
-    This is a comprehensive connectivity test that verifies the client
-    can access all three main API stubs.
-    """
-    async with helper.client() as client:
-        # Verify all stubs are initialized
-        assert client.domain_stub is not None
-        assert client.worker_stub is not None
-        assert client.workflow_stub is not None
+        # Verify workflow execution identifiers
+        wf_exec = response.workflow_execution_info.workflow_execution
+        assert wf_exec.workflow_id == workflow_id, \
+            f"workflow_id mismatch: expected {workflow_id}, got {wf_exec.workflow_id}"
+        assert wf_exec.run_id == execution.run_id, \
+            f"run_id mismatch: expected {execution.run_id}, got {wf_exec.run_id}"
 
-        # Verify they are the correct types
-        from cadence.api.v1.service_domain_pb2_grpc import DomainAPIStub
-        from cadence.api.v1.service_worker_pb2_grpc import WorkerAPIStub
-        from cadence.api.v1.service_workflow_pb2_grpc import WorkflowAPIStub
+        # Verify workflow type
+        assert response.workflow_execution_info.type.name == workflow_type, \
+            f"workflow_type mismatch: expected {workflow_type}, got {response.workflow_execution_info.type.name}"
 
-        assert isinstance(client.domain_stub, DomainAPIStub)
-        assert isinstance(client.worker_stub, WorkerAPIStub)
-        assert isinstance(client.workflow_stub, WorkflowAPIStub)
+        # Verify task list
+        assert response.workflow_execution_info.task_list == task_list_name, \
+            f"task_list mismatch: expected {task_list_name}, got {response.workflow_execution_info.task_list}"
 
-        # Test basic connectivity with each stub
-        # Domain stub - describe domain
-        domain_response = await client.domain_stub.DescribeDomain(
-            DescribeDomainRequest(name=DOMAIN_NAME)
-        )
-        assert domain_response.domain.name == DOMAIN_NAME
+        # Verify execution configuration
+        assert response.execution_configuration is not None, "execution_configuration is None"
 
-        # Workflow stub - start workflow
-        execution = await client.start_workflow(
-            "connectivity-test-workflow",
-            task_list="connectivity-test-task-list",
-            execution_start_to_close_timeout=timedelta(minutes=5),
-            workflow_id="connectivity-test-workflow-789",
-        )
-        assert execution.workflow_id == "connectivity-test-workflow-789"
+        # Verify task list in configuration
+        assert response.execution_configuration.task_list.name == task_list_name, \
+            f"config task_list mismatch: expected {task_list_name}, got {response.execution_configuration.task_list.name}"
+        
+        # Verify timeouts
+        exec_timeout_seconds = response.execution_configuration.execution_start_to_close_timeout.ToSeconds()
+        assert exec_timeout_seconds == execution_timeout.total_seconds(), \
+            f"execution_start_to_close_timeout mismatch: expected {execution_timeout.total_seconds()}s, got {exec_timeout_seconds}s"
+        
+        task_timeout_seconds = response.execution_configuration.task_start_to_close_timeout.ToSeconds()
+        assert task_timeout_seconds == task_timeout.total_seconds(), \
+            f"task_start_to_close_timeout mismatch: expected {task_timeout.total_seconds()}s, got {task_timeout_seconds}s"