diff --git a/common/types/mapper/proto/api.go b/common/types/mapper/proto/api.go index a128d01265d..5ab461b5804 100644 --- a/common/types/mapper/proto/api.go +++ b/common/types/mapper/proto/api.go @@ -270,7 +270,7 @@ func FromArchivalStatus(t *types.ArchivalStatus) apiv1.ArchivalStatus { case types.ArchivalStatusEnabled: return apiv1.ArchivalStatus_ARCHIVAL_STATUS_ENABLED } - panic("unexpected enum value") + return apiv1.ArchivalStatus_ARCHIVAL_STATUS_INVALID } func ToArchivalStatus(t apiv1.ArchivalStatus) *types.ArchivalStatus { @@ -282,7 +282,7 @@ func ToArchivalStatus(t apiv1.ArchivalStatus) *types.ArchivalStatus { case apiv1.ArchivalStatus_ARCHIVAL_STATUS_ENABLED: return types.ArchivalStatusEnabled.Ptr() } - panic("unexpected enum value") + return nil } func FromBadBinaries(t *types.BadBinaries) *apiv1.BadBinaries { @@ -335,7 +335,7 @@ func FromCancelExternalWorkflowExecutionFailedCause(t *types.CancelExternalWorkf case types.CancelExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted: return apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED } - panic("unexpected enum value") + return apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID } func ToCancelExternalWorkflowExecutionFailedCause(t apiv1.CancelExternalWorkflowExecutionFailedCause) *types.CancelExternalWorkflowExecutionFailedCause { @@ -347,7 +347,7 @@ func ToCancelExternalWorkflowExecutionFailedCause(t apiv1.CancelExternalWorkflow case apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED: return types.CancelExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted.Ptr() } - panic("unexpected enum value") + return nil } func FromCancelTimerDecisionAttributes(t *types.CancelTimerDecisionAttributes) *apiv1.CancelTimerDecisionAttributes { @@ -474,7 +474,7 @@ func FromChildWorkflowExecutionFailedCause(t *types.ChildWorkflowExecutionFailed case types.ChildWorkflowExecutionFailedCauseWorkflowAlreadyRunning: return apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING } - panic("unexpected enum value") + return apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID } func ToChildWorkflowExecutionFailedCause(t apiv1.ChildWorkflowExecutionFailedCause) *types.ChildWorkflowExecutionFailedCause { @@ -484,7 +484,7 @@ func ToChildWorkflowExecutionFailedCause(t apiv1.ChildWorkflowExecutionFailedCau case apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING: return types.ChildWorkflowExecutionFailedCauseWorkflowAlreadyRunning.Ptr() } - panic("unexpected enum value") + return nil } func FromChildWorkflowExecutionFailedEventAttributes(t *types.ChildWorkflowExecutionFailedEventAttributes) *apiv1.ChildWorkflowExecutionFailedEventAttributes { @@ -644,7 +644,7 @@ func FromContinueAsNewInitiator(t *types.ContinueAsNewInitiator) apiv1.ContinueA case types.ContinueAsNewInitiatorCronSchedule: return apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_CRON_SCHEDULE } - panic("unexpected enum value") + return apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_INVALID } func ToContinueAsNewInitiator(t apiv1.ContinueAsNewInitiator) *types.ContinueAsNewInitiator { @@ -658,7 +658,7 @@ func ToContinueAsNewInitiator(t apiv1.ContinueAsNewInitiator) *types.ContinueAsN case apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_CRON_SCHEDULE: return types.ContinueAsNewInitiatorCronSchedule.Ptr() } - panic("unexpected enum value") + return nil } func FromContinueAsNewWorkflowExecutionDecisionAttributes(t *types.ContinueAsNewWorkflowExecutionDecisionAttributes) *apiv1.ContinueAsNewWorkflowExecutionDecisionAttributes { @@ -848,7 +848,7 @@ func FromDecisionTaskFailedCause(t *types.DecisionTaskFailedCause) apiv1.Decisio case types.DecisionTaskFailedCauseBadSearchAttributes: return apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SEARCH_ATTRIBUTES } - panic("unexpected enum value") + return apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_INVALID } func ToDecisionTaskFailedCause(t apiv1.DecisionTaskFailedCause) *types.DecisionTaskFailedCause { @@ -902,7 +902,7 @@ func ToDecisionTaskFailedCause(t apiv1.DecisionTaskFailedCause) *types.DecisionT case apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_BAD_SEARCH_ATTRIBUTES: return types.DecisionTaskFailedCauseBadSearchAttributes.Ptr() } - panic("unexpected enum value") + return nil } func FromDecisionTaskFailedEventAttributes(t *types.DecisionTaskFailedEventAttributes) *apiv1.DecisionTaskFailedEventAttributes { @@ -1070,6 +1070,7 @@ func FromDescribeDomainRequest(t *types.DescribeDomainRequest) *apiv1.DescribeDo if t.Name != nil { return &apiv1.DescribeDomainRequest{DescribeBy: &apiv1.DescribeDomainRequest_Name{Name: *t.Name}} } + // TODO: Remove this panic and decide on an error behaviour panic("neither oneof field is set for DescribeDomainRequest") } @@ -1083,6 +1084,7 @@ func ToDescribeDomainRequest(t *apiv1.DescribeDomainRequest) *types.DescribeDoma case *apiv1.DescribeDomainRequest_Name: return &types.DescribeDomainRequest{Name: common.StringPtr(describeBy.Name)} } + // TODO: Remove this panic and decide on an error behaviour panic("neither oneof field is set for DescribeDomainRequest") } @@ -1351,7 +1353,7 @@ func FromDomainStatus(t *types.DomainStatus) apiv1.DomainStatus { case types.DomainStatusDeleted: return apiv1.DomainStatus_DOMAIN_STATUS_DELETED } - panic("unexpected enum value") + return apiv1.DomainStatus_DOMAIN_STATUS_INVALID } func ToDomainStatus(t apiv1.DomainStatus) *types.DomainStatus { @@ -1365,7 +1367,7 @@ func ToDomainStatus(t apiv1.DomainStatus) *types.DomainStatus { case apiv1.DomainStatus_DOMAIN_STATUS_DELETED: return types.DomainStatusDeleted.Ptr() } - panic("unexpected enum value") + return nil } func FromEncodingType(t *types.EncodingType) apiv1.EncodingType { @@ -1378,7 +1380,7 @@ func FromEncodingType(t *types.EncodingType) apiv1.EncodingType { case types.EncodingTypeJSON: return apiv1.EncodingType_ENCODING_TYPE_JSON } - panic("unexpected enum value") + return apiv1.EncodingType_ENCODING_TYPE_INVALID } func ToEncodingType(t apiv1.EncodingType) *types.EncodingType { @@ -1390,9 +1392,9 @@ func ToEncodingType(t apiv1.EncodingType) *types.EncodingType { case apiv1.EncodingType_ENCODING_TYPE_JSON: return types.EncodingTypeJSON.Ptr() case apiv1.EncodingType_ENCODING_TYPE_PROTO3: - panic("not supported yet") + return nil } - panic("unexpected enum value") + return nil } func FromEventFilterType(t *types.HistoryEventFilterType) apiv1.EventFilterType { @@ -1405,7 +1407,7 @@ func FromEventFilterType(t *types.HistoryEventFilterType) apiv1.EventFilterType case types.HistoryEventFilterTypeCloseEvent: return apiv1.EventFilterType_EVENT_FILTER_TYPE_CLOSE_EVENT } - panic("unexpected enum value") + return apiv1.EventFilterType_EVENT_FILTER_TYPE_INVALID } func ToEventFilterType(t apiv1.EventFilterType) *types.HistoryEventFilterType { @@ -1417,7 +1419,7 @@ func ToEventFilterType(t apiv1.EventFilterType) *types.HistoryEventFilterType { case apiv1.EventFilterType_EVENT_FILTER_TYPE_CLOSE_EVENT: return types.HistoryEventFilterTypeCloseEvent.Ptr() } - panic("unexpected enum value") + return nil } func FromExternalWorkflowExecutionCancelRequestedEventAttributes(t *types.ExternalWorkflowExecutionCancelRequestedEventAttributes) *apiv1.ExternalWorkflowExecutionCancelRequestedEventAttributes { @@ -1648,13 +1650,13 @@ func FromIndexedValueType(t types.IndexedValueType) apiv1.IndexedValueType { case types.IndexedValueTypeDatetime: return apiv1.IndexedValueType_INDEXED_VALUE_TYPE_DATETIME } - panic("unexpected enum value") + return apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID } func ToIndexedValueType(t apiv1.IndexedValueType) types.IndexedValueType { switch t { case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID: - panic("received IndexedValueType_INDEXED_VALUE_TYPE_INVALID") + return types.IndexedValueTypeString case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_STRING: return types.IndexedValueTypeString case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_KEYWORD: @@ -1668,7 +1670,7 @@ func ToIndexedValueType(t apiv1.IndexedValueType) types.IndexedValueType { case apiv1.IndexedValueType_INDEXED_VALUE_TYPE_DATETIME: return types.IndexedValueTypeDatetime } - panic("unexpected enum value") + return types.IndexedValueTypeString } func FromListArchivedWorkflowExecutionsRequest(t *types.ListArchivedWorkflowExecutionsRequest) *apiv1.ListArchivedWorkflowExecutionsRequest { @@ -1995,7 +1997,7 @@ func FromParentClosePolicy(t *types.ParentClosePolicy) apiv1.ParentClosePolicy { case types.ParentClosePolicyTerminate: return apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_TERMINATE } - panic("unexpected enum value") + return apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID } func ToParentClosePolicy(t apiv1.ParentClosePolicy) *types.ParentClosePolicy { @@ -2009,7 +2011,7 @@ func ToParentClosePolicy(t apiv1.ParentClosePolicy) *types.ParentClosePolicy { case apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_TERMINATE: return types.ParentClosePolicyTerminate.Ptr() } - panic("unexpected enum value") + return nil } func FromPendingActivityInfo(t *types.PendingActivityInfo) *apiv1.PendingActivityInfo { @@ -2069,7 +2071,7 @@ func FromPendingActivityState(t *types.PendingActivityState) apiv1.PendingActivi case types.PendingActivityStateCancelRequested: return apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_CANCEL_REQUESTED } - panic("unexpected enum value") + return apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_INVALID } func ToPendingActivityState(t apiv1.PendingActivityState) *types.PendingActivityState { @@ -2083,7 +2085,7 @@ func ToPendingActivityState(t apiv1.PendingActivityState) *types.PendingActivity case apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_CANCEL_REQUESTED: return types.PendingActivityStateCancelRequested.Ptr() } - panic("unexpected enum value") + return nil } func FromPendingChildExecutionInfo(t *types.PendingChildExecutionInfo) *apiv1.PendingChildExecutionInfo { @@ -2151,7 +2153,7 @@ func FromPendingDecisionState(t *types.PendingDecisionState) apiv1.PendingDecisi case types.PendingDecisionStateStarted: return apiv1.PendingDecisionState_PENDING_DECISION_STATE_STARTED } - panic("unexpected enum value") + return apiv1.PendingDecisionState_PENDING_DECISION_STATE_INVALID } func ToPendingDecisionState(t apiv1.PendingDecisionState) *types.PendingDecisionState { @@ -2163,7 +2165,7 @@ func ToPendingDecisionState(t apiv1.PendingDecisionState) *types.PendingDecision case apiv1.PendingDecisionState_PENDING_DECISION_STATE_STARTED: return types.PendingDecisionStateStarted.Ptr() } - panic("unexpected enum value") + return nil } func FromPollForActivityTaskRequest(t *types.PollForActivityTaskRequest) *apiv1.PollForActivityTaskRequest { @@ -2346,7 +2348,7 @@ func FromQueryConsistencyLevel(t *types.QueryConsistencyLevel) apiv1.QueryConsis case types.QueryConsistencyLevelStrong: return apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_STRONG } - panic("unexpected enum value") + return apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_INVALID } func ToQueryConsistencyLevel(t apiv1.QueryConsistencyLevel) *types.QueryConsistencyLevel { @@ -2358,7 +2360,7 @@ func ToQueryConsistencyLevel(t apiv1.QueryConsistencyLevel) *types.QueryConsiste case apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_STRONG: return types.QueryConsistencyLevelStrong.Ptr() } - panic("unexpected enum value") + return nil } func FromQueryRejectCondition(t *types.QueryRejectCondition) apiv1.QueryRejectCondition { @@ -2371,7 +2373,7 @@ func FromQueryRejectCondition(t *types.QueryRejectCondition) apiv1.QueryRejectCo case types.QueryRejectConditionNotCompletedCleanly: return apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY } - panic("unexpected enum value") + return apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_INVALID } func ToQueryRejectCondition(t apiv1.QueryRejectCondition) *types.QueryRejectCondition { @@ -2383,7 +2385,7 @@ func ToQueryRejectCondition(t apiv1.QueryRejectCondition) *types.QueryRejectCond case apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_COMPLETED_CLEANLY: return types.QueryRejectConditionNotCompletedCleanly.Ptr() } - panic("unexpected enum value") + return nil } func FromQueryRejected(t *types.QueryRejected) *apiv1.QueryRejected { @@ -2414,7 +2416,7 @@ func FromQueryResultType(t *types.QueryResultType) apiv1.QueryResultType { case types.QueryResultTypeFailed: return apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED } - panic("unexpected enum value") + return apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID } func ToQueryResultType(t apiv1.QueryResultType) *types.QueryResultType { @@ -2426,7 +2428,7 @@ func ToQueryResultType(t apiv1.QueryResultType) *types.QueryResultType { case apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED: return types.QueryResultTypeFailed.Ptr() } - panic("unexpected enum value") + return nil } func FromQueryWorkflowRequest(t *types.QueryWorkflowRequest) *apiv1.QueryWorkflowRequest { @@ -3175,7 +3177,7 @@ func FromQueryTaskCompletedType(t *types.QueryTaskCompletedType) apiv1.QueryResu case types.QueryTaskCompletedTypeFailed: return apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED } - panic("unexpected enum value") + return apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID } func ToQueryTaskCompletedType(t apiv1.QueryResultType) *types.QueryTaskCompletedType { @@ -3187,7 +3189,7 @@ func ToQueryTaskCompletedType(t apiv1.QueryResultType) *types.QueryTaskCompleted case apiv1.QueryResultType_QUERY_RESULT_TYPE_FAILED: return types.QueryTaskCompletedTypeFailed.Ptr() } - panic("unexpected enum value") + return nil } func FromRetryPolicy(t *types.RetryPolicy) *apiv1.RetryPolicy { @@ -3378,7 +3380,7 @@ func FromSignalExternalWorkflowExecutionFailedCause(t *types.SignalExternalWorkf case types.SignalExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted: return apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED } - panic("unexpected enum value") + return apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID } func ToSignalExternalWorkflowExecutionFailedCause(t apiv1.SignalExternalWorkflowExecutionFailedCause) *types.SignalExternalWorkflowExecutionFailedCause { @@ -3390,7 +3392,7 @@ func ToSignalExternalWorkflowExecutionFailedCause(t apiv1.SignalExternalWorkflow case apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_COMPLETED: return types.SignalExternalWorkflowExecutionFailedCauseWorkflowAlreadyCompleted.Ptr() } - panic("unexpected enum value") + return nil } func FromSignalExternalWorkflowExecutionFailedEventAttributes(t *types.SignalExternalWorkflowExecutionFailedEventAttributes) *apiv1.SignalExternalWorkflowExecutionFailedEventAttributes { @@ -4014,7 +4016,7 @@ func FromTaskListKind(t *types.TaskListKind) apiv1.TaskListKind { case types.TaskListKindEphemeral: return apiv1.TaskListKind_TASK_LIST_KIND_EPHEMERAL } - panic("unexpected enum value") + return apiv1.TaskListKind_TASK_LIST_KIND_INVALID } func ToTaskListKind(t apiv1.TaskListKind) *types.TaskListKind { @@ -4028,7 +4030,7 @@ func ToTaskListKind(t apiv1.TaskListKind) *types.TaskListKind { case apiv1.TaskListKind_TASK_LIST_KIND_EPHEMERAL: return types.TaskListKindEphemeral.Ptr() } - panic("unexpected enum value") + return nil } func FromTaskListMetadata(t *types.TaskListMetadata) *apiv1.TaskListMetadata { @@ -4125,7 +4127,7 @@ func FromTaskListType(t *types.TaskListType) apiv1.TaskListType { case types.TaskListTypeActivity: return apiv1.TaskListType_TASK_LIST_TYPE_ACTIVITY } - panic("unexpected enum value") + return apiv1.TaskListType_TASK_LIST_TYPE_INVALID } func ToTaskListType(t apiv1.TaskListType) *types.TaskListType { @@ -4137,7 +4139,7 @@ func ToTaskListType(t apiv1.TaskListType) *types.TaskListType { case apiv1.TaskListType_TASK_LIST_TYPE_ACTIVITY: return types.TaskListTypeActivity.Ptr() } - panic("unexpected enum value") + return nil } func FromTerminateWorkflowExecutionRequest(t *types.TerminateWorkflowExecutionRequest) *apiv1.TerminateWorkflowExecutionRequest { @@ -4182,7 +4184,7 @@ func FromTimeoutType(t *types.TimeoutType) apiv1.TimeoutType { case types.TimeoutTypeHeartbeat: return apiv1.TimeoutType_TIMEOUT_TYPE_HEARTBEAT } - panic("unexpected enum value") + return apiv1.TimeoutType_TIMEOUT_TYPE_INVALID } func ToTimeoutType(t apiv1.TimeoutType) *types.TimeoutType { @@ -4198,7 +4200,7 @@ func ToTimeoutType(t apiv1.TimeoutType) *types.TimeoutType { case apiv1.TimeoutType_TIMEOUT_TYPE_HEARTBEAT: return types.TimeoutTypeHeartbeat.Ptr() } - panic("unexpected enum value") + return nil } func FromDecisionTaskTimedOutCause(t *types.DecisionTaskTimedOutCause) apiv1.DecisionTaskTimedOutCause { @@ -4211,7 +4213,7 @@ func FromDecisionTaskTimedOutCause(t *types.DecisionTaskTimedOutCause) apiv1.Dec case types.DecisionTaskTimedOutCauseReset: return apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_RESET } - panic("unexpected enum value") + return apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_INVALID } func ToDecisionTaskTimedOutCause(t apiv1.DecisionTaskTimedOutCause) *types.DecisionTaskTimedOutCause { @@ -4223,7 +4225,7 @@ func ToDecisionTaskTimedOutCause(t apiv1.DecisionTaskTimedOutCause) *types.Decis case apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_RESET: return types.DecisionTaskTimedOutCauseReset.Ptr() } - panic("unexpected enum value") + return nil } func FromTimerCanceledEventAttributes(t *types.TimerCanceledEventAttributes) *apiv1.TimerCanceledEventAttributes { @@ -4786,7 +4788,7 @@ func FromWorkflowExecutionCloseStatus(t *types.WorkflowExecutionCloseStatus) api case types.WorkflowExecutionCloseStatusTimedOut: return apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_TIMED_OUT } - panic("unexpected enum value") + return apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_INVALID } func ToWorkflowExecutionCloseStatus(t apiv1.WorkflowExecutionCloseStatus) *types.WorkflowExecutionCloseStatus { @@ -4806,7 +4808,7 @@ func ToWorkflowExecutionCloseStatus(t apiv1.WorkflowExecutionCloseStatus) *types case apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_TIMED_OUT: return types.WorkflowExecutionCloseStatusTimedOut.Ptr() } - panic("unexpected enum value") + return nil } func FromWorkflowExecutionCompletedEventAttributes(t *types.WorkflowExecutionCompletedEventAttributes) *apiv1.WorkflowExecutionCompletedEventAttributes { @@ -5220,7 +5222,7 @@ func FromWorkflowIDReusePolicy(t *types.WorkflowIDReusePolicy) apiv1.WorkflowIdR case types.WorkflowIDReusePolicyTerminateIfRunning: return apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING } - panic("unexpected enum value") + return apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_INVALID } func ToWorkflowIDReusePolicy(t apiv1.WorkflowIdReusePolicy) *types.WorkflowIDReusePolicy { @@ -5236,7 +5238,7 @@ func ToWorkflowIDReusePolicy(t apiv1.WorkflowIdReusePolicy) *types.WorkflowIDReu case apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_TERMINATE_IF_RUNNING: return types.WorkflowIDReusePolicyTerminateIfRunning.Ptr() } - panic("unexpected enum value") + return nil } func FromWorkflowQuery(t *types.WorkflowQuery) *apiv1.WorkflowQuery { diff --git a/common/types/mapper/proto/enum_test.go b/common/types/mapper/proto/enum_test.go index c0ef294b9e8..80a24c14718 100644 --- a/common/types/mapper/proto/enum_test.go +++ b/common/types/mapper/proto/enum_test.go @@ -44,9 +44,63 @@ func TestTaskSource(t *testing.T) { } { assert.Equal(t, item, ToTaskSource(FromTaskSource(item))) } - assert.Panics(t, func() { ToTaskSource(sharedv1.TaskSource(UnknownValue)) }) - assert.Panics(t, func() { FromTaskSource(types.TaskSource(UnknownValue).Ptr()) }) } + +func TestToTaskSource(t *testing.T) { + cases := []struct { + name string + input sharedv1.TaskSource + expected *types.TaskSource + }{ + { + name: "when input is invalid it should return nil", + input: sharedv1.TaskSource_TASK_SOURCE_INVALID, + }, + { + name: "when input is out of range it should return nil", + input: UnknownValue, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: sharedv1.TaskSource_TASK_SOURCE_HISTORY, + expected: types.TaskSourceHistory.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToTaskSource(tc.input)) + }) + } +} + +func TestFromTaskSource(t *testing.T) { + cases := []struct { + name string + input *types.TaskSource + expected sharedv1.TaskSource + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.TaskSourceHistory.Ptr(), + expected: sharedv1.TaskSource_TASK_SOURCE_HISTORY, + }, + { + name: "when input is out of range it should return INVALID", + input: types.TaskSource(UnknownValue).Ptr(), + expected: sharedv1.TaskSource_TASK_SOURCE_INVALID, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromTaskSource(tc.input)) + }) + } +} + func TestDLQType(t *testing.T) { for _, item := range []*types.DLQType{ nil, @@ -55,20 +109,135 @@ func TestDLQType(t *testing.T) { } { assert.Equal(t, item, ToDLQType(FromDLQType(item))) } - assert.Panics(t, func() { ToDLQType(adminv1.DLQType(UnknownValue)) }) - assert.Panics(t, func() { FromDLQType(types.DLQType(UnknownValue).Ptr()) }) } + +func TestToDLQType(t *testing.T) { + cases := []struct { + name string + input adminv1.DLQType + expected *types.DLQType + }{ + { + name: "when input is invalid it should return nil", + input: adminv1.DLQType_DLQ_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: UnknownValue, + expected: nil, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: adminv1.DLQType_DLQ_TYPE_REPLICATION, + expected: types.DLQTypeReplication.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToDLQType(tc.input)) + }) + } +} + +func TestFromDLQType(t *testing.T) { + cases := []struct { + name string + input *types.DLQType + expected adminv1.DLQType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: adminv1.DLQType_DLQ_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.DLQType(UnknownValue).Ptr(), + expected: adminv1.DLQType_DLQ_TYPE_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.DLQTypeReplication.Ptr(), + expected: adminv1.DLQType_DLQ_TYPE_REPLICATION, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromDLQType(tc.input)) + }) + } +} + func TestDomainOperation(t *testing.T) { for _, item := range []*types.DomainOperation{ nil, types.DomainOperationCreate.Ptr(), types.DomainOperationUpdate.Ptr(), + types.DomainOperationDelete.Ptr(), } { assert.Equal(t, item, ToDomainOperation(FromDomainOperation(item))) } - assert.Panics(t, func() { ToDomainOperation(adminv1.DomainOperation(UnknownValue)) }) - assert.Panics(t, func() { FromDomainOperation(types.DomainOperation(UnknownValue).Ptr()) }) } + +func TestToDomainOperation(t *testing.T) { + cases := []struct { + name string + input adminv1.DomainOperation + expected *types.DomainOperation + }{ + { + name: "when input is invalid it should return nil", + input: adminv1.DomainOperation_DOMAIN_OPERATION_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: UnknownValue, + expected: nil, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: adminv1.DomainOperation_DOMAIN_OPERATION_CREATE, + expected: types.DomainOperationCreate.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToDomainOperation(tc.input)) + }) + } +} + +func TestFromDomainOperation(t *testing.T) { + cases := []struct { + name string + input *types.DomainOperation + expected adminv1.DomainOperation + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: adminv1.DomainOperation_DOMAIN_OPERATION_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.DomainOperation(UnknownValue).Ptr(), + expected: adminv1.DomainOperation_DOMAIN_OPERATION_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.DomainOperationCreate.Ptr(), + expected: adminv1.DomainOperation_DOMAIN_OPERATION_CREATE, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromDomainOperation(tc.input)) + }) + } +} + func TestReplicationTaskType(t *testing.T) { for _, item := range []*types.ReplicationTaskType{ nil, @@ -82,8 +251,64 @@ func TestReplicationTaskType(t *testing.T) { } { assert.Equal(t, item, ToReplicationTaskType(FromReplicationTaskType(item))) } - assert.Panics(t, func() { ToReplicationTaskType(adminv1.ReplicationTaskType(UnknownValue)) }) - assert.Panics(t, func() { FromReplicationTaskType(types.ReplicationTaskType(UnknownValue).Ptr()) }) +} + +func TestToReplicationTaskType(t *testing.T) { + cases := []struct { + name string + input adminv1.ReplicationTaskType + expected *types.ReplicationTaskType + }{ + { + name: "when input is invalid it should return nil", + input: adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: adminv1.ReplicationTaskType(UnknownValue), + expected: nil, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_DOMAIN, + expected: types.ReplicationTaskTypeDomain.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToReplicationTaskType(tc.input)) + }) + } +} + +func TestFromReplicationTaskType(t *testing.T) { + cases := []struct { + name string + input *types.ReplicationTaskType + expected adminv1.ReplicationTaskType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.ReplicationTaskType(UnknownValue).Ptr(), + expected: adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.ReplicationTaskTypeDomain.Ptr(), + expected: adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_DOMAIN, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromReplicationTaskType(tc.input)) + }) + } } func TestArchivalStatus(t *testing.T) { for _, item := range []*types.ArchivalStatus{ @@ -93,8 +318,64 @@ func TestArchivalStatus(t *testing.T) { } { assert.Equal(t, item, ToArchivalStatus(FromArchivalStatus(item))) } - assert.Panics(t, func() { ToArchivalStatus(apiv1.ArchivalStatus(UnknownValue)) }) - assert.Panics(t, func() { FromArchivalStatus(types.ArchivalStatus(UnknownValue).Ptr()) }) +} + +func TestToArchivalStatus(t *testing.T) { + cases := []struct { + name string + input apiv1.ArchivalStatus + expected *types.ArchivalStatus + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.ArchivalStatus_ARCHIVAL_STATUS_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.ArchivalStatus(UnknownValue), + expected: nil, + }, + { + name: "when input is disabled it should return the correctly mapped value", + input: apiv1.ArchivalStatus_ARCHIVAL_STATUS_DISABLED, + expected: types.ArchivalStatusDisabled.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToArchivalStatus(tc.input)) + }) + } +} + +func TestFromArchivalStatus(t *testing.T) { + cases := []struct { + name string + input *types.ArchivalStatus + expected apiv1.ArchivalStatus + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.ArchivalStatus_ARCHIVAL_STATUS_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.ArchivalStatus(UnknownValue).Ptr(), + expected: apiv1.ArchivalStatus_ARCHIVAL_STATUS_INVALID, + }, + { + name: "when input is disabled it should return the correctly mapped value", + input: types.ArchivalStatusDisabled.Ptr(), + expected: apiv1.ArchivalStatus_ARCHIVAL_STATUS_DISABLED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromArchivalStatus(tc.input)) + }) + } } func TestCancelExternalWorkflowExecutionFailedCause(t *testing.T) { for _, item := range []*types.CancelExternalWorkflowExecutionFailedCause{ @@ -104,12 +385,64 @@ func TestCancelExternalWorkflowExecutionFailedCause(t *testing.T) { } { assert.Equal(t, item, ToCancelExternalWorkflowExecutionFailedCause(FromCancelExternalWorkflowExecutionFailedCause(item))) } - assert.Panics(t, func() { - ToCancelExternalWorkflowExecutionFailedCause(apiv1.CancelExternalWorkflowExecutionFailedCause(UnknownValue)) - }) - assert.Panics(t, func() { - FromCancelExternalWorkflowExecutionFailedCause(types.CancelExternalWorkflowExecutionFailedCause(UnknownValue).Ptr()) - }) +} + +func TestToCancelExternalWorkflowExecutionFailedCause(t *testing.T) { + cases := []struct { + name string + input apiv1.CancelExternalWorkflowExecutionFailedCause + expected *types.CancelExternalWorkflowExecutionFailedCause + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.CancelExternalWorkflowExecutionFailedCause(UnknownValue), + expected: nil, + }, + { + name: "when input is unknown external workflow execution it should return the correctly mapped value", + input: apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION, + expected: types.CancelExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToCancelExternalWorkflowExecutionFailedCause(tc.input)) + }) + } +} + +func TestFromCancelExternalWorkflowExecutionFailedCause(t *testing.T) { + cases := []struct { + name string + input *types.CancelExternalWorkflowExecutionFailedCause + expected apiv1.CancelExternalWorkflowExecutionFailedCause + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.CancelExternalWorkflowExecutionFailedCause(UnknownValue).Ptr(), + expected: apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + }, + { + name: "when input is unknown external workflow execution it should return the correctly mapped value", + input: types.CancelExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr(), + expected: apiv1.CancelExternalWorkflowExecutionFailedCause_CANCEL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromCancelExternalWorkflowExecutionFailedCause(tc.input)) + }) + } } func TestChildWorkflowExecutionFailedCause(t *testing.T) { for _, item := range []*types.ChildWorkflowExecutionFailedCause{ @@ -118,10 +451,64 @@ func TestChildWorkflowExecutionFailedCause(t *testing.T) { } { assert.Equal(t, item, ToChildWorkflowExecutionFailedCause(FromChildWorkflowExecutionFailedCause(item))) } - assert.Panics(t, func() { ToChildWorkflowExecutionFailedCause(apiv1.ChildWorkflowExecutionFailedCause(UnknownValue)) }) - assert.Panics(t, func() { - FromChildWorkflowExecutionFailedCause(types.ChildWorkflowExecutionFailedCause(UnknownValue).Ptr()) - }) +} + +func TestToChildWorkflowExecutionFailedCause(t *testing.T) { + cases := []struct { + name string + input apiv1.ChildWorkflowExecutionFailedCause + expected *types.ChildWorkflowExecutionFailedCause + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.ChildWorkflowExecutionFailedCause(UnknownValue), + expected: nil, + }, + { + name: "when input is workflow already running it should return the correctly mapped value", + input: apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING, + expected: types.ChildWorkflowExecutionFailedCauseWorkflowAlreadyRunning.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToChildWorkflowExecutionFailedCause(tc.input)) + }) + } +} + +func TestFromChildWorkflowExecutionFailedCause(t *testing.T) { + cases := []struct { + name string + input *types.ChildWorkflowExecutionFailedCause + expected apiv1.ChildWorkflowExecutionFailedCause + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.ChildWorkflowExecutionFailedCause(UnknownValue).Ptr(), + expected: apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + }, + { + name: "when input is workflow already running it should return the correctly mapped value", + input: types.ChildWorkflowExecutionFailedCauseWorkflowAlreadyRunning.Ptr(), + expected: apiv1.ChildWorkflowExecutionFailedCause_CHILD_WORKFLOW_EXECUTION_FAILED_CAUSE_WORKFLOW_ALREADY_RUNNING, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromChildWorkflowExecutionFailedCause(tc.input)) + }) + } } func TestContinueAsNewInitiator(t *testing.T) { for _, item := range []*types.ContinueAsNewInitiator{ @@ -132,8 +519,64 @@ func TestContinueAsNewInitiator(t *testing.T) { } { assert.Equal(t, item, ToContinueAsNewInitiator(FromContinueAsNewInitiator(item))) } - assert.Panics(t, func() { ToContinueAsNewInitiator(apiv1.ContinueAsNewInitiator(UnknownValue)) }) - assert.Panics(t, func() { FromContinueAsNewInitiator(types.ContinueAsNewInitiator(UnknownValue).Ptr()) }) +} + +func TestToContinueAsNewInitiator(t *testing.T) { + cases := []struct { + name string + input apiv1.ContinueAsNewInitiator + expected *types.ContinueAsNewInitiator + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.ContinueAsNewInitiator(UnknownValue), + expected: nil, + }, + { + name: "when input is decider it should return the correctly mapped value", + input: apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_DECIDER, + expected: types.ContinueAsNewInitiatorDecider.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToContinueAsNewInitiator(tc.input)) + }) + } +} + +func TestFromContinueAsNewInitiator(t *testing.T) { + cases := []struct { + name string + input *types.ContinueAsNewInitiator + expected apiv1.ContinueAsNewInitiator + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.ContinueAsNewInitiator(UnknownValue).Ptr(), + expected: apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_INVALID, + }, + { + name: "when input is decider it should return the correctly mapped value", + input: types.ContinueAsNewInitiatorDecider.Ptr(), + expected: apiv1.ContinueAsNewInitiator_CONTINUE_AS_NEW_INITIATOR_DECIDER, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromContinueAsNewInitiator(tc.input)) + }) + } } func TestCrossClusterTaskFailedCause(t *testing.T) { for _, item := range []*types.CrossClusterTaskFailedCause{ @@ -147,8 +590,64 @@ func TestCrossClusterTaskFailedCause(t *testing.T) { } { assert.Equal(t, item, ToCrossClusterTaskFailedCause(FromCrossClusterTaskFailedCause(item))) } - assert.Panics(t, func() { ToCrossClusterTaskFailedCause(adminv1.CrossClusterTaskFailedCause(UnknownValue)) }) - assert.Panics(t, func() { FromCrossClusterTaskFailedCause(types.CrossClusterTaskFailedCause(UnknownValue).Ptr()) }) +} + +func TestToCrossClusterTaskFailedCause(t *testing.T) { + cases := []struct { + name string + input adminv1.CrossClusterTaskFailedCause + expected *types.CrossClusterTaskFailedCause + }{ + { + name: "when input is invalid it should return nil", + input: adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: adminv1.CrossClusterTaskFailedCause(UnknownValue), + expected: nil, + }, + { + name: "when input is domain not active it should return the correctly mapped value", + input: adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_ACTIVE, + expected: types.CrossClusterTaskFailedCauseDomainNotActive.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToCrossClusterTaskFailedCause(tc.input)) + }) + } +} + +func TestFromCrossClusterTaskFailedCause(t *testing.T) { + cases := []struct { + name string + input *types.CrossClusterTaskFailedCause + expected adminv1.CrossClusterTaskFailedCause + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.CrossClusterTaskFailedCause(UnknownValue).Ptr(), + expected: adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID, + }, + { + name: "when input is domain not active it should return the correctly mapped value", + input: types.CrossClusterTaskFailedCauseDomainNotActive.Ptr(), + expected: adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_DOMAIN_NOT_ACTIVE, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromCrossClusterTaskFailedCause(tc.input)) + }) + } } func TestDecisionTaskFailedCause(t *testing.T) { for _, item := range []*types.DecisionTaskFailedCause{ @@ -179,8 +678,64 @@ func TestDecisionTaskFailedCause(t *testing.T) { } { assert.Equal(t, item, ToDecisionTaskFailedCause(FromDecisionTaskFailedCause(item))) } - assert.Panics(t, func() { ToDecisionTaskFailedCause(apiv1.DecisionTaskFailedCause(UnknownValue)) }) - assert.Panics(t, func() { FromDecisionTaskFailedCause(types.DecisionTaskFailedCause(UnknownValue).Ptr()) }) +} + +func TestToDecisionTaskFailedCause(t *testing.T) { + cases := []struct { + name string + input apiv1.DecisionTaskFailedCause + expected *types.DecisionTaskFailedCause + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.DecisionTaskFailedCause(UnknownValue), + expected: nil, + }, + { + name: "when input is unhandled decision it should return the correctly mapped value", + input: apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_UNHANDLED_DECISION, + expected: types.DecisionTaskFailedCauseUnhandledDecision.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToDecisionTaskFailedCause(tc.input)) + }) + } +} + +func TestFromDecisionTaskFailedCause(t *testing.T) { + cases := []struct { + name string + input *types.DecisionTaskFailedCause + expected apiv1.DecisionTaskFailedCause + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.DecisionTaskFailedCause(UnknownValue).Ptr(), + expected: apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_INVALID, + }, + { + name: "when input is unhandled decision it should return the correctly mapped value", + input: types.DecisionTaskFailedCauseUnhandledDecision.Ptr(), + expected: apiv1.DecisionTaskFailedCause_DECISION_TASK_FAILED_CAUSE_UNHANDLED_DECISION, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromDecisionTaskFailedCause(tc.input)) + }) + } } func TestDomainStatus(t *testing.T) { for _, item := range []*types.DomainStatus{ @@ -191,8 +746,62 @@ func TestDomainStatus(t *testing.T) { } { assert.Equal(t, item, ToDomainStatus(FromDomainStatus(item))) } - assert.Panics(t, func() { ToDomainStatus(apiv1.DomainStatus(UnknownValue)) }) - assert.Panics(t, func() { FromDomainStatus(types.DomainStatus(UnknownValue).Ptr()) }) +} + +func TestToDomainStatus(t *testing.T) { + cases := []struct { + name string + input apiv1.DomainStatus + expected *types.DomainStatus + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.DomainStatus_DOMAIN_STATUS_INVALID, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.DomainStatus(UnknownValue), + }, + { + name: "when input is valid it should return the correctly mapped value", + input: apiv1.DomainStatus_DOMAIN_STATUS_REGISTERED, + expected: types.DomainStatusRegistered.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToDomainStatus(tc.input)) + }) + } +} + +func TestFromDomainStatus(t *testing.T) { + cases := []struct { + name string + input *types.DomainStatus + expected apiv1.DomainStatus + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.DomainStatus_DOMAIN_STATUS_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.DomainStatus(UnknownValue).Ptr(), + expected: apiv1.DomainStatus_DOMAIN_STATUS_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.DomainStatusRegistered.Ptr(), + expected: apiv1.DomainStatus_DOMAIN_STATUS_REGISTERED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromDomainStatus(tc.input)) + }) + } } func TestEncodingType(t *testing.T) { for _, item := range []*types.EncodingType{ @@ -202,8 +811,62 @@ func TestEncodingType(t *testing.T) { } { assert.Equal(t, item, ToEncodingType(FromEncodingType(item))) } - assert.Panics(t, func() { ToEncodingType(apiv1.EncodingType(UnknownValue)) }) - assert.Panics(t, func() { FromEncodingType(types.EncodingType(UnknownValue).Ptr()) }) +} + +func TestToEncodingType(t *testing.T) { + cases := []struct { + name string + input apiv1.EncodingType + expected *types.EncodingType + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.EncodingType_ENCODING_TYPE_INVALID, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.EncodingType(UnknownValue), + }, + { + name: "when input is valid it should return the correctly mapped value", + input: apiv1.EncodingType_ENCODING_TYPE_THRIFTRW, + expected: types.EncodingTypeThriftRW.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToEncodingType(tc.input)) + }) + } +} + +func TestFromEncodingType(t *testing.T) { + cases := []struct { + name string + input *types.EncodingType + expected apiv1.EncodingType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.EncodingType_ENCODING_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.EncodingType(UnknownValue).Ptr(), + expected: apiv1.EncodingType_ENCODING_TYPE_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.EncodingTypeThriftRW.Ptr(), + expected: apiv1.EncodingType_ENCODING_TYPE_THRIFTRW, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromEncodingType(tc.input)) + }) + } } func TestEventFilterType(t *testing.T) { for _, item := range []*types.HistoryEventFilterType{ @@ -213,8 +876,62 @@ func TestEventFilterType(t *testing.T) { } { assert.Equal(t, item, ToEventFilterType(FromEventFilterType(item))) } - assert.Panics(t, func() { ToEventFilterType(apiv1.EventFilterType(UnknownValue)) }) - assert.Panics(t, func() { FromEventFilterType(types.HistoryEventFilterType(UnknownValue).Ptr()) }) +} + +func TestToEventFilterType(t *testing.T) { + cases := []struct { + name string + input apiv1.EventFilterType + expected *types.HistoryEventFilterType + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.EventFilterType_EVENT_FILTER_TYPE_INVALID, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.EventFilterType(UnknownValue), + }, + { + name: "when input is valid it should return the correctly mapped value", + input: apiv1.EventFilterType_EVENT_FILTER_TYPE_ALL_EVENT, + expected: types.HistoryEventFilterTypeAllEvent.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToEventFilterType(tc.input)) + }) + } +} + +func TestFromEventFilterType(t *testing.T) { + cases := []struct { + name string + input *types.HistoryEventFilterType + expected apiv1.EventFilterType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.EventFilterType_EVENT_FILTER_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.HistoryEventFilterType(UnknownValue).Ptr(), + expected: apiv1.EventFilterType_EVENT_FILTER_TYPE_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.HistoryEventFilterTypeAllEvent.Ptr(), + expected: apiv1.EventFilterType_EVENT_FILTER_TYPE_ALL_EVENT, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromEventFilterType(tc.input)) + }) + } } func TestIndexedValueType(t *testing.T) { for _, item := range []types.IndexedValueType{ @@ -227,9 +944,59 @@ func TestIndexedValueType(t *testing.T) { } { assert.Equal(t, item, ToIndexedValueType(FromIndexedValueType(item))) } - assert.Panics(t, func() { ToIndexedValueType(apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID) }) - assert.Panics(t, func() { ToIndexedValueType(apiv1.IndexedValueType(UnknownValue)) }) - assert.Panics(t, func() { FromIndexedValueType(types.IndexedValueType(UnknownValue)) }) +} + +func TestToIndexedValueType(t *testing.T) { + cases := []struct { + name string + input apiv1.IndexedValueType + expected types.IndexedValueType + }{ + { + name: "when input is invalid it should return string", + input: apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID, + expected: types.IndexedValueTypeString, + }, + { + name: "when input is out of range it should return string", + input: apiv1.IndexedValueType(UnknownValue), + expected: types.IndexedValueTypeString, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: apiv1.IndexedValueType_INDEXED_VALUE_TYPE_STRING, + expected: types.IndexedValueTypeString, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToIndexedValueType(tc.input)) + }) + } +} + +func TestFromIndexedValueType(t *testing.T) { + cases := []struct { + name string + input types.IndexedValueType + expected apiv1.IndexedValueType + }{ + { + name: "when input is out of range it should return INVALID", + input: types.IndexedValueType(UnknownValue), + expected: apiv1.IndexedValueType_INDEXED_VALUE_TYPE_INVALID, + }, + { + name: "when input is valid it should return the correctly mapped value", + input: types.IndexedValueTypeString, + expected: apiv1.IndexedValueType_INDEXED_VALUE_TYPE_STRING, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromIndexedValueType(tc.input)) + }) + } } func TestParentClosePolicy(t *testing.T) { for _, item := range []*types.ParentClosePolicy{ @@ -240,8 +1007,64 @@ func TestParentClosePolicy(t *testing.T) { } { assert.Equal(t, item, ToParentClosePolicy(FromParentClosePolicy(item))) } - assert.Panics(t, func() { ToParentClosePolicy(apiv1.ParentClosePolicy(UnknownValue)) }) - assert.Panics(t, func() { FromParentClosePolicy(types.ParentClosePolicy(UnknownValue).Ptr()) }) +} + +func TestToParentClosePolicy(t *testing.T) { + cases := []struct { + name string + input apiv1.ParentClosePolicy + expected *types.ParentClosePolicy + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.ParentClosePolicy(UnknownValue), + expected: nil, + }, + { + name: "when input is abandon it should return the correctly mapped value", + input: apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_ABANDON, + expected: types.ParentClosePolicyAbandon.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToParentClosePolicy(tc.input)) + }) + } +} + +func TestFromParentClosePolicy(t *testing.T) { + cases := []struct { + name string + input *types.ParentClosePolicy + expected apiv1.ParentClosePolicy + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.ParentClosePolicy(UnknownValue).Ptr(), + expected: apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_INVALID, + }, + { + name: "when input is abandon it should return the correctly mapped value", + input: types.ParentClosePolicyAbandon.Ptr(), + expected: apiv1.ParentClosePolicy_PARENT_CLOSE_POLICY_ABANDON, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromParentClosePolicy(tc.input)) + }) + } } func TestPendingActivityState(t *testing.T) { for _, item := range []*types.PendingActivityState{ @@ -252,8 +1075,64 @@ func TestPendingActivityState(t *testing.T) { } { assert.Equal(t, item, ToPendingActivityState(FromPendingActivityState(item))) } - assert.Panics(t, func() { ToPendingActivityState(apiv1.PendingActivityState(UnknownValue)) }) - assert.Panics(t, func() { FromPendingActivityState(types.PendingActivityState(UnknownValue).Ptr()) }) +} + +func TestToPendingActivityState(t *testing.T) { + cases := []struct { + name string + input apiv1.PendingActivityState + expected *types.PendingActivityState + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.PendingActivityState(UnknownValue), + expected: nil, + }, + { + name: "when input is scheduled it should return the correctly mapped value", + input: apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_SCHEDULED, + expected: types.PendingActivityStateScheduled.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToPendingActivityState(tc.input)) + }) + } +} + +func TestFromPendingActivityState(t *testing.T) { + cases := []struct { + name string + input *types.PendingActivityState + expected apiv1.PendingActivityState + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.PendingActivityState(UnknownValue).Ptr(), + expected: apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_INVALID, + }, + { + name: "when input is scheduled it should return the correctly mapped value", + input: types.PendingActivityStateScheduled.Ptr(), + expected: apiv1.PendingActivityState_PENDING_ACTIVITY_STATE_SCHEDULED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromPendingActivityState(tc.input)) + }) + } } func TestPendingDecisionState(t *testing.T) { for _, item := range []*types.PendingDecisionState{ @@ -263,8 +1142,64 @@ func TestPendingDecisionState(t *testing.T) { } { assert.Equal(t, item, ToPendingDecisionState(FromPendingDecisionState(item))) } - assert.Panics(t, func() { ToPendingDecisionState(apiv1.PendingDecisionState(UnknownValue)) }) - assert.Panics(t, func() { FromPendingDecisionState(types.PendingDecisionState(UnknownValue).Ptr()) }) +} + +func TestToPendingDecisionState(t *testing.T) { + cases := []struct { + name string + input apiv1.PendingDecisionState + expected *types.PendingDecisionState + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.PendingDecisionState_PENDING_DECISION_STATE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.PendingDecisionState(UnknownValue), + expected: nil, + }, + { + name: "when input is scheduled it should return the correctly mapped value", + input: apiv1.PendingDecisionState_PENDING_DECISION_STATE_SCHEDULED, + expected: types.PendingDecisionStateScheduled.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToPendingDecisionState(tc.input)) + }) + } +} + +func TestFromPendingDecisionState(t *testing.T) { + cases := []struct { + name string + input *types.PendingDecisionState + expected apiv1.PendingDecisionState + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.PendingDecisionState_PENDING_DECISION_STATE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.PendingDecisionState(UnknownValue).Ptr(), + expected: apiv1.PendingDecisionState_PENDING_DECISION_STATE_INVALID, + }, + { + name: "when input is scheduled it should return the correctly mapped value", + input: types.PendingDecisionStateScheduled.Ptr(), + expected: apiv1.PendingDecisionState_PENDING_DECISION_STATE_SCHEDULED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromPendingDecisionState(tc.input)) + }) + } } func TestQueryConsistencyLevel(t *testing.T) { for _, item := range []*types.QueryConsistencyLevel{ @@ -274,8 +1209,64 @@ func TestQueryConsistencyLevel(t *testing.T) { } { assert.Equal(t, item, ToQueryConsistencyLevel(FromQueryConsistencyLevel(item))) } - assert.Panics(t, func() { ToQueryConsistencyLevel(apiv1.QueryConsistencyLevel(UnknownValue)) }) - assert.Panics(t, func() { FromQueryConsistencyLevel(types.QueryConsistencyLevel(UnknownValue).Ptr()) }) +} + +func TestToQueryConsistencyLevel(t *testing.T) { + cases := []struct { + name string + input apiv1.QueryConsistencyLevel + expected *types.QueryConsistencyLevel + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.QueryConsistencyLevel(UnknownValue), + expected: nil, + }, + { + name: "when input is eventual it should return the correctly mapped value", + input: apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_EVENTUAL, + expected: types.QueryConsistencyLevelEventual.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToQueryConsistencyLevel(tc.input)) + }) + } +} + +func TestFromQueryConsistencyLevel(t *testing.T) { + cases := []struct { + name string + input *types.QueryConsistencyLevel + expected apiv1.QueryConsistencyLevel + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.QueryConsistencyLevel(UnknownValue).Ptr(), + expected: apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_INVALID, + }, + { + name: "when input is eventual it should return the correctly mapped value", + input: types.QueryConsistencyLevelEventual.Ptr(), + expected: apiv1.QueryConsistencyLevel_QUERY_CONSISTENCY_LEVEL_EVENTUAL, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromQueryConsistencyLevel(tc.input)) + }) + } } func TestQueryRejectCondition(t *testing.T) { for _, item := range []*types.QueryRejectCondition{ @@ -285,8 +1276,64 @@ func TestQueryRejectCondition(t *testing.T) { } { assert.Equal(t, item, ToQueryRejectCondition(FromQueryRejectCondition(item))) } - assert.Panics(t, func() { ToQueryRejectCondition(apiv1.QueryRejectCondition(UnknownValue)) }) - assert.Panics(t, func() { FromQueryRejectCondition(types.QueryRejectCondition(UnknownValue).Ptr()) }) +} + +func TestToQueryRejectCondition(t *testing.T) { + cases := []struct { + name string + input apiv1.QueryRejectCondition + expected *types.QueryRejectCondition + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.QueryRejectCondition(UnknownValue), + expected: nil, + }, + { + name: "when input is not open it should return the correctly mapped value", + input: apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_OPEN, + expected: types.QueryRejectConditionNotOpen.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToQueryRejectCondition(tc.input)) + }) + } +} + +func TestFromQueryRejectCondition(t *testing.T) { + cases := []struct { + name string + input *types.QueryRejectCondition + expected apiv1.QueryRejectCondition + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.QueryRejectCondition(UnknownValue).Ptr(), + expected: apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_INVALID, + }, + { + name: "when input is not open it should return the correctly mapped value", + input: types.QueryRejectConditionNotOpen.Ptr(), + expected: apiv1.QueryRejectCondition_QUERY_REJECT_CONDITION_NOT_OPEN, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromQueryRejectCondition(tc.input)) + }) + } } func TestQueryResultType(t *testing.T) { for _, item := range []*types.QueryResultType{ @@ -296,8 +1343,64 @@ func TestQueryResultType(t *testing.T) { } { assert.Equal(t, item, ToQueryResultType(FromQueryResultType(item))) } - assert.Panics(t, func() { ToQueryResultType(apiv1.QueryResultType(UnknownValue)) }) - assert.Panics(t, func() { FromQueryResultType(types.QueryResultType(UnknownValue).Ptr()) }) +} + +func TestToQueryResultType(t *testing.T) { + cases := []struct { + name string + input apiv1.QueryResultType + expected *types.QueryResultType + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.QueryResultType(UnknownValue), + expected: nil, + }, + { + name: "when input is answered it should return the correctly mapped value", + input: apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED, + expected: types.QueryResultTypeAnswered.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToQueryResultType(tc.input)) + }) + } +} + +func TestFromQueryResultType(t *testing.T) { + cases := []struct { + name string + input *types.QueryResultType + expected apiv1.QueryResultType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.QueryResultType(UnknownValue).Ptr(), + expected: apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID, + }, + { + name: "when input is answered it should return the correctly mapped value", + input: types.QueryResultTypeAnswered.Ptr(), + expected: apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromQueryResultType(tc.input)) + }) + } } func TestQueryTaskCompletedType(t *testing.T) { for _, item := range []*types.QueryTaskCompletedType{ @@ -307,8 +1410,64 @@ func TestQueryTaskCompletedType(t *testing.T) { } { assert.Equal(t, item, ToQueryTaskCompletedType(FromQueryTaskCompletedType(item))) } - assert.Panics(t, func() { ToQueryTaskCompletedType(apiv1.QueryResultType(UnknownValue)) }) - assert.Panics(t, func() { FromQueryTaskCompletedType(types.QueryTaskCompletedType(UnknownValue).Ptr()) }) +} + +func TestToQueryTaskCompletedType(t *testing.T) { + cases := []struct { + name string + input apiv1.QueryResultType + expected *types.QueryTaskCompletedType + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.QueryResultType(UnknownValue), + expected: nil, + }, + { + name: "when input is completed it should return the correctly mapped value", + input: apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED, + expected: types.QueryTaskCompletedTypeCompleted.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToQueryTaskCompletedType(tc.input)) + }) + } +} + +func TestFromQueryTaskCompletedType(t *testing.T) { + cases := []struct { + name string + input *types.QueryTaskCompletedType + expected apiv1.QueryResultType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.QueryTaskCompletedType(UnknownValue).Ptr(), + expected: apiv1.QueryResultType_QUERY_RESULT_TYPE_INVALID, + }, + { + name: "when input is completed it should return the correctly mapped value", + input: types.QueryTaskCompletedTypeCompleted.Ptr(), + expected: apiv1.QueryResultType_QUERY_RESULT_TYPE_ANSWERED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromQueryTaskCompletedType(tc.input)) + }) + } } func TestSignalExternalWorkflowExecutionFailedCause(t *testing.T) { for _, item := range []*types.SignalExternalWorkflowExecutionFailedCause{ @@ -318,13 +1477,66 @@ func TestSignalExternalWorkflowExecutionFailedCause(t *testing.T) { } { assert.Equal(t, item, ToSignalExternalWorkflowExecutionFailedCause(FromSignalExternalWorkflowExecutionFailedCause(item))) } - assert.Panics(t, func() { - ToSignalExternalWorkflowExecutionFailedCause(apiv1.SignalExternalWorkflowExecutionFailedCause(UnknownValue)) - }) - assert.Panics(t, func() { - FromSignalExternalWorkflowExecutionFailedCause(types.SignalExternalWorkflowExecutionFailedCause(UnknownValue).Ptr()) - }) } + +func TestToSignalExternalWorkflowExecutionFailedCause(t *testing.T) { + cases := []struct { + name string + input apiv1.SignalExternalWorkflowExecutionFailedCause + expected *types.SignalExternalWorkflowExecutionFailedCause + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.SignalExternalWorkflowExecutionFailedCause(UnknownValue), + expected: nil, + }, + { + name: "when input is unknown external workflow execution it should return the correctly mapped value", + input: apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION, + expected: types.SignalExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToSignalExternalWorkflowExecutionFailedCause(tc.input)) + }) + } +} + +func TestFromSignalExternalWorkflowExecutionFailedCause(t *testing.T) { + cases := []struct { + name string + input *types.SignalExternalWorkflowExecutionFailedCause + expected apiv1.SignalExternalWorkflowExecutionFailedCause + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.SignalExternalWorkflowExecutionFailedCause(UnknownValue).Ptr(), + expected: apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_INVALID, + }, + { + name: "when input is unknown external workflow execution it should return the correctly mapped value", + input: types.SignalExternalWorkflowExecutionFailedCauseUnknownExternalWorkflowExecution.Ptr(), + expected: apiv1.SignalExternalWorkflowExecutionFailedCause_SIGNAL_EXTERNAL_WORKFLOW_EXECUTION_FAILED_CAUSE_UNKNOWN_EXTERNAL_WORKFLOW_EXECUTION, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromSignalExternalWorkflowExecutionFailedCause(tc.input)) + }) + } +} + func TestTaskListKind(t *testing.T) { for _, item := range []*types.TaskListKind{ nil, @@ -334,9 +1546,66 @@ func TestTaskListKind(t *testing.T) { } { assert.Equal(t, item, ToTaskListKind(FromTaskListKind(item))) } - assert.Panics(t, func() { ToTaskListKind(apiv1.TaskListKind(UnknownValue)) }) - assert.Panics(t, func() { FromTaskListKind(types.TaskListKind(UnknownValue).Ptr()) }) } + +func TestToTaskListKind(t *testing.T) { + cases := []struct { + name string + input apiv1.TaskListKind + expected *types.TaskListKind + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.TaskListKind_TASK_LIST_KIND_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.TaskListKind(UnknownValue), + expected: nil, + }, + { + name: "when input is normal it should return the correctly mapped value", + input: apiv1.TaskListKind_TASK_LIST_KIND_NORMAL, + expected: types.TaskListKindNormal.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToTaskListKind(tc.input)) + }) + } +} + +func TestFromTaskListKind(t *testing.T) { + cases := []struct { + name string + input *types.TaskListKind + expected apiv1.TaskListKind + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.TaskListKind_TASK_LIST_KIND_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.TaskListKind(UnknownValue).Ptr(), + expected: apiv1.TaskListKind_TASK_LIST_KIND_INVALID, + }, + { + name: "when input is normal it should return the correctly mapped value", + input: types.TaskListKindNormal.Ptr(), + expected: apiv1.TaskListKind_TASK_LIST_KIND_NORMAL, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromTaskListKind(tc.input)) + }) + } +} + func TestTaskListType(t *testing.T) { for _, item := range []*types.TaskListType{ nil, @@ -345,8 +1614,64 @@ func TestTaskListType(t *testing.T) { } { assert.Equal(t, item, ToTaskListType(FromTaskListType(item))) } - assert.Panics(t, func() { ToTaskListType(apiv1.TaskListType(UnknownValue)) }) - assert.Panics(t, func() { FromTaskListType(types.TaskListType(UnknownValue).Ptr()) }) +} + +func TestToTaskListType(t *testing.T) { + cases := []struct { + name string + input apiv1.TaskListType + expected *types.TaskListType + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.TaskListType_TASK_LIST_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.TaskListType(UnknownValue), + expected: nil, + }, + { + name: "when input is decision it should return the correctly mapped value", + input: apiv1.TaskListType_TASK_LIST_TYPE_DECISION, + expected: types.TaskListTypeDecision.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToTaskListType(tc.input)) + }) + } +} + +func TestFromTaskListType(t *testing.T) { + cases := []struct { + name string + input *types.TaskListType + expected apiv1.TaskListType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.TaskListType_TASK_LIST_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.TaskListType(UnknownValue).Ptr(), + expected: apiv1.TaskListType_TASK_LIST_TYPE_INVALID, + }, + { + name: "when input is decision it should return the correctly mapped value", + input: types.TaskListTypeDecision.Ptr(), + expected: apiv1.TaskListType_TASK_LIST_TYPE_DECISION, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromTaskListType(tc.input)) + }) + } } func TestTimeoutType(t *testing.T) { for _, item := range []*types.TimeoutType{ @@ -358,8 +1683,64 @@ func TestTimeoutType(t *testing.T) { } { assert.Equal(t, item, ToTimeoutType(FromTimeoutType(item))) } - assert.Panics(t, func() { ToTimeoutType(apiv1.TimeoutType(UnknownValue)) }) - assert.Panics(t, func() { FromTimeoutType(types.TimeoutType(UnknownValue).Ptr()) }) +} + +func TestToTimeoutType(t *testing.T) { + cases := []struct { + name string + input apiv1.TimeoutType + expected *types.TimeoutType + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.TimeoutType_TIMEOUT_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.TimeoutType(UnknownValue), + expected: nil, + }, + { + name: "when input is start to close it should return the correctly mapped value", + input: apiv1.TimeoutType_TIMEOUT_TYPE_START_TO_CLOSE, + expected: types.TimeoutTypeStartToClose.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToTimeoutType(tc.input)) + }) + } +} + +func TestFromTimeoutType(t *testing.T) { + cases := []struct { + name string + input *types.TimeoutType + expected apiv1.TimeoutType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.TimeoutType_TIMEOUT_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.TimeoutType(UnknownValue).Ptr(), + expected: apiv1.TimeoutType_TIMEOUT_TYPE_INVALID, + }, + { + name: "when input is start to close it should return the correctly mapped value", + input: types.TimeoutTypeStartToClose.Ptr(), + expected: apiv1.TimeoutType_TIMEOUT_TYPE_START_TO_CLOSE, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromTimeoutType(tc.input)) + }) + } } func TestDecisionTaskTimedOutCause(t *testing.T) { for _, item := range []*types.DecisionTaskTimedOutCause{ @@ -369,8 +1750,64 @@ func TestDecisionTaskTimedOutCause(t *testing.T) { } { assert.Equal(t, item, ToDecisionTaskTimedOutCause(FromDecisionTaskTimedOutCause(item))) } - assert.Panics(t, func() { ToDecisionTaskTimedOutCause(apiv1.DecisionTaskTimedOutCause(UnknownValue)) }) - assert.Panics(t, func() { FromDecisionTaskTimedOutCause(types.DecisionTaskTimedOutCause(UnknownValue).Ptr()) }) +} + +func TestToDecisionTaskTimedOutCause(t *testing.T) { + cases := []struct { + name string + input apiv1.DecisionTaskTimedOutCause + expected *types.DecisionTaskTimedOutCause + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.DecisionTaskTimedOutCause(UnknownValue), + expected: nil, + }, + { + name: "when input is timeout it should return the correctly mapped value", + input: apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_TIMEOUT, + expected: types.DecisionTaskTimedOutCauseTimeout.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToDecisionTaskTimedOutCause(tc.input)) + }) + } +} + +func TestFromDecisionTaskTimedOutCause(t *testing.T) { + cases := []struct { + name string + input *types.DecisionTaskTimedOutCause + expected apiv1.DecisionTaskTimedOutCause + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.DecisionTaskTimedOutCause(UnknownValue).Ptr(), + expected: apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_INVALID, + }, + { + name: "when input is timeout it should return the correctly mapped value", + input: types.DecisionTaskTimedOutCauseTimeout.Ptr(), + expected: apiv1.DecisionTaskTimedOutCause_DECISION_TASK_TIMED_OUT_CAUSE_TIMEOUT, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromDecisionTaskTimedOutCause(tc.input)) + }) + } } func TestWorkflowExecutionCloseStatus(t *testing.T) { for _, item := range []*types.WorkflowExecutionCloseStatus{ @@ -384,8 +1821,64 @@ func TestWorkflowExecutionCloseStatus(t *testing.T) { } { assert.Equal(t, item, ToWorkflowExecutionCloseStatus(FromWorkflowExecutionCloseStatus(item))) } - assert.Panics(t, func() { ToWorkflowExecutionCloseStatus(apiv1.WorkflowExecutionCloseStatus(UnknownValue)) }) - assert.Panics(t, func() { FromWorkflowExecutionCloseStatus(types.WorkflowExecutionCloseStatus(UnknownValue).Ptr()) }) +} + +func TestToWorkflowExecutionCloseStatus(t *testing.T) { + cases := []struct { + name string + input apiv1.WorkflowExecutionCloseStatus + expected *types.WorkflowExecutionCloseStatus + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.WorkflowExecutionCloseStatus(UnknownValue), + expected: nil, + }, + { + name: "when input is completed it should return the correctly mapped value", + input: apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_COMPLETED, + expected: types.WorkflowExecutionCloseStatusCompleted.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToWorkflowExecutionCloseStatus(tc.input)) + }) + } +} + +func TestFromWorkflowExecutionCloseStatus(t *testing.T) { + cases := []struct { + name string + input *types.WorkflowExecutionCloseStatus + expected apiv1.WorkflowExecutionCloseStatus + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.WorkflowExecutionCloseStatus(UnknownValue).Ptr(), + expected: apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_INVALID, + }, + { + name: "when input is completed it should return the correctly mapped value", + input: types.WorkflowExecutionCloseStatusCompleted.Ptr(), + expected: apiv1.WorkflowExecutionCloseStatus_WORKFLOW_EXECUTION_CLOSE_STATUS_COMPLETED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromWorkflowExecutionCloseStatus(tc.input)) + }) + } } func TestWorkflowIDReusePolicy(t *testing.T) { for _, item := range []*types.WorkflowIDReusePolicy{ @@ -397,8 +1890,64 @@ func TestWorkflowIDReusePolicy(t *testing.T) { } { assert.Equal(t, item, ToWorkflowIDReusePolicy(FromWorkflowIDReusePolicy(item))) } - assert.Panics(t, func() { ToWorkflowIDReusePolicy(apiv1.WorkflowIdReusePolicy(UnknownValue)) }) - assert.Panics(t, func() { FromWorkflowIDReusePolicy(types.WorkflowIDReusePolicy(UnknownValue).Ptr()) }) +} + +func TestToWorkflowIDReusePolicy(t *testing.T) { + cases := []struct { + name string + input apiv1.WorkflowIdReusePolicy + expected *types.WorkflowIDReusePolicy + }{ + { + name: "when input is invalid it should return nil", + input: apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: apiv1.WorkflowIdReusePolicy(UnknownValue), + expected: nil, + }, + { + name: "when input is allow duplicate failed only it should return the correctly mapped value", + input: apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY, + expected: types.WorkflowIDReusePolicyAllowDuplicateFailedOnly.Ptr(), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToWorkflowIDReusePolicy(tc.input)) + }) + } +} + +func TestFromWorkflowIDReusePolicy(t *testing.T) { + cases := []struct { + name string + input *types.WorkflowIDReusePolicy + expected apiv1.WorkflowIdReusePolicy + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: types.WorkflowIDReusePolicy(UnknownValue).Ptr(), + expected: apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_INVALID, + }, + { + name: "when input is allow duplicate failed only it should return the correctly mapped value", + input: types.WorkflowIDReusePolicyAllowDuplicateFailedOnly.Ptr(), + expected: apiv1.WorkflowIdReusePolicy_WORKFLOW_ID_REUSE_POLICY_ALLOW_DUPLICATE_FAILED_ONLY, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromWorkflowIDReusePolicy(tc.input)) + }) + } } func TestWorkflowState(t *testing.T) { for _, item := range []*int32{ @@ -412,8 +1961,64 @@ func TestWorkflowState(t *testing.T) { } { assert.Equal(t, item, ToWorkflowState(FromWorkflowState(item))) } - assert.Panics(t, func() { ToWorkflowState(sharedv1.WorkflowState(UnknownValue)) }) - assert.Panics(t, func() { FromWorkflowState(common.Int32Ptr(UnknownValue)) }) +} + +func TestToWorkflowState(t *testing.T) { + cases := []struct { + name string + input sharedv1.WorkflowState + expected *int32 + }{ + { + name: "when input is invalid it should return nil", + input: sharedv1.WorkflowState_WORKFLOW_STATE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: sharedv1.WorkflowState(UnknownValue), + expected: nil, + }, + { + name: "when input is created it should return the correctly mapped value", + input: sharedv1.WorkflowState_WORKFLOW_STATE_CREATED, + expected: common.Int32Ptr(persistence.WorkflowStateCreated), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToWorkflowState(tc.input)) + }) + } +} + +func TestFromWorkflowState(t *testing.T) { + cases := []struct { + name string + input *int32 + expected sharedv1.WorkflowState + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: sharedv1.WorkflowState_WORKFLOW_STATE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: common.Int32Ptr(UnknownValue), + expected: sharedv1.WorkflowState_WORKFLOW_STATE_INVALID, + }, + { + name: "when input is created it should return the correctly mapped value", + input: common.Int32Ptr(persistence.WorkflowStateCreated), + expected: sharedv1.WorkflowState_WORKFLOW_STATE_CREATED, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromWorkflowState(tc.input)) + }) + } } func TestTaskType(t *testing.T) { for _, item := range []*int32{ @@ -425,6 +2030,62 @@ func TestTaskType(t *testing.T) { } { assert.Equal(t, item, ToTaskType(FromTaskType(item))) } - assert.Panics(t, func() { ToTaskType(adminv1.TaskType(UnknownValue)) }) - assert.Panics(t, func() { FromTaskType(common.Int32Ptr(UnknownValue)) }) +} + +func TestToTaskType(t *testing.T) { + cases := []struct { + name string + input adminv1.TaskType + expected *int32 + }{ + { + name: "when input is invalid it should return nil", + input: adminv1.TaskType_TASK_TYPE_INVALID, + expected: nil, + }, + { + name: "when input is out of range it should return nil", + input: adminv1.TaskType(UnknownValue), + expected: nil, + }, + { + name: "when input is transfer it should return the correctly mapped value", + input: adminv1.TaskType_TASK_TYPE_TRANSFER, + expected: common.Int32Ptr(int32(constants.TaskTypeTransfer)), + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, ToTaskType(tc.input)) + }) + } +} + +func TestFromTaskType(t *testing.T) { + cases := []struct { + name string + input *int32 + expected adminv1.TaskType + }{ + { + name: "when input is nil it should return INVALID", + input: nil, + expected: adminv1.TaskType_TASK_TYPE_INVALID, + }, + { + name: "when input is out of range it should return INVALID", + input: common.Int32Ptr(UnknownValue), + expected: adminv1.TaskType_TASK_TYPE_INVALID, + }, + { + name: "when input is transfer it should return the correctly mapped value", + input: common.Int32Ptr(int32(constants.TaskTypeTransfer)), + expected: adminv1.TaskType_TASK_TYPE_TRANSFER, + }, + } + for _, tc := range cases { + t.Run(tc.name, func(t *testing.T) { + assert.Equal(t, tc.expected, FromTaskType(tc.input)) + }) + } } diff --git a/common/types/mapper/proto/shared.go b/common/types/mapper/proto/shared.go index 4e0d2253729..1e86a633709 100644 --- a/common/types/mapper/proto/shared.go +++ b/common/types/mapper/proto/shared.go @@ -254,7 +254,7 @@ func FromTaskSource(t *types.TaskSource) sharedv1.TaskSource { case types.TaskSourceDbBacklog: return sharedv1.TaskSource_TASK_SOURCE_DB_BACKLOG } - panic("unexpected enum value") + return sharedv1.TaskSource_TASK_SOURCE_INVALID } func ToTaskSource(t sharedv1.TaskSource) *types.TaskSource { @@ -266,7 +266,7 @@ func ToTaskSource(t sharedv1.TaskSource) *types.TaskSource { case sharedv1.TaskSource_TASK_SOURCE_DB_BACKLOG: return types.TaskSourceDbBacklog.Ptr() } - panic("unexpected enum value") + return nil } func FromTransientDecisionInfo(t *types.TransientDecisionInfo) *sharedv1.TransientDecisionInfo { @@ -367,7 +367,7 @@ func FromWorkflowState(t *int32) sharedv1.WorkflowState { case persistence.WorkflowStateCorrupted: return sharedv1.WorkflowState_WORKFLOW_STATE_CORRUPTED } - panic("unexpected enum value") + return sharedv1.WorkflowState_WORKFLOW_STATE_INVALID } func ToWorkflowState(t sharedv1.WorkflowState) *int32 { @@ -393,7 +393,7 @@ func ToWorkflowState(t sharedv1.WorkflowState) *int32 { v := int32(persistence.WorkflowStateCorrupted) return &v } - panic("unexpected enum value") + return nil } func FromHostInfoArray(t []*types.HostInfo) []*adminv1.HostInfo { @@ -472,7 +472,7 @@ func FromDLQType(t *types.DLQType) adminv1.DLQType { case types.DLQTypeDomain: return adminv1.DLQType_DLQ_TYPE_DOMAIN } - panic("unexpected enum value") + return adminv1.DLQType_DLQ_TYPE_INVALID } func ToDLQType(t adminv1.DLQType) *types.DLQType { @@ -484,7 +484,7 @@ func ToDLQType(t adminv1.DLQType) *types.DLQType { case adminv1.DLQType_DLQ_TYPE_DOMAIN: return types.DLQTypeDomain.Ptr() } - panic("unexpected enum value") + return nil } func FromDomainOperation(t *types.DomainOperation) adminv1.DomainOperation { @@ -499,7 +499,7 @@ func FromDomainOperation(t *types.DomainOperation) adminv1.DomainOperation { case types.DomainOperationDelete: return adminv1.DomainOperation_DOMAIN_OPERATION_DELETE } - panic("unexpected enum value") + return adminv1.DomainOperation_DOMAIN_OPERATION_INVALID } func ToDomainOperation(t adminv1.DomainOperation) *types.DomainOperation { @@ -513,7 +513,7 @@ func ToDomainOperation(t adminv1.DomainOperation) *types.DomainOperation { case adminv1.DomainOperation_DOMAIN_OPERATION_DELETE: return types.DomainOperationDelete.Ptr() } - panic("unexpected enum value") + return nil } func FromDomainTaskAttributes(t *types.DomainTaskAttributes) *adminv1.DomainTaskAttributes { @@ -705,7 +705,7 @@ func FromReplicationTaskType(t *types.ReplicationTaskType) adminv1.ReplicationTa case types.ReplicationTaskTypeFailoverMarker: return adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_FAILOVER_MARKER } - panic("unexpected enum value") + return adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_INVALID } func ToReplicationTaskType(t adminv1.ReplicationTaskType) *types.ReplicationTaskType { @@ -727,7 +727,7 @@ func ToReplicationTaskType(t adminv1.ReplicationTaskType) *types.ReplicationTask case adminv1.ReplicationTaskType_REPLICATION_TASK_TYPE_FAILOVER_MARKER: return types.ReplicationTaskTypeFailoverMarker.Ptr() } - panic("unexpected enum value") + return nil } func FromReplicationToken(t *types.ReplicationToken) *adminv1.ReplicationToken { @@ -1001,7 +1001,7 @@ func FromTaskType(t *int32) adminv1.TaskType { case constants.TaskTypeCrossCluster: return adminv1.TaskType_TASK_TYPE_CROSS_CLUSTER } - panic("unexpected enum value") + return adminv1.TaskType_TASK_TYPE_INVALID } func ToTaskType(t adminv1.TaskType) *int32 { @@ -1017,7 +1017,7 @@ func ToTaskType(t adminv1.TaskType) *int32 { case adminv1.TaskType_TASK_TYPE_CROSS_CLUSTER: return common.Int32Ptr(int32(constants.TaskTypeCrossCluster)) } - panic("unexpected enum value") + return nil } func FromFailoverMarkerTokenArray(t []*types.FailoverMarkerToken) []*adminv1.FailoverMarkerToken { @@ -1105,7 +1105,7 @@ func FromCrossClusterTaskType(t *types.CrossClusterTaskType) adminv1.CrossCluste case types.CrossClusterTaskTypeApplyParentPolicy: return adminv1.CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_APPLY_PARENT_CLOSE_POLICY } - panic("unexpected enum value") + return adminv1.CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_INVALID } // ToCrossClusterTaskType converts proto CrossClusterTaskType type to internal @@ -1124,7 +1124,7 @@ func ToCrossClusterTaskType(t adminv1.CrossClusterTaskType) *types.CrossClusterT case adminv1.CrossClusterTaskType_CROSS_CLUSTER_TASK_TYPE_APPLY_PARENT_CLOSE_POLICY: return types.CrossClusterTaskTypeApplyParentPolicy.Ptr() } - panic("unexpected enum value") + return nil } // FromCrossClusterTaskFailedCause converts internal CrossClusterTaskFailedCause type to proto @@ -1146,7 +1146,7 @@ func FromCrossClusterTaskFailedCause(t *types.CrossClusterTaskFailedCause) admin case types.CrossClusterTaskFailedCauseUncategorized: return adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_UNCATEGORIZED } - panic("unexpected enum value") + return adminv1.CrossClusterTaskFailedCause_CROSS_CLUSTER_TASK_FAILED_CAUSE_INVALID } // ToCrossClusterTaskFailedCause converts proto CrossClusterTaskFailedCause type to internal @@ -1168,7 +1168,7 @@ func ToCrossClusterTaskFailedCause(t adminv1.CrossClusterTaskFailedCause) *types return types.CrossClusterTaskFailedCauseUncategorized.Ptr() } - panic("unexpected enum value") + return nil } // FromGetTaskFailedCause converts internal GetTaskFailedCause type to proto @@ -1186,7 +1186,7 @@ func FromGetTaskFailedCause(t *types.GetTaskFailedCause) adminv1.GetTaskFailedCa case types.GetTaskFailedCauseUncategorized: return adminv1.GetTaskFailedCause_GET_TASK_FAILED_CAUSE_UNCATEGORIZED } - panic("unexpected enum value") + return adminv1.GetTaskFailedCause_GET_TASK_FAILED_CAUSE_INVALID } // ToGetTaskFailedCause converts proto GetTaskFailedCause type to internal @@ -1203,7 +1203,7 @@ func ToGetTaskFailedCause(t adminv1.GetTaskFailedCause) *types.GetTaskFailedCaus case adminv1.GetTaskFailedCause_GET_TASK_FAILED_CAUSE_UNCATEGORIZED: return types.GetTaskFailedCauseUncategorized.Ptr() } - panic("unexpected enum value") + return nil } // FromCrossClusterTaskInfo converts internal CrossClusterTaskInfo type to proto