fix(active-active): Update CLI describe workflow output to show ActiveClusterSelectionPolicy (#7461)

<!-- Describe what has changed in this PR -->
**What changed?**
Update CLI describe workflow output to show ActiveClusterSelectionPolicy

<!-- Tell your future self why have you made these changes -->
**Why?**


<!-- How have you verified this change? Tested locally? Added a unit
test? Checked in staging env? -->
**How did you test it?**
unit test

<!-- Assuming the worst case, what can be broken when deploying this
change to production? -->
**Potential risks**

<!-- Is it notable for release? e.g. schema updates, configuration or
data migration required? If so, please mention it, and also update
CHANGELOG.md -->
**Release notes**

<!-- Is there any documentation updates should be made for config,
https://cadenceworkflow.io/docs/operation-guide/setup/ ? If so, please
open an PR in https://github.com/cadence-workflow/cadence-docs -->
**Documentation Changes**

Author: Shaddoll

tools/cli/workflow_commands.go

@@ -1148,19 +1148,20 @@ type describeWorkflowExecutionResponse struct {
 
 // workflowExecutionInfo has same fields as types.WorkflowExecutionInfo, but has datetime instead of raw time
 type workflowExecutionInfo struct {
-	Execution         *types.WorkflowExecution
-	Type              *types.WorkflowType
-	StartTime         *string // change from *int64
-	CloseTime         *string // change from *int64
-	CloseStatus       *types.WorkflowExecutionCloseStatus
-	HistoryLength     int64
-	ParentDomainID    *string
-	ParentExecution   *types.WorkflowExecution
-	Memo              *types.Memo
-	SearchAttributes  map[string]interface{}
-	AutoResetPoints   *types.ResetPoints
-	PartitionConfig   map[string]string
-	CronOverlapPolicy *types.CronOverlapPolicy
+	Execution                    *types.WorkflowExecution
+	Type                         *types.WorkflowType
+	StartTime                    *string // change from *int64
+	CloseTime                    *string // change from *int64
+	CloseStatus                  *types.WorkflowExecutionCloseStatus
+	HistoryLength                int64
+	ParentDomainID               *string
+	ParentExecution              *types.WorkflowExecution
+	Memo                         *types.Memo
+	SearchAttributes             map[string]interface{}
+	AutoResetPoints              *types.ResetPoints
+	PartitionConfig              map[string]string
+	CronOverlapPolicy            *types.CronOverlapPolicy
+	ActiveClusterSelectionPolicy *types.ActiveClusterSelectionPolicy
 }
 
 // pendingActivityInfo has same fields as types.PendingActivityInfo, but different field type for better display
@@ -1199,19 +1200,20 @@ func convertDescribeWorkflowExecutionResponse(resp *types.DescribeWorkflowExecut
 		return nil, fmt.Errorf("error converting search attributes: %w", err)
 	}
 	executionInfo := workflowExecutionInfo{
-		Execution:         info.Execution,
-		Type:              info.Type,
-		StartTime:         common.StringPtr(timestampToString(info.GetStartTime(), false)),
-		CloseTime:         common.StringPtr(timestampToString(info.GetCloseTime(), false)),
-		CloseStatus:       info.CloseStatus,
-		HistoryLength:     info.HistoryLength,
-		ParentDomainID:    info.ParentDomainID,
-		ParentExecution:   info.ParentExecution,
-		Memo:              info.Memo,
-		SearchAttributes:  searchattributes,
-		AutoResetPoints:   info.AutoResetPoints,
-		PartitionConfig:   info.PartitionConfig,
-		CronOverlapPolicy: info.CronOverlapPolicy,
+		Execution:                    info.Execution,
+		Type:                         info.Type,
+		StartTime:                    common.StringPtr(timestampToString(info.GetStartTime(), false)),
+		CloseTime:                    common.StringPtr(timestampToString(info.GetCloseTime(), false)),
+		CloseStatus:                  info.CloseStatus,
+		HistoryLength:                info.HistoryLength,
+		ParentDomainID:               info.ParentDomainID,
+		ParentExecution:              info.ParentExecution,
+		Memo:                         info.Memo,
+		SearchAttributes:             searchattributes,
+		AutoResetPoints:              info.AutoResetPoints,
+		PartitionConfig:              info.PartitionConfig,
+		CronOverlapPolicy:            info.CronOverlapPolicy,
+		ActiveClusterSelectionPolicy: info.ActiveClusterSelectionPolicy,
 	}
 
 	var pendingActs []*pendingActivityInfo

tools/cli/workflow_commands_test.go

@@ -426,31 +426,252 @@ func Test_GetWorkflowStatus(t *testing.T) {
 func Test_ConvertDescribeWorkflowExecutionResponse(t *testing.T) {
 	mockCtrl := gomock.NewController(t)
 	serverFrontendClient := frontend.NewMockClient(mockCtrl)
-	mockResp := &types.DescribeWorkflowExecutionResponse{
-		WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
-			Execution: &types.WorkflowExecution{
-				WorkflowID: "test-workflow-id",
-				RunID:      "test-run-id",
+
+	t.Run("basic conversion", func(t *testing.T) {
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "test-workflow-id",
+					RunID:      "test-run-id",
+				},
 			},
-		},
-		PendingActivities: []*types.PendingActivityInfo{
-			{
-				ActivityID: "test-activity-id",
-				ActivityType: &types.ActivityType{
-					Name: "test-activity-type",
+			PendingActivities: []*types.PendingActivityInfo{
+				{
+					ActivityID: "test-activity-id",
+					ActivityType: &types.ActivityType{
+						Name: "test-activity-type",
+					},
+					HeartbeatDetails:   []byte("test-heartbeat-details"),
+					LastFailureDetails: []byte("test-failure-details"),
 				},
-				HeartbeatDetails:   []byte("test-heartbeat-details"),
-				LastFailureDetails: []byte("test-failure-details"),
 			},
-		},
-		PendingDecision: &types.PendingDecisionInfo{
-			State: nil,
-		},
-	}
+			PendingDecision: &types.PendingDecisionInfo{
+				State: nil,
+			},
+		}
 
-	resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
-	assert.NoError(t, err)
-	assert.Equal(t, "test-workflow-id", resp.WorkflowExecutionInfo.Execution.WorkflowID)
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.Equal(t, "test-workflow-id", resp.WorkflowExecutionInfo.Execution.WorkflowID)
+		assert.Equal(t, 1, len(resp.PendingActivities))
+		assert.NotNil(t, resp.PendingDecision)
+	})
+
+	t.Run("with execution configuration", func(t *testing.T) {
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			ExecutionConfiguration: &types.WorkflowExecutionConfiguration{
+				TaskList: &types.TaskList{Name: "test-task-list"},
+			},
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "test-wf-id",
+					RunID:      "test-run-id",
+				},
+				Type: &types.WorkflowType{
+					Name: "test-workflow-type",
+				},
+				HistoryLength: 100,
+			},
+			PendingActivities: []*types.PendingActivityInfo{},
+			PendingChildren:   []*types.PendingChildExecutionInfo{},
+		}
+
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.NotNil(t, resp.ExecutionConfiguration)
+		assert.Equal(t, "test-task-list", resp.ExecutionConfiguration.TaskList.Name)
+		assert.Equal(t, int64(100), resp.WorkflowExecutionInfo.HistoryLength)
+	})
+
+	t.Run("with pending activities and conversion of timestamps", func(t *testing.T) {
+		now := time.Now().UnixNano()
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "test-wf",
+					RunID:      "test-run",
+				},
+				StartTime: common.Int64Ptr(now),
+				CloseTime: common.Int64Ptr(now + 1000),
+			},
+			PendingActivities: []*types.PendingActivityInfo{
+				{
+					ActivityID: "activity-1",
+					ActivityType: &types.ActivityType{
+						Name: "ActivityType1",
+					},
+					State:                  types.PendingActivityStateScheduled.Ptr(),
+					ScheduledTimestamp:     common.Int64Ptr(now),
+					LastStartedTimestamp:   common.Int64Ptr(now + 500),
+					LastHeartbeatTimestamp: common.Int64Ptr(now + 600),
+					ExpirationTimestamp:    common.Int64Ptr(now + 2000),
+					Attempt:                1,
+					MaximumAttempts:        3,
+					LastFailureReason:      common.StringPtr("test-failure"),
+					LastWorkerIdentity:     "worker-1",
+					ScheduleID:             1,
+				},
+				{
+					ActivityID: "activity-2",
+					ActivityType: &types.ActivityType{
+						Name: "ActivityType2",
+					},
+					HeartbeatDetails:   []byte("heartbeat-data"),
+					LastFailureDetails: []byte("failure-data"),
+				},
+			},
+		}
+
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, len(resp.PendingActivities))
+
+		// Check first activity has timestamps converted
+		assert.NotNil(t, resp.PendingActivities[0].ScheduledTimestamp)
+		assert.NotNil(t, resp.PendingActivities[0].LastStartedTimestamp)
+		assert.NotNil(t, resp.PendingActivities[0].LastHeartbeatTimestamp)
+		assert.NotNil(t, resp.PendingActivities[0].ExpirationTimestamp)
+		assert.Equal(t, int32(1), resp.PendingActivities[0].Attempt)
+		assert.Equal(t, int32(3), resp.PendingActivities[0].MaximumAttempts)
+		assert.Equal(t, "test-failure", *resp.PendingActivities[0].LastFailureReason)
+
+		// Check second activity has byte fields converted
+		assert.NotNil(t, resp.PendingActivities[1].HeartbeatDetails)
+		assert.Equal(t, "heartbeat-data", *resp.PendingActivities[1].HeartbeatDetails)
+		assert.NotNil(t, resp.PendingActivities[1].LastFailureDetails)
+		assert.Equal(t, "failure-data", *resp.PendingActivities[1].LastFailureDetails)
+	})
+
+	t.Run("with pending decision and timestamps", func(t *testing.T) {
+		now := time.Now().UnixNano()
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "test-wf",
+					RunID:      "test-run",
+				},
+			},
+			PendingDecision: &types.PendingDecisionInfo{
+				State:              types.PendingDecisionStateScheduled.Ptr(),
+				ScheduledTimestamp: common.Int64Ptr(now),
+				StartedTimestamp:   common.Int64Ptr(now + 100),
+				Attempt:            5,
+				ScheduleID:         42,
+			},
+		}
+
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.NotNil(t, resp.PendingDecision)
+		assert.NotNil(t, resp.PendingDecision.ScheduledTimestamp)
+		assert.NotNil(t, resp.PendingDecision.StartedTimestamp)
+		assert.Equal(t, int64(5), resp.PendingDecision.Attempt)
+		assert.Equal(t, int64(42), resp.PendingDecision.ScheduleID)
+	})
+
+	t.Run("with pending children", func(t *testing.T) {
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "parent-wf",
+					RunID:      "parent-run",
+				},
+			},
+			PendingChildren: []*types.PendingChildExecutionInfo{
+				{
+					WorkflowID:        "child-wf-1",
+					RunID:             "child-run-1",
+					WorkflowTypeName:  "ChildWorkflowType",
+					InitiatedID:       10,
+					ParentClosePolicy: types.ParentClosePolicyTerminate.Ptr(),
+				},
+				{
+					WorkflowID:        "child-wf-2",
+					RunID:             "child-run-2",
+					WorkflowTypeName:  "ChildWorkflowType2",
+					InitiatedID:       20,
+					ParentClosePolicy: types.ParentClosePolicyAbandon.Ptr(),
+				},
+			},
+		}
+
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.Equal(t, 2, len(resp.PendingChildren))
+		assert.Equal(t, "child-wf-1", resp.PendingChildren[0].WorkflowID)
+		assert.Equal(t, "child-wf-2", resp.PendingChildren[1].WorkflowID)
+	})
+
+	t.Run("with workflow execution info fields", func(t *testing.T) {
+		now := time.Now().UnixNano()
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "wf-id",
+					RunID:      "run-id",
+				},
+				Type: &types.WorkflowType{
+					Name: "WorkflowType",
+				},
+				StartTime:      common.Int64Ptr(now),
+				CloseTime:      common.Int64Ptr(now + 1000),
+				CloseStatus:    types.WorkflowExecutionCloseStatusCompleted.Ptr(),
+				HistoryLength:  50,
+				ParentDomainID: common.StringPtr("parent-domain"),
+				ParentExecution: &types.WorkflowExecution{
+					WorkflowID: "parent-wf",
+					RunID:      "parent-run",
+				},
+				Memo: &types.Memo{
+					Fields: map[string][]byte{
+						"key1": []byte("value1"),
+					},
+				},
+				PartitionConfig: map[string]string{
+					"config1": "value1",
+				},
+				CronOverlapPolicy: types.CronOverlapPolicySkipped.Ptr(),
+				ActiveClusterSelectionPolicy: &types.ActiveClusterSelectionPolicy{
+					ClusterAttribute: &types.ClusterAttribute{
+						Scope: "region",
+						Name:  "us-west-1",
+					},
+				},
+			},
+		}
+
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.StartTime)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.CloseTime)
+		assert.Equal(t, types.WorkflowExecutionCloseStatusCompleted, *resp.WorkflowExecutionInfo.CloseStatus)
+		assert.Equal(t, int64(50), resp.WorkflowExecutionInfo.HistoryLength)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.ParentDomainID)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.ParentExecution)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.Memo)
+		assert.Equal(t, map[string]string{"config1": "value1"}, resp.WorkflowExecutionInfo.PartitionConfig)
+		assert.Equal(t, types.CronOverlapPolicySkipped, *resp.WorkflowExecutionInfo.CronOverlapPolicy)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.ActiveClusterSelectionPolicy)
+		assert.NotNil(t, resp.WorkflowExecutionInfo.ActiveClusterSelectionPolicy.ClusterAttribute)
+		assert.Equal(t, "region", resp.WorkflowExecutionInfo.ActiveClusterSelectionPolicy.ClusterAttribute.Scope)
+		assert.Equal(t, "us-west-1", resp.WorkflowExecutionInfo.ActiveClusterSelectionPolicy.ClusterAttribute.Name)
+	})
+
+	t.Run("with no pending activities or decision", func(t *testing.T) {
+		mockResp := &types.DescribeWorkflowExecutionResponse{
+			WorkflowExecutionInfo: &types.WorkflowExecutionInfo{
+				Execution: &types.WorkflowExecution{
+					WorkflowID: "wf-id",
+					RunID:      "run-id",
+				},
+			},
+		}
+
+		resp, err := convertDescribeWorkflowExecutionResponse(mockResp, serverFrontendClient, nil)
+		assert.NoError(t, err)
+		assert.Nil(t, resp.PendingDecision)
+		assert.Equal(t, 0, len(resp.PendingActivities))
+	})
 }
 
 func Test_PrintRunStatus(t *testing.T) {