diff --git a/src/main/java/com/uber/cadence/internal/compatibility/thrift/TypeMapper.java b/src/main/java/com/uber/cadence/internal/compatibility/thrift/TypeMapper.java index 66b582469..af696f16f 100644 --- a/src/main/java/com/uber/cadence/internal/compatibility/thrift/TypeMapper.java +++ b/src/main/java/com/uber/cadence/internal/compatibility/thrift/TypeMapper.java @@ -500,7 +500,9 @@ static DescribeDomainResponse describeDomainResponseDomain(com.uber.cadence.api. domainInfo.setOwnerEmail(t.getOwnerEmail()); domainInfo.setData(t.getDataMap()); domainInfo.setUuid(t.getId()); + DomainConfiguration domainConfiguration = new DomainConfiguration(); + res.setConfiguration(domainConfiguration); domainConfiguration.setWorkflowExecutionRetentionPeriodInDays( durationToDays(t.getWorkflowExecutionRetentionPeriod())); @@ -511,8 +513,10 @@ static DescribeDomainResponse describeDomainResponseDomain(com.uber.cadence.api. domainConfiguration.setVisibilityArchivalStatus( archivalStatus(t.getVisibilityArchivalStatus())); domainConfiguration.setVisibilityArchivalURI(t.getVisibilityArchivalUri()); + DomainReplicationConfiguration domainReplicationConfiguration = new DomainReplicationConfiguration(); + res.setReplicationConfiguration(domainReplicationConfiguration); domainReplicationConfiguration.setActiveClusterName(t.getActiveClusterName()); domainReplicationConfiguration.setClusters( diff --git a/src/test/java/com/uber/cadence/internal/compatibility/ProtoObjects.java b/src/test/java/com/uber/cadence/internal/compatibility/ProtoObjects.java index b8391e794..c0da91447 100644 --- a/src/test/java/com/uber/cadence/internal/compatibility/ProtoObjects.java +++ b/src/test/java/com/uber/cadence/internal/compatibility/ProtoObjects.java @@ -20,6 +20,7 @@ import com.google.protobuf.DoubleValue; import com.google.protobuf.Duration; import com.google.protobuf.FieldMask; +import com.google.protobuf.Int64Value; import com.google.protobuf.Timestamp; import com.uber.cadence.api.v1.*; import java.util.Map; @@ -90,6 +91,143 @@ public final class ProtoObjects { ResetPoints.newBuilder().addPoints(RESET_POINT_INFO).build(); public static final ClusterReplicationConfiguration CLUSTER_REPLICATION_CONFIGURATION = ClusterReplicationConfiguration.newBuilder().setClusterName("cluster").build(); + public static final PollerInfo POLLER_INFO = + PollerInfo.newBuilder() + .setIdentity("identity") + .setLastAccessTime(timestampNanos(1)) + .setRatePerSecond(2.0) + .build(); + public static final TaskIDBlock TASK_ID_BLOCK = + TaskIDBlock.newBuilder().setStartId(1).setEndId(2).build(); + public static final TaskListStatus TASK_LIST_STATUS = + TaskListStatus.newBuilder() + .setTaskIdBlock(TASK_ID_BLOCK) + .setAckLevel(1) + .setBacklogCountHint(2) + .setReadLevel(3) + .setRatePerSecond(4.0) + .build(); + public static final WorkflowExecutionConfiguration WORKFLOW_EXECUTION_CONFIGURATION = + WorkflowExecutionConfiguration.newBuilder() + .setTaskList(TASK_LIST) + .setExecutionStartToCloseTimeout(seconds(1)) + .setTaskStartToCloseTimeout(seconds(2)) + .build(); + public static final WorkflowExecutionInfo WORKFLOW_EXECUTION_INFO = + WorkflowExecutionInfo.newBuilder() + .setWorkflowExecution(WORKFLOW_EXECUTION) + .setType(WORKFLOW_TYPE) + .setStartTime(timestampNanos(1)) + .setCloseTime(timestampNanos(2)) + .setCloseStatus(WorkflowExecutionCloseStatus.WORKFLOW_EXECUTION_CLOSE_STATUS_FAILED) + .setHistoryLength(3) + .setParentExecutionInfo( + ParentExecutionInfo.newBuilder() + .setDomainId("parentDomainId") + .setWorkflowExecution(PARENT_WORKFLOW_EXECUTION) + .setInitiatedId(1) + .build()) + .setExecutionTime(timestampNanos(4)) + .setMemo(MEMO) + .setSearchAttributes(SEARCH_ATTRIBUTES) + .setAutoResetPoints(RESET_POINTS) + .setTaskList(TASK_LIST.getName()) + .setIsCron(true) + .build(); + public static final PendingActivityInfo PENDING_ACTIVITY_INFO = + PendingActivityInfo.newBuilder() + .setActivityId("activityId") + .setActivityType(ACTIVITY_TYPE) + .setState(PendingActivityState.PENDING_ACTIVITY_STATE_STARTED) + .setHeartbeatDetails(payload("heartbeatDetails")) + .setLastHeartbeatTime(timestampNanos(1)) + .setLastStartedTime(timestampNanos(2)) + .setAttempt(3) + .setMaximumAttempts(4) + .setScheduledTime(timestampNanos(5)) + .setExpirationTime(timestampNanos(6)) + .setLastWorkerIdentity("lastWorkerIdentity") + .setLastFailure( + Failure.newBuilder() + .setReason("lastFailureReason") + .setDetails(utf8("lastFailureDetails"))) + .build(); + public static final PendingChildExecutionInfo PENDING_CHILD_EXECUTION_INFO = + PendingChildExecutionInfo.newBuilder() + .setWorkflowExecution(WORKFLOW_EXECUTION) + .setWorkflowTypeName(WORKFLOW_TYPE.getName()) + .setInitiatedId(1) + .setParentClosePolicy(ParentClosePolicy.PARENT_CLOSE_POLICY_REQUEST_CANCEL) + .build(); + public static final PendingDecisionInfo PENDING_DECISION_INFO = + PendingDecisionInfo.newBuilder() + .setState(PendingDecisionState.PENDING_DECISION_STATE_STARTED) + .setScheduledTime(timestampNanos(1)) + .setStartedTime(timestampNanos(2)) + .setAttempt(3) + .setOriginalScheduledTime(timestampNanos(4)) + .build(); + public static final SupportedClientVersions SUPPORTED_CLIENT_VERSIONS = + SupportedClientVersions.newBuilder().setGoSdk("goSdk").setJavaSdk("javaSdk").build(); + public static final Map INDEXED_VALUES = + ImmutableMap.of( + "STRING", + IndexedValueType.INDEXED_VALUE_TYPE_STRING, + "KEYWORD", + IndexedValueType.INDEXED_VALUE_TYPE_KEYWORD, + "INT", + IndexedValueType.INDEXED_VALUE_TYPE_INT, + "DOUBLE", + IndexedValueType.INDEXED_VALUE_TYPE_DOUBLE, + "BOOL", + IndexedValueType.INDEXED_VALUE_TYPE_BOOL, + "DATETIME", + IndexedValueType.INDEXED_VALUE_TYPE_DATETIME); + public static final DataBlob DATA_BLOB = + DataBlob.newBuilder() + .setData(utf8("data")) + .setEncodingType(EncodingType.ENCODING_TYPE_JSON) + .build(); + public static final TaskListPartitionMetadata TASK_LIST_PARTITION_METADATA = + TaskListPartitionMetadata.newBuilder() + .setKey("key") + .setOwnerHostName("ownerHostName") + .build(); + public static final ActivityLocalDispatchInfo ACTIVITY_LOCAL_DISPATCH_INFO = + ActivityLocalDispatchInfo.newBuilder() + .setActivityId("activityId") + .setScheduledTime(timestampNanos(1)) + .setStartedTime(timestampNanos(2)) + .setScheduledTimeOfThisAttempt(timestampNanos(3)) + .setTaskToken(utf8("taskToken")) + .build(); + public static final Domain DOMAIN = + Domain.newBuilder() + .setId("uuid") + .setName("domain") + .setStatus(DomainStatus.DOMAIN_STATUS_DEPRECATED) + .setDescription("description") + .setOwnerEmail("email") + .putAllData(DATA) + .setWorkflowExecutionRetentionPeriod(days(2)) + .setBadBinaries( + BadBinaries.newBuilder() + .putBinaries( + "badBinaryKey", + BadBinaryInfo.newBuilder() + .setReason("reason") + .setOperator("operator") + .setCreatedTime(timestampNanos(3)) + .build())) + .setHistoryArchivalStatus(ArchivalStatus.ARCHIVAL_STATUS_ENABLED) + .setHistoryArchivalUri("historyArchivalUri") + .setVisibilityArchivalStatus(ArchivalStatus.ARCHIVAL_STATUS_DISABLED) + .setVisibilityArchivalUri("visibilityArchivalUri") + .setActiveClusterName("activeCluster") + .addClusters(CLUSTER_REPLICATION_CONFIGURATION) + .setFailoverVersion(1) + .setIsGlobalDomain(true) + .build(); public static Decision DECISION_SCHEDULE_ACTIVITY_TASK = Decision.newBuilder() @@ -669,6 +807,18 @@ public final class ProtoObjects { .setWorkflowExecution(WORKFLOW_EXECUTION) .setControl(utf8("control")) .build(); + + public static final HistoryEvent HISTORY_EVENT = + HistoryEvent.newBuilder() + .setEventId(1) + .setEventTime(timestampNanos(2)) + .setVersion(3) + .setTaskId(4) + .setWorkflowExecutionStartedEventAttributes(WORKFLOW_EXECUTION_STARTED_EVENT_ATTRIBUTES) + .build(); + + public static final History HISTORY = History.newBuilder().addEvents(HISTORY_EVENT).build(); + public static final CountWorkflowExecutionsRequest COUNT_WORKFLOW_EXECUTIONS_REQUEST = CountWorkflowExecutionsRequest.newBuilder().setDomain("domain").setQuery("query").build(); public static final DescribeTaskListRequest DESCRIBE_TASK_LIST_REQUEST = @@ -1026,6 +1176,154 @@ public final class ProtoObjects { .setLatestTime(timestampNanos(3))) .build(); + public static final StartWorkflowExecutionResponse START_WORKFLOW_EXECUTION_RESPONSE = + StartWorkflowExecutionResponse.newBuilder().setRunId(WORKFLOW_EXECUTION.getRunId()).build(); + public static final StartWorkflowExecutionAsyncResponse START_WORKFLOW_EXECUTION_ASYNC_RESPONSE = + StartWorkflowExecutionAsyncResponse.newBuilder().build(); + + public static final DescribeTaskListResponse DESCRIBE_TASK_LIST_RESPONSE = + DescribeTaskListResponse.newBuilder() + .addPollers(POLLER_INFO) + .setTaskListStatus(TASK_LIST_STATUS) + .build(); + + public static final DescribeWorkflowExecutionResponse DESCRIBE_WORKFLOW_EXECUTION_RESPONSE = + DescribeWorkflowExecutionResponse.newBuilder() + .setExecutionConfiguration(WORKFLOW_EXECUTION_CONFIGURATION) + .setWorkflowExecutionInfo(WORKFLOW_EXECUTION_INFO) + .addPendingActivities(PENDING_ACTIVITY_INFO) + .addPendingChildren(PENDING_CHILD_EXECUTION_INFO) + .setPendingDecision(PENDING_DECISION_INFO) + .build(); + + public static final GetClusterInfoResponse GET_CLUSTER_INFO_RESPONSE = + GetClusterInfoResponse.newBuilder() + .setSupportedClientVersions(SUPPORTED_CLIENT_VERSIONS) + .build(); + + public static final GetSearchAttributesResponse GET_SEARCH_ATTRIBUTES_RESPONSE = + GetSearchAttributesResponse.newBuilder().putAllKeys(INDEXED_VALUES).build(); + public static final GetWorkflowExecutionHistoryResponse GET_WORKFLOW_EXECUTION_HISTORY_RESPONSE = + GetWorkflowExecutionHistoryResponse.newBuilder() + .setHistory(HISTORY) + .addRawHistory(DATA_BLOB) + .setNextPageToken(utf8("nextPageToken")) + .setArchived(true) + .build(); + + public static final ListArchivedWorkflowExecutionsResponse + LIST_ARCHIVED_WORKFLOW_EXECUTIONS_RESPONSE = + ListArchivedWorkflowExecutionsResponse.newBuilder() + .addExecutions(WORKFLOW_EXECUTION_INFO) + .setNextPageToken(utf8("nextPageToken")) + .build(); + + public static final ListClosedWorkflowExecutionsResponse + LIST_CLOSED_WORKFLOW_EXECUTIONS_RESPONSE = + ListClosedWorkflowExecutionsResponse.newBuilder() + .addExecutions(WORKFLOW_EXECUTION_INFO) + .setNextPageToken(utf8("nextPageToken")) + .build(); + public static final ListOpenWorkflowExecutionsResponse LIST_OPEN_WORKFLOW_EXECUTIONS_RESPONSE = + ListOpenWorkflowExecutionsResponse.newBuilder() + .addExecutions(WORKFLOW_EXECUTION_INFO) + .setNextPageToken(utf8("nextPageToken")) + .build(); + public static final ListTaskListPartitionsResponse LIST_TASK_LIST_PARTITIONS_RESPONSE = + ListTaskListPartitionsResponse.newBuilder() + .addActivityTaskListPartitions(TASK_LIST_PARTITION_METADATA) + .addDecisionTaskListPartitions(TASK_LIST_PARTITION_METADATA) + .build(); + public static final ScanWorkflowExecutionsResponse SCAN_WORKFLOW_EXECUTIONS_RESPONSE = + ScanWorkflowExecutionsResponse.newBuilder() + .addExecutions(WORKFLOW_EXECUTION_INFO) + .setNextPageToken(utf8("nextPageToken")) + .build(); + public static final ListWorkflowExecutionsResponse LIST_WORKFLOW_EXECUTIONS_RESPONSE = + ListWorkflowExecutionsResponse.newBuilder() + .addExecutions(WORKFLOW_EXECUTION_INFO) + .setNextPageToken(utf8("nextPageToken")) + .build(); + public static final PollForActivityTaskResponse POLL_FOR_ACTIVITY_TASK_RESPONSE = + PollForActivityTaskResponse.newBuilder() + .setTaskToken(utf8("taskToken")) + .setWorkflowExecution(WORKFLOW_EXECUTION) + .setActivityId("activityId") + .setActivityType(ACTIVITY_TYPE) + .setInput(payload("input")) + .setScheduledTime(timestampNanos(1)) + .setStartedTime(timestampNanos(2)) + .setScheduleToCloseTimeout(seconds(3)) + .setStartToCloseTimeout(seconds(4)) + .setHeartbeatTimeout(seconds(5)) + .setAttempt(6) + .setScheduledTimeOfThisAttempt(timestampNanos(7)) + .setHeartbeatDetails(payload("heartbeatDetails")) + .setWorkflowType(WORKFLOW_TYPE) + .setWorkflowDomain("domain") + .setHeader(HEADER) + .build(); + public static final PollForDecisionTaskResponse POLL_FOR_DECISION_TASK_RESPONSE = + PollForDecisionTaskResponse.newBuilder() + .setTaskToken(utf8("taskToken")) + .setWorkflowExecution(WORKFLOW_EXECUTION) + .setWorkflowType(WORKFLOW_TYPE) + .setPreviousStartedEventId(int64(1)) + .setStartedEventId(2) + .setAttempt(3) + .setBacklogCountHint(4) + .setHistory(HISTORY) + .setNextPageToken(utf8("nextPageToken")) + .setQuery(WORKFLOW_QUERY) + .setWorkflowExecutionTaskList(TASK_LIST) + .setScheduledTime(timestampNanos(5)) + .setStartedTime(timestampNanos(6)) + .putAllQueries(ImmutableMap.of("query", WORKFLOW_QUERY)) + .setNextEventId(7) + .build(); + + public static final QueryWorkflowResponse QUERY_WORKFLOW_RESPONSE = + QueryWorkflowResponse.newBuilder() + .setQueryResult(payload("result")) + .setQueryRejected( + QueryRejected.newBuilder() + .setCloseStatus( + WorkflowExecutionCloseStatus.WORKFLOW_EXECUTION_CLOSE_STATUS_FAILED)) + .build(); + + public static final RecordActivityTaskHeartbeatResponse RECORD_ACTIVITY_TASK_HEARTBEAT_RESPONSE = + RecordActivityTaskHeartbeatResponse.newBuilder().setCancelRequested(true).build(); + public static final RecordActivityTaskHeartbeatByIDResponse + RECORD_ACTIVITY_TASK_HEARTBEAT_BY_ID_RESPONSE = + RecordActivityTaskHeartbeatByIDResponse.newBuilder().setCancelRequested(true).build(); + public static final ResetWorkflowExecutionResponse RESET_WORKFLOW_EXECUTION_RESPONSE = + ResetWorkflowExecutionResponse.newBuilder().setRunId(WORKFLOW_EXECUTION.getRunId()).build(); + public static final RespondDecisionTaskCompletedResponse + RESPOND_DECISION_TASK_COMPLETED_RESPONSE = + RespondDecisionTaskCompletedResponse.newBuilder() + .setDecisionTask(POLL_FOR_DECISION_TASK_RESPONSE) + .putActivitiesToDispatchLocally("activity", ACTIVITY_LOCAL_DISPATCH_INFO) + .build(); + public static final CountWorkflowExecutionsResponse COUNT_WORKFLOW_EXECUTIONS_RESPONSE = + CountWorkflowExecutionsResponse.newBuilder().setCount(1000).build(); + public static final DescribeDomainResponse DESCRIBE_DOMAIN_RESPONSE = + DescribeDomainResponse.newBuilder().setDomain(DOMAIN).build(); + public static final ListDomainsResponse LIST_DOMAINS_RESPONSE = + ListDomainsResponse.newBuilder() + .addDomains(DOMAIN) + .setNextPageToken(utf8("nextPageToken")) + .build(); + public static final SignalWithStartWorkflowExecutionResponse + SIGNAL_WITH_START_WORKFLOW_EXECUTION_RESPONSE = + SignalWithStartWorkflowExecutionResponse.newBuilder() + .setRunId(WORKFLOW_EXECUTION.getRunId()) + .build(); + public static final SignalWithStartWorkflowExecutionAsyncResponse + SIGNAL_WITH_START_WORKFLOW_EXECUTION_ASYNC_RESPONSE = + SignalWithStartWorkflowExecutionAsyncResponse.newBuilder().build(); + public static final UpdateDomainResponse UPDATE_DOMAIN_RESPONSE = + UpdateDomainResponse.newBuilder().setDomain(DOMAIN).build(); + private ProtoObjects() {} private static Payload payload(String value) { @@ -1047,4 +1345,8 @@ private static Timestamp timestampNanos(int value) { private static ByteString utf8(String value) { return ByteString.copyFromUtf8(value); } + + private static Int64Value int64(long value) { + return Int64Value.newBuilder().setValue(value).build(); + } } diff --git a/src/test/java/com/uber/cadence/internal/compatibility/ThriftObjects.java b/src/test/java/com/uber/cadence/internal/compatibility/ThriftObjects.java index deee5799c..63cc6ca1a 100644 --- a/src/test/java/com/uber/cadence/internal/compatibility/ThriftObjects.java +++ b/src/test/java/com/uber/cadence/internal/compatibility/ThriftObjects.java @@ -19,8 +19,10 @@ import com.uber.cadence.*; import java.nio.ByteBuffer; import java.nio.charset.StandardCharsets; +import java.util.Arrays; import java.util.Collections; import java.util.Map; +import java.util.stream.Collectors; public final class ThriftObjects { public static final WorkflowType WORKFLOW_TYPE = @@ -76,6 +78,111 @@ public final class ThriftObjects { new ResetPoints().setPoints(Collections.singletonList(RESET_POINT_INFO)); public static final ClusterReplicationConfiguration CLUSTER_REPLICATION_CONFIGURATION = new ClusterReplicationConfiguration().setClusterName("cluster"); + public static final PollerInfo POLLER_INFO = + new PollerInfo().setIdentity("identity").setLastAccessTime(1).setRatePerSecond(2.0); + public static final TaskIDBlock TASK_ID_BLOCK = new TaskIDBlock().setStartID(1).setEndID(2); + public static final TaskListStatus TASK_LIST_STATUS = + new TaskListStatus() + .setTaskIDBlock(TASK_ID_BLOCK) + .setAckLevel(1) + .setBacklogCountHint(2) + .setReadLevel(3) + .setRatePerSecond(4.0); + public static final WorkflowExecutionConfiguration WORKFLOW_EXECUTION_CONFIGURATION = + new WorkflowExecutionConfiguration() + .setTaskList(TASK_LIST) + .setExecutionStartToCloseTimeoutSeconds(1) + .setTaskStartToCloseTimeoutSeconds(2); + public static final WorkflowExecutionInfo WORKFLOW_EXECUTION_INFO = + new WorkflowExecutionInfo() + .setExecution(WORKFLOW_EXECUTION) + .setType(WORKFLOW_TYPE) + .setStartTime(1) + .setCloseTime(2) + .setCloseStatus(WorkflowExecutionCloseStatus.FAILED) + .setHistoryLength(3) + .setParentDomainId("parentDomainId") + .setParentExecution(PARENT_WORKFLOW_EXECUTION) + .setExecutionTime(4) + .setMemo(MEMO) + .setSearchAttributes(SEARCH_ATTRIBUTES) + .setAutoResetPoints(RESET_POINTS) + .setTaskList(TASK_LIST.getName()) + .setIsCron(true); + public static final PendingActivityInfo PENDING_ACTIVITY_INFO = + new PendingActivityInfo() + .setActivityID("activityId") + .setActivityType(ACTIVITY_TYPE) + .setState(PendingActivityState.STARTED) + .setHeartbeatDetails(utf8("heartbeatDetails")) + .setLastHeartbeatTimestamp(1) + .setLastStartedTimestamp(2) + .setAttempt(3) + .setMaximumAttempts(4) + .setScheduledTimestamp(5) + .setExpirationTimestamp(6) + .setLastWorkerIdentity("lastWorkerIdentity") + .setLastFailureReason("lastFailureReason") + .setLastFailureDetails(utf8("lastFailureDetails")); + public static final PendingChildExecutionInfo PENDING_CHILD_EXECUTION_INFO = + new PendingChildExecutionInfo() + .setWorkflowID(WORKFLOW_ID) + .setRunID(RUN_ID) + .setWorkflowTypName(WORKFLOW_TYPE.getName()) + .setInitiatedID(1) + .setParentClosePolicy(ParentClosePolicy.REQUEST_CANCEL); + public static final PendingDecisionInfo PENDING_DECISION_INFO = + new PendingDecisionInfo() + .setState(PendingDecisionState.STARTED) + .setScheduledTimestamp(1) + .setStartedTimestamp(2) + .setAttempt(3) + .setOriginalScheduledTimestamp(4); + public static final SupportedClientVersions SUPPORTED_CLIENT_VERSIONS = + new SupportedClientVersions().setGoSdk("goSdk").setJavaSdk("javaSdk"); + public static final Map INDEXED_VALUES = + Arrays.stream(IndexedValueType.values()).collect(Collectors.toMap(Enum::name, v -> v)); + public static final DataBlob DATA_BLOB = + new DataBlob().setData(utf8Bytes("data")).setEncodingType(EncodingType.JSON); + public static final TaskListPartitionMetadata TASK_LIST_PARTITION_METADATA = + new TaskListPartitionMetadata().setKey("key").setOwnerHostName("ownerHostName"); + public static final ActivityLocalDispatchInfo ACTIVITY_LOCAL_DISPATCH_INFO = + new ActivityLocalDispatchInfo() + .setActivityId("activityId") + .setScheduledTimestamp(1) + .setStartedTimestamp(2) + .setScheduledTimestampOfThisAttempt(3) + .setTaskToken(utf8("taskToken")); + public static final DomainInfo DOMAIN_INFO = + new DomainInfo() + .setName("domain") + .setStatus(DomainStatus.DEPRECATED) + .setDescription("description") + .setOwnerEmail("email") + .setData(DATA) + .setUuid("uuid"); + public static final DomainConfiguration DOMAIN_CONFIGURATION = + new DomainConfiguration() + .setWorkflowExecutionRetentionPeriodInDays(2) + .setBadBinaries( + new BadBinaries() + .setBinaries( + ImmutableMap.of( + "badBinaryKey", + new BadBinaryInfo() + .setReason("reason") + .setOperator("operator") + .setCreatedTimeNano(3)))) + .setHistoryArchivalStatus(ArchivalStatus.ENABLED) + .setHistoryArchivalURI("historyArchivalUri") + .setVisibilityArchivalStatus(ArchivalStatus.DISABLED) + .setVisibilityArchivalURI("visibilityArchivalUri") + .setEmitMetric(true); + + public static final DomainReplicationConfiguration DOMAIN_REPLICATION_CONFIGURATION = + new DomainReplicationConfiguration() + .setActiveClusterName("activeCluster") + .setClusters(ImmutableList.of(CLUSTER_REPLICATION_CONFIGURATION)); public static Decision DECISION_SCHEDULE_ACTIVITY_TASK = new Decision() @@ -597,6 +704,17 @@ public final class ThriftObjects { .setWorkflowExecution(WORKFLOW_EXECUTION) .setControl(utf8("control")); + public static final HistoryEvent HISTORY_EVENT = + new HistoryEvent() + .setEventId(1) + .setTimestamp(2) + .setVersion(3) + .setTaskId(4) + .setEventType(EventType.WorkflowExecutionStarted) + .setWorkflowExecutionStartedEventAttributes(WORKFLOW_EXECUTION_STARTED_EVENT_ATTRIBUTES); + + public static final History HISTORY = new History().setEvents(ImmutableList.of(HISTORY_EVENT)); + public static final CountWorkflowExecutionsRequest COUNT_WORKFLOW_EXECUTIONS_REQUEST = new CountWorkflowExecutionsRequest().setDomain("domain").setQuery("query"); public static final DescribeTaskListRequest DESCRIBE_TASK_LIST_REQUEST = @@ -863,26 +981,8 @@ public final class ThriftObjects { .setData(DATA) .setDescription("description") .setOwnerEmail("ownerEmail")) - .setReplicationConfiguration( - new DomainReplicationConfiguration() - .setActiveClusterName("activeCluster") - .setClusters(ImmutableList.of(CLUSTER_REPLICATION_CONFIGURATION))) - .setConfiguration( - new DomainConfiguration() - .setWorkflowExecutionRetentionPeriodInDays(2) - .setBadBinaries( - new BadBinaries() - .setBinaries( - ImmutableMap.of( - "badBinaryKey", - new BadBinaryInfo() - .setReason("reason") - .setOperator("operator") - .setCreatedTimeNano(3)))) - .setHistoryArchivalStatus(ArchivalStatus.ENABLED) - .setHistoryArchivalURI("historyArchivalUri") - .setVisibilityArchivalStatus(ArchivalStatus.DISABLED) - .setVisibilityArchivalURI("visibilityArchivalUri")) + .setReplicationConfiguration(DOMAIN_REPLICATION_CONFIGURATION) + .setConfiguration(DOMAIN_CONFIGURATION) .setDeleteBadBinary("deleteBadBinary") .setFailoverTimeoutInSeconds(1); @@ -907,6 +1007,135 @@ public final class ThriftObjects { .setNextPageToken(utf8("nextPageToken")) .setStartTimeFilter(new StartTimeFilter().setEarliestTime(2).setLatestTime(3)); + public static final StartWorkflowExecutionResponse START_WORKFLOW_EXECUTION_RESPONSE = + new StartWorkflowExecutionResponse().setRunId(RUN_ID); + public static final StartWorkflowExecutionAsyncResponse START_WORKFLOW_EXECUTION_ASYNC_RESPONSE = + new StartWorkflowExecutionAsyncResponse(); + + public static final DescribeTaskListResponse DESCRIBE_TASK_LIST_RESPONSE = + new DescribeTaskListResponse() + .setPollers(ImmutableList.of(POLLER_INFO)) + .setTaskListStatus(TASK_LIST_STATUS); + + public static final DescribeWorkflowExecutionResponse DESCRIBE_WORKFLOW_EXECUTION_RESPONSE = + new DescribeWorkflowExecutionResponse() + .setExecutionConfiguration(WORKFLOW_EXECUTION_CONFIGURATION) + .setWorkflowExecutionInfo(WORKFLOW_EXECUTION_INFO) + .setPendingActivities(ImmutableList.of(PENDING_ACTIVITY_INFO)) + .setPendingChildren(ImmutableList.of(PENDING_CHILD_EXECUTION_INFO)) + .setPendingDecision(PENDING_DECISION_INFO); + + public static final ClusterInfo CLUSTER_INFO = + new ClusterInfo().setSupportedClientVersions(SUPPORTED_CLIENT_VERSIONS); + + public static final GetSearchAttributesResponse GET_SEARCH_ATTRIBUTES_RESPONSE = + new GetSearchAttributesResponse().setKeys(INDEXED_VALUES); + public static final GetWorkflowExecutionHistoryResponse GET_WORKFLOW_EXECUTION_HISTORY_RESPONSE = + new GetWorkflowExecutionHistoryResponse() + .setHistory(HISTORY) + .setRawHistory(ImmutableList.of(DATA_BLOB)) + .setNextPageToken(utf8("nextPageToken")) + .setArchived(true); + + public static final ListArchivedWorkflowExecutionsResponse + LIST_ARCHIVED_WORKFLOW_EXECUTIONS_RESPONSE = + new ListArchivedWorkflowExecutionsResponse() + .setExecutions(ImmutableList.of(WORKFLOW_EXECUTION_INFO)) + .setNextPageToken(utf8("nextPageToken")); + + public static final ListClosedWorkflowExecutionsResponse + LIST_CLOSED_WORKFLOW_EXECUTIONS_RESPONSE = + new ListClosedWorkflowExecutionsResponse() + .setExecutions(ImmutableList.of(WORKFLOW_EXECUTION_INFO)) + .setNextPageToken(utf8("nextPageToken")); + public static final ListOpenWorkflowExecutionsResponse LIST_OPEN_WORKFLOW_EXECUTIONS_RESPONSE = + new ListOpenWorkflowExecutionsResponse() + .setExecutions(ImmutableList.of(WORKFLOW_EXECUTION_INFO)) + .setNextPageToken(utf8("nextPageToken")); + public static final ListTaskListPartitionsResponse LIST_TASK_LIST_PARTITIONS_RESPONSE = + new ListTaskListPartitionsResponse() + .setActivityTaskListPartitions(ImmutableList.of(TASK_LIST_PARTITION_METADATA)) + .setDecisionTaskListPartitions(ImmutableList.of(TASK_LIST_PARTITION_METADATA)); + public static final ListWorkflowExecutionsResponse LIST_WORKFLOW_EXECUTIONS_RESPONSE = + new ListWorkflowExecutionsResponse() + .setExecutions(ImmutableList.of(WORKFLOW_EXECUTION_INFO)) + .setNextPageToken(utf8("nextPageToken")); + public static final PollForActivityTaskResponse POLL_FOR_ACTIVITY_TASK_RESPONSE = + new PollForActivityTaskResponse() + .setTaskToken(utf8("taskToken")) + .setWorkflowExecution(WORKFLOW_EXECUTION) + .setActivityId("activityId") + .setActivityType(ACTIVITY_TYPE) + .setInput(utf8("input")) + .setScheduledTimestamp(1) + .setStartedTimestamp(2) + .setScheduleToCloseTimeoutSeconds(3) + .setStartToCloseTimeoutSeconds(4) + .setHeartbeatTimeoutSeconds(5) + .setAttempt(6) + .setScheduledTimestampOfThisAttempt(7) + .setHeartbeatDetails(utf8("heartbeatDetails")) + .setWorkflowType(WORKFLOW_TYPE) + .setWorkflowDomain("domain") + .setHeader(HEADER); + public static final PollForDecisionTaskResponse POLL_FOR_DECISION_TASK_RESPONSE = + new PollForDecisionTaskResponse() + .setTaskToken(utf8("taskToken")) + .setWorkflowExecution(WORKFLOW_EXECUTION) + .setWorkflowType(WORKFLOW_TYPE) + .setPreviousStartedEventId(1) + .setStartedEventId(2) + .setAttempt(3) + .setBacklogCountHint(4) + .setHistory(HISTORY) + .setNextPageToken(utf8("nextPageToken")) + .setQuery(WORKFLOW_QUERY) + .setWorkflowExecutionTaskList(TASK_LIST) + .setScheduledTimestamp(5) + .setStartedTimestamp(6) + .setQueries(ImmutableMap.of("query", WORKFLOW_QUERY)) + .setNextEventId(7); + + public static final QueryWorkflowResponse QUERY_WORKFLOW_RESPONSE = + new QueryWorkflowResponse() + .setQueryResult(utf8("result")) + .setQueryRejected( + new QueryRejected().setCloseStatus(WorkflowExecutionCloseStatus.FAILED)); + + public static final RecordActivityTaskHeartbeatResponse RECORD_ACTIVITY_TASK_HEARTBEAT_RESPONSE = + new RecordActivityTaskHeartbeatResponse().setCancelRequested(true); + public static final ResetWorkflowExecutionResponse RESET_WORKFLOW_EXECUTION_RESPONSE = + new ResetWorkflowExecutionResponse().setRunId(RUN_ID); + public static final RespondDecisionTaskCompletedResponse + RESPOND_DECISION_TASK_COMPLETED_RESPONSE = + new RespondDecisionTaskCompletedResponse() + .setDecisionTask(POLL_FOR_DECISION_TASK_RESPONSE) + .setActivitiesToDispatchLocally( + ImmutableMap.of("activity", ACTIVITY_LOCAL_DISPATCH_INFO)); + public static final CountWorkflowExecutionsResponse COUNT_WORKFLOW_EXECUTIONS_RESPONSE = + new CountWorkflowExecutionsResponse().setCount(1000); + public static final DescribeDomainResponse DESCRIBE_DOMAIN_RESPONSE = + new DescribeDomainResponse() + .setDomainInfo(DOMAIN_INFO) + .setConfiguration(DOMAIN_CONFIGURATION) + .setReplicationConfiguration(DOMAIN_REPLICATION_CONFIGURATION) + .setFailoverVersion(1) + .setIsGlobalDomain(true); + public static final ListDomainsResponse LIST_DOMAINS_RESPONSE = + new ListDomainsResponse() + .setDomains(ImmutableList.of(DESCRIBE_DOMAIN_RESPONSE)) + .setNextPageToken(utf8("nextPageToken")); + public static final SignalWithStartWorkflowExecutionAsyncResponse + SIGNAL_WITH_START_WORKFLOW_EXECUTION_ASYNC_RESPONSE = + new SignalWithStartWorkflowExecutionAsyncResponse(); + public static final UpdateDomainResponse UPDATE_DOMAIN_RESPONSE = + new UpdateDomainResponse() + .setDomainInfo(DOMAIN_INFO) + .setConfiguration(DOMAIN_CONFIGURATION) + .setReplicationConfiguration(DOMAIN_REPLICATION_CONFIGURATION) + .setFailoverVersion(1) + .setIsGlobalDomain(true); + private ThriftObjects() {} public static ByteBuffer utf8(String value) { diff --git a/src/test/java/com/uber/cadence/internal/compatibility/thrift/ResponseMapperTest.java b/src/test/java/com/uber/cadence/internal/compatibility/thrift/ResponseMapperTest.java index 9a421d159..cf2380b14 100644 --- a/src/test/java/com/uber/cadence/internal/compatibility/thrift/ResponseMapperTest.java +++ b/src/test/java/com/uber/cadence/internal/compatibility/thrift/ResponseMapperTest.java @@ -17,100 +17,182 @@ package com.uber.cadence.internal.compatibility.thrift; +import static com.uber.cadence.internal.compatibility.MapperTestUtil.assertMissingFields; import static com.uber.cadence.internal.compatibility.MapperTestUtil.assertNoMissingFields; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertNotNull; - -import com.uber.cadence.api.v1.DescribeDomainResponse; -import com.uber.cadence.api.v1.Domain; -import com.uber.cadence.api.v1.SignalWithStartWorkflowExecutionAsyncResponse; -import com.uber.cadence.api.v1.SignalWithStartWorkflowExecutionResponse; -import com.uber.cadence.api.v1.StartWorkflowExecutionAsyncResponse; -import com.uber.cadence.api.v1.StartWorkflowExecutionResponse; -import com.uber.cadence.api.v1.UpdateDomainResponse; -import org.junit.Assert; +import static org.junit.Assert.assertNull; + +import com.google.common.collect.ImmutableSet; +import com.google.protobuf.Message; +import com.uber.cadence.internal.compatibility.ProtoObjects; +import com.uber.cadence.internal.compatibility.ThriftObjects; +import java.util.Arrays; +import java.util.Set; +import java.util.function.Function; +import org.apache.thrift.TBase; +import org.apache.thrift.TFieldIdEnum; import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; -public class ResponseMapperTest { +@RunWith(Parameterized.class) +public class ResponseMapperTest< + F extends Enum & TFieldIdEnum, T extends TBase, P extends Message> { - @Test - public void DescribeDomainContainsConfigurationInfo() { - com.uber.cadence.api.v1.DescribeDomainResponse describeDomainResponse = - DescribeDomainResponse.newBuilder().setDomain(Domain.newBuilder().build()).build(); - com.uber.cadence.DescribeDomainResponse response = - ResponseMapper.describeDomainResponse(describeDomainResponse); - Assert.assertNotNull(response.configuration); - Assert.assertNotNull(response.replicationConfiguration); - } - - @Test - public void UpdateDomainContainsConfigurationInfo() { - com.uber.cadence.api.v1.UpdateDomainResponse updateDomainResponse = - UpdateDomainResponse.newBuilder().setDomain(Domain.newBuilder().build()).build(); + @Parameterized.Parameter(0) + public String testName; - com.uber.cadence.UpdateDomainResponse response = - ResponseMapper.updateDomainResponse(updateDomainResponse); - - Assert.assertNotNull(response.configuration); - Assert.assertNotNull(response.replicationConfiguration); - } - - @Test - public void testStartWorkflowExecutionResponse() { - com.uber.cadence.api.v1.StartWorkflowExecutionResponse startWorkflowExecutionResponse = - StartWorkflowExecutionResponse.newBuilder().setRunId("runId").build(); + @Parameterized.Parameter(1) + public P from; - com.uber.cadence.StartWorkflowExecutionResponse response = - ResponseMapper.startWorkflowExecutionResponse(startWorkflowExecutionResponse); + @Parameterized.Parameter(2) + public T to; - assertNoMissingFields(response, com.uber.cadence.StartWorkflowExecutionResponse._Fields.class); + @Parameterized.Parameter(3) + public Function via; - assertEquals("runId", response.getRunId()); - } + @Parameterized.Parameter(4) + public Set missingFields; @Test - public void testStartWorkflowExecutionAsyncResponse() { - com.uber.cadence.api.v1.StartWorkflowExecutionAsyncResponse startWorkflowExecutionResponse = - StartWorkflowExecutionAsyncResponse.newBuilder().build(); - - com.uber.cadence.StartWorkflowExecutionAsyncResponse response = - ResponseMapper.startWorkflowExecutionAsyncResponse(startWorkflowExecutionResponse); - - assertNoMissingFields( - response, com.uber.cadence.StartWorkflowExecutionAsyncResponse._Fields.class); - - // No fields to test - assertNotNull(response); + public void testFieldsPresent() { + // If IDL is updated, this will fail. Update the mapper or add it to the test + if (missingFields.isEmpty()) { + assertNoMissingFields(to); + } else { + assertMissingFields(to, missingFields); + } } @Test - public void testSignalWithStartWorkflowExecutionResponse() { - com.uber.cadence.api.v1.SignalWithStartWorkflowExecutionResponse - startWorkflowExecutionResponse = - SignalWithStartWorkflowExecutionResponse.newBuilder().setRunId("runId").build(); - - com.uber.cadence.StartWorkflowExecutionResponse response = - ResponseMapper.signalWithStartWorkflowExecutionResponse(startWorkflowExecutionResponse); - - assertNoMissingFields(response, com.uber.cadence.StartWorkflowExecutionResponse._Fields.class); - - assertEquals("runId", response.getRunId()); + public void testMapper() { + T actual = via.apply(from); + assertEquals(to, actual); } @Test - public void testSignalWithStartWorkflowExecutionAsyncResponse() { - com.uber.cadence.api.v1.SignalWithStartWorkflowExecutionAsyncResponse - startWorkflowExecutionResponse = - SignalWithStartWorkflowExecutionAsyncResponse.newBuilder().build(); + public void testHandlesNull() { + T actual = via.apply(null); - com.uber.cadence.SignalWithStartWorkflowExecutionAsyncResponse response = - ResponseMapper.signalWithStartWorkflowExecutionAsyncResponse( - startWorkflowExecutionResponse); + assertNull("Mapper functions should accept null, returning null", actual); + } - assertNoMissingFields( - response, com.uber.cadence.SignalWithStartWorkflowExecutionAsyncResponse._Fields.class); + @Parameterized.Parameters(name = "{0}") + public static Iterable cases() { + return Arrays.asList( + testCase( + ProtoObjects.START_WORKFLOW_EXECUTION_RESPONSE, + ThriftObjects.START_WORKFLOW_EXECUTION_RESPONSE, + ResponseMapper::startWorkflowExecutionResponse), + testCase( + ProtoObjects.START_WORKFLOW_EXECUTION_ASYNC_RESPONSE, + ThriftObjects.START_WORKFLOW_EXECUTION_ASYNC_RESPONSE, + ResponseMapper::startWorkflowExecutionAsyncResponse), + testCase( + ProtoObjects.DESCRIBE_TASK_LIST_RESPONSE, + ThriftObjects.DESCRIBE_TASK_LIST_RESPONSE, + ResponseMapper::describeTaskListResponse), + testCase( + ProtoObjects.DESCRIBE_WORKFLOW_EXECUTION_RESPONSE, + ThriftObjects.DESCRIBE_WORKFLOW_EXECUTION_RESPONSE, + ResponseMapper::describeWorkflowExecutionResponse), + testCase( + ProtoObjects.GET_SEARCH_ATTRIBUTES_RESPONSE, + ThriftObjects.GET_SEARCH_ATTRIBUTES_RESPONSE, + ResponseMapper::getSearchAttributesResponse), + testCase( + ProtoObjects.GET_WORKFLOW_EXECUTION_HISTORY_RESPONSE, + ThriftObjects.GET_WORKFLOW_EXECUTION_HISTORY_RESPONSE, + ResponseMapper::getWorkflowExecutionHistoryResponse), + testCase( + ProtoObjects.LIST_ARCHIVED_WORKFLOW_EXECUTIONS_RESPONSE, + ThriftObjects.LIST_ARCHIVED_WORKFLOW_EXECUTIONS_RESPONSE, + ResponseMapper::listArchivedWorkflowExecutionsResponse), + testCase( + ProtoObjects.LIST_CLOSED_WORKFLOW_EXECUTIONS_RESPONSE, + ThriftObjects.LIST_CLOSED_WORKFLOW_EXECUTIONS_RESPONSE, + ResponseMapper::listClosedWorkflowExecutionsResponse), + testCase( + ProtoObjects.LIST_TASK_LIST_PARTITIONS_RESPONSE, + ThriftObjects.LIST_TASK_LIST_PARTITIONS_RESPONSE, + ResponseMapper::listTaskListPartitionsResponse), + testCase( + ProtoObjects.LIST_WORKFLOW_EXECUTIONS_RESPONSE, + ThriftObjects.LIST_WORKFLOW_EXECUTIONS_RESPONSE, + ResponseMapper::listWorkflowExecutionsResponse), + testCase( + ProtoObjects.POLL_FOR_ACTIVITY_TASK_RESPONSE, + ThriftObjects.POLL_FOR_ACTIVITY_TASK_RESPONSE, + ResponseMapper::pollForActivityTaskResponse), + testCase( + ProtoObjects.POLL_FOR_DECISION_TASK_RESPONSE, + ThriftObjects.POLL_FOR_DECISION_TASK_RESPONSE, + ResponseMapper::pollForDecisionTaskResponse, + "totalHistoryBytes"), + testCase( + ProtoObjects.QUERY_WORKFLOW_RESPONSE, + ThriftObjects.QUERY_WORKFLOW_RESPONSE, + ResponseMapper::queryWorkflowResponse), + testCase( + ProtoObjects.RECORD_ACTIVITY_TASK_HEARTBEAT_RESPONSE, + ThriftObjects.RECORD_ACTIVITY_TASK_HEARTBEAT_RESPONSE, + ResponseMapper::recordActivityTaskHeartbeatResponse), + testCase( + ProtoObjects.RESET_WORKFLOW_EXECUTION_RESPONSE, + ThriftObjects.RESET_WORKFLOW_EXECUTION_RESPONSE, + ResponseMapper::resetWorkflowExecutionResponse), + testCase( + ProtoObjects.RESPOND_DECISION_TASK_COMPLETED_RESPONSE, + ThriftObjects.RESPOND_DECISION_TASK_COMPLETED_RESPONSE, + ResponseMapper::respondDecisionTaskCompletedResponse), + testCase( + ProtoObjects.COUNT_WORKFLOW_EXECUTIONS_RESPONSE, + ThriftObjects.COUNT_WORKFLOW_EXECUTIONS_RESPONSE, + ResponseMapper::countWorkflowExecutionsResponse), + testCase( + ProtoObjects.DESCRIBE_DOMAIN_RESPONSE, + ThriftObjects.DESCRIBE_DOMAIN_RESPONSE, + ResponseMapper::describeDomainResponse, + "failoverInfo"), + testCase( + ProtoObjects.LIST_DOMAINS_RESPONSE, + ThriftObjects.LIST_DOMAINS_RESPONSE, + ResponseMapper::listDomainsResponse), + testCase( + ProtoObjects.SIGNAL_WITH_START_WORKFLOW_EXECUTION_ASYNC_RESPONSE, + ThriftObjects.SIGNAL_WITH_START_WORKFLOW_EXECUTION_ASYNC_RESPONSE, + ResponseMapper::signalWithStartWorkflowExecutionAsyncResponse), + testCase( + ProtoObjects.UPDATE_DOMAIN_RESPONSE, + ThriftObjects.UPDATE_DOMAIN_RESPONSE, + ResponseMapper::updateDomainResponse), + testCase( + ProtoObjects.LIST_OPEN_WORKFLOW_EXECUTIONS_RESPONSE, + ThriftObjects.LIST_OPEN_WORKFLOW_EXECUTIONS_RESPONSE, + ResponseMapper::listOpenWorkflowExecutionsResponse), + // Proto has more types than thrift because it doesn't reuse response types across methods + testCase( + ProtoObjects.SCAN_WORKFLOW_EXECUTIONS_RESPONSE, + ThriftObjects.LIST_WORKFLOW_EXECUTIONS_RESPONSE, + ResponseMapper::scanWorkflowExecutionsResponse), + testCase( + ProtoObjects.RECORD_ACTIVITY_TASK_HEARTBEAT_BY_ID_RESPONSE, + ThriftObjects.RECORD_ACTIVITY_TASK_HEARTBEAT_RESPONSE, + ResponseMapper::recordActivityTaskHeartbeatByIdResponse), + testCase( + ProtoObjects.GET_CLUSTER_INFO_RESPONSE, + ThriftObjects.CLUSTER_INFO, + ResponseMapper::getClusterInfoResponse), + testCase( + ProtoObjects.SIGNAL_WITH_START_WORKFLOW_EXECUTION_RESPONSE, + ThriftObjects.START_WORKFLOW_EXECUTION_RESPONSE, + ResponseMapper::signalWithStartWorkflowExecutionResponse)); + } - // No fields to test - assertNotNull(response); + private static Object[] testCase( + P from, T to, Function via, String... missingFields) { + return new Object[] { + from.getClass().getSimpleName(), from, to, via, ImmutableSet.copyOf(missingFields) + }; } }