diff --git a/temporal-sdk/src/main/java/io/temporal/internal/common/SdkFlag.java b/temporal-sdk/src/main/java/io/temporal/internal/common/SdkFlag.java index 82bde814f1..06d72c1bfb 100644 --- a/temporal-sdk/src/main/java/io/temporal/internal/common/SdkFlag.java +++ b/temporal-sdk/src/main/java/io/temporal/internal/common/SdkFlag.java @@ -36,6 +36,17 @@ public enum SdkFlag { * Bug: https://github.com/temporalio/sdk-java/issues/2796 */ VERSION_WAIT_FOR_MARKER(5), + /* + * Prevents cancellation of the enclosing CancellationScope from canceling the timeout timer + * used by non-cancellable Promise.get(timeout, unit). + * + * Introduced: 1.39.0 + * + * Enabled: (pending) + * + * Bug: https://github.com/temporalio/sdk-java/issues/3026 + */ + DETACH_NON_CANCELLABLE_PROMISE_GET_TIMER(6), UNKNOWN(Integer.MAX_VALUE); private final int value; diff --git a/temporal-sdk/src/main/java/io/temporal/internal/sync/CompletablePromiseImpl.java b/temporal-sdk/src/main/java/io/temporal/internal/sync/CompletablePromiseImpl.java index d4ea14dddf..559182cc01 100644 --- a/temporal-sdk/src/main/java/io/temporal/internal/sync/CompletablePromiseImpl.java +++ b/temporal-sdk/src/main/java/io/temporal/internal/sync/CompletablePromiseImpl.java @@ -1,6 +1,7 @@ package io.temporal.internal.sync; import io.temporal.failure.TemporalFailure; +import io.temporal.internal.common.SdkFlag; import io.temporal.workflow.CancellationScope; import io.temporal.workflow.CompletablePromise; import io.temporal.workflow.Functions; @@ -91,15 +92,28 @@ public V cancellableGet(long timeout, TimeUnit unit) throws TimeoutException { public V cancellableGetImpl(boolean cancellable, long timeout, TimeUnit unit) throws TimeoutException { if (!completed) { - WorkflowInternal.await( - Duration.ofMillis(unit.toMillis(timeout)), - "Feature.get", - () -> { - if (cancellable) { - CancellationScope.throwCanceled(); - } - return completed; - }); + Runnable waitForCompletion = + () -> + WorkflowInternal.await( + Duration.ofMillis(unit.toMillis(timeout)), + "Feature.get", + () -> { + if (cancellable) { + CancellationScope.throwCanceled(); + } + return completed; + }); + if (!cancellable + && WorkflowInternal.checkSdkFlag(SdkFlag.DETACH_NON_CANCELLABLE_PROMISE_GET_TIMER)) { + CancellationScope timeoutScope = Workflow.newDetachedCancellationScope(waitForCompletion); + try { + timeoutScope.run(); + } finally { + timeoutScope.cancel("Promise.get completed"); + } + } else { + waitForCompletion.run(); + } } if (!completed) { throw new TimeoutException(); diff --git a/temporal-sdk/src/main/java/io/temporal/internal/sync/WorkflowInternal.java b/temporal-sdk/src/main/java/io/temporal/internal/sync/WorkflowInternal.java index 3ea979e8db..8c4959e21d 100644 --- a/temporal-sdk/src/main/java/io/temporal/internal/sync/WorkflowInternal.java +++ b/temporal-sdk/src/main/java/io/temporal/internal/sync/WorkflowInternal.java @@ -875,6 +875,10 @@ static WorkflowOutboundCallsInterceptor getWorkflowOutboundInterceptor() { return getRootWorkflowContext().getWorkflowOutboundInterceptor(); } + static boolean checkSdkFlag(SdkFlag flag) { + return getRootWorkflowContext().getReplayContext().checkSdkFlag(flag); + } + static SyncWorkflowContext getRootWorkflowContext() { // If we are in a query handler, we need to get the workflow context from the // QueryDispatcher, otherwise we get it from the current thread's internal context. diff --git a/temporal-sdk/src/test/java/io/temporal/workflow/PromiseTimedGetCancellationReplayTest.java b/temporal-sdk/src/test/java/io/temporal/workflow/PromiseTimedGetCancellationReplayTest.java new file mode 100644 index 0000000000..a2cfad401c --- /dev/null +++ b/temporal-sdk/src/test/java/io/temporal/workflow/PromiseTimedGetCancellationReplayTest.java @@ -0,0 +1,81 @@ +package io.temporal.workflow; + +import io.temporal.testing.WorkflowReplayer; +import java.util.Arrays; +import java.util.Collection; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class PromiseTimedGetCancellationReplayTest { + + @Parameterized.Parameters(name = "{0}") + public static Collection parameters() { + return Arrays.asList( + new Object[][] { + { + "promiseGetTimeoutCancellationLegacyAwaitLegacy.json", + PromiseTimedGetCancellationTest.ReplayWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationLegacyAwaitCancel.json", + PromiseTimedGetCancellationTest.ReplayWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationDetachedAwaitLegacy.json", + PromiseTimedGetCancellationTest.ReplayWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationDetachedAwaitCancel.json", + PromiseTimedGetCancellationTest.ReplayWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationCompletionAwaitLegacy.json", + PromiseTimedGetCancellationTest.ControlledPromiseWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationCompletionAwaitCancel.json", + PromiseTimedGetCancellationTest.ControlledPromiseWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationChildAwaitLegacy.json", + PromiseTimedGetCancellationTest.ChildStartCancellationWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationChildAwaitCancel.json", + PromiseTimedGetCancellationTest.ChildStartCancellationWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationActivityLegacyAwaitLegacy.json", + PromiseTimedGetCancellationTest.ActivityCancellationWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationActivityLegacyAwaitCancel.json", + PromiseTimedGetCancellationTest.ActivityCancellationWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationActivityDetachedAwaitLegacy.json", + PromiseTimedGetCancellationTest.ActivityCancellationWorkflowImpl.class + }, + { + "promiseGetTimeoutCancellationActivityDetachedAwaitCancel.json", + PromiseTimedGetCancellationTest.ActivityCancellationWorkflowImpl.class + } + }); + } + + private final String historyResource; + private final Class workflowImplementation; + + public PromiseTimedGetCancellationReplayTest( + String historyResource, Class workflowImplementation) { + this.historyResource = historyResource; + this.workflowImplementation = workflowImplementation; + } + + @Test + public void replaysHistoryForFlagCombination() throws Exception { + WorkflowReplayer.replayWorkflowExecutionFromResource(historyResource, workflowImplementation); + } +} diff --git a/temporal-sdk/src/test/java/io/temporal/workflow/PromiseTimedGetCancellationTest.java b/temporal-sdk/src/test/java/io/temporal/workflow/PromiseTimedGetCancellationTest.java new file mode 100644 index 0000000000..d7acb9bddb --- /dev/null +++ b/temporal-sdk/src/test/java/io/temporal/workflow/PromiseTimedGetCancellationTest.java @@ -0,0 +1,435 @@ +package io.temporal.workflow; + +import static io.temporal.api.enums.v1.EventType.EVENT_TYPE_TIMER_CANCELED; +import static io.temporal.api.enums.v1.EventType.EVENT_TYPE_TIMER_FIRED; +import static io.temporal.api.enums.v1.EventType.EVENT_TYPE_TIMER_STARTED; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; +import static org.junit.Assume.assumeTrue; + +import io.temporal.activity.Activity; +import io.temporal.activity.ActivityCancellationType; +import io.temporal.activity.ActivityInterface; +import io.temporal.activity.ActivityOptions; +import io.temporal.api.common.v1.WorkflowExecution; +import io.temporal.api.history.v1.HistoryEvent; +import io.temporal.client.WorkflowClient; +import io.temporal.client.WorkflowStub; +import io.temporal.common.WorkflowExecutionHistory; +import io.temporal.failure.ActivityFailure; +import io.temporal.failure.CanceledFailure; +import io.temporal.failure.ChildWorkflowFailure; +import io.temporal.internal.common.SdkFlag; +import io.temporal.internal.statemachines.WorkflowStateMachines; +import io.temporal.testing.WorkflowReplayer; +import io.temporal.testing.internal.SDKTestWorkflowRule; +import java.time.Duration; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.TimeUnit; +import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicReference; +import org.junit.After; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; + +@RunWith(Parameterized.class) +public class PromiseTimedGetCancellationTest { + + private static final Duration LONG_TIMEOUT = Duration.ofSeconds(30); + private static final Duration SHORT_TIMEOUT = Duration.ofMillis(100); + + private final CountDownLatch activityFinished = new CountDownLatch(1); + private final CountDownLatch activityStarted = new CountDownLatch(1); + + @Parameterized.Parameters(name = "detachedTimer={0}, cancelAwaitTimer={1}") + public static Collection parameters() { + return Arrays.asList( + new Object[][] {{false, false}, {false, true}, {true, false}, {true, true}}); + } + + private final boolean detachedTimer; + private final boolean cancelAwaitTimer; + private List savedInitialFlags; + + @Rule + public SDKTestWorkflowRule testWorkflowRule = + SDKTestWorkflowRule.newBuilder() + .setWorkflowTypes( + ControlledPromiseWorkflowImpl.class, + ActivityCancellationWorkflowImpl.class, + ChildStartCancellationWorkflowImpl.class, + ReplayWorkflowImpl.class, + TestChildWorkflowImpl.class) + .setActivityImplementations( + new CancellableActivityImpl(activityStarted, activityFinished)) + .setUseTimeskipping(false) + .build(); + + public PromiseTimedGetCancellationTest(boolean detachedTimer, boolean cancelAwaitTimer) { + this.detachedTimer = detachedTimer; + this.cancelAwaitTimer = cancelAwaitTimer; + } + + @Before + public void setUpSdkFlags() { + savedInitialFlags = WorkflowStateMachines.initialFlags; + List flags = new ArrayList<>(savedInitialFlags); + if (detachedTimer) { + flags.add(SdkFlag.DETACH_NON_CANCELLABLE_PROMISE_GET_TIMER); + } + if (cancelAwaitTimer) { + flags.add(SdkFlag.CANCEL_AWAIT_TIMER_ON_CONDITION); + } + WorkflowStateMachines.initialFlags = Collections.unmodifiableList(flags); + } + + @After + public void restoreSdkFlags() { + WorkflowStateMachines.initialFlags = savedInitialFlags; + } + + @Test + public void nonCancellableGetDoesNotTreatCancellationAsTimeoutWhenFlagEnabled() { + ControlledPromiseWorkflow workflow = + testWorkflowRule.newWorkflowStub(ControlledPromiseWorkflow.class); + WorkflowExecution execution = + WorkflowClient.start(workflow::execute, LONG_TIMEOUT.toMillis(), false); + assertTrue(workflow.isWaiting()); + + workflow.cancelTimedWait(); + if (detachedTimer) { + workflow.complete(); + } + + assertEquals( + detachedTimer ? "completed" : "timeout", + WorkflowStub.fromTyped(workflow).getResult(String.class)); + testWorkflowRule.assertHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_STARTED); + testWorkflowRule.assertHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_CANCELED); + testWorkflowRule.assertNoHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_FIRED); + } + + @Test + public void cancellableGetRemainsCancellationSensitive() { + ControlledPromiseWorkflow workflow = + testWorkflowRule.newWorkflowStub(ControlledPromiseWorkflow.class); + WorkflowClient.start(workflow::execute, LONG_TIMEOUT.toMillis(), true); + assertTrue(workflow.isWaiting()); + + workflow.cancelTimedWait(); + + assertEquals("canceled", WorkflowStub.fromTyped(workflow).getResult(String.class)); + } + + @Test + public void actualTimeoutStillThrowsTimeoutException() { + ControlledPromiseWorkflow workflow = + testWorkflowRule.newWorkflowStub(ControlledPromiseWorkflow.class); + + assertEquals("timeout", workflow.execute(SHORT_TIMEOUT.toMillis(), false)); + } + + @Test + public void completedPromiseCancelsTimeoutTimerAccordingToEnabledFlags() { + ControlledPromiseWorkflow workflow = + testWorkflowRule.newWorkflowStub(ControlledPromiseWorkflow.class); + WorkflowExecution execution = + WorkflowClient.start(workflow::execute, LONG_TIMEOUT.toMillis(), false); + assertTrue(workflow.isWaiting()); + + workflow.complete(); + + assertEquals("completed", WorkflowStub.fromTyped(workflow).getResult(String.class)); + testWorkflowRule.assertHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_STARTED); + if (detachedTimer || cancelAwaitTimer) { + testWorkflowRule.assertHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_CANCELED); + } else { + testWorkflowRule.assertNoHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_CANCELED); + } + testWorkflowRule.assertNoHistoryEvent(execution.getWorkflowId(), EVENT_TYPE_TIMER_FIRED); + } + + @Test + public void childStartCancellationDoesNotBecomeTimeoutWhenFlagEnabled() { + assumeTrue(detachedTimer); + ChildStartCancellationWorkflow workflow = + testWorkflowRule.newWorkflowStub(ChildStartCancellationWorkflow.class); + + assertEquals("canceled", workflow.execute()); + } + + @Test + public void activityCancellationHistoryReplaysWithItsFlagCombination() throws Exception { + ActivityCancellationWorkflow workflow = + testWorkflowRule.newWorkflowStub(ActivityCancellationWorkflow.class); + WorkflowExecution execution = WorkflowClient.start(workflow::execute); + assertTrue(activityStarted.await(10, TimeUnit.SECONDS)); + + workflow.cancelActivityWait(); + + assertEquals( + detachedTimer ? "activity-canceled" : "timeout", + WorkflowStub.fromTyped(workflow).getResult(String.class)); + assertTrue(activityFinished.await(10, TimeUnit.SECONDS)); + WorkflowExecutionHistory history = + testWorkflowRule.getExecutionHistory(execution.getWorkflowId(), execution.getRunId()); + WorkflowReplayer.replayWorkflowExecution(history, testWorkflowRule.getWorker()); + assertEquals( + detachedTimer, hasSdkFlag(history, SdkFlag.DETACH_NON_CANCELLABLE_PROMISE_GET_TIMER)); + assertEquals(cancelAwaitTimer, hasSdkFlag(history, SdkFlag.CANCEL_AWAIT_TIMER_ON_CONDITION)); + } + + @Test + public void generatedHistoryReplaysWithItsFlagCombination() throws Exception { + ReplayWorkflow workflow = testWorkflowRule.newWorkflowStub(ReplayWorkflow.class); + WorkflowExecution execution = WorkflowClient.start(workflow::execute); + assertEquals("timeout", WorkflowStub.fromTyped(workflow).getResult(String.class)); + + WorkflowExecutionHistory history = + testWorkflowRule.getExecutionHistory(execution.getWorkflowId(), execution.getRunId()); + WorkflowReplayer.replayWorkflowExecution(history, testWorkflowRule.getWorker()); + assertEquals( + detachedTimer, hasSdkFlag(history, SdkFlag.DETACH_NON_CANCELLABLE_PROMISE_GET_TIMER)); + assertEquals(cancelAwaitTimer, hasSdkFlag(history, SdkFlag.CANCEL_AWAIT_TIMER_ON_CONDITION)); + } + + @WorkflowInterface + public interface ControlledPromiseWorkflow { + @WorkflowMethod + String execute(long timeoutMillis, boolean cancellable); + + @SignalMethod + void complete(); + + @SignalMethod + void cancelTimedWait(); + + @QueryMethod + boolean isWaiting(); + } + + public static class ControlledPromiseWorkflowImpl implements ControlledPromiseWorkflow { + private CompletablePromise promise; + private CancellationScope timedWaitScope; + private boolean waiting; + + @Override + public String execute(long timeoutMillis, boolean cancellable) { + AtomicReference result = new AtomicReference<>(); + timedWaitScope = + Workflow.newCancellationScope( + () -> { + promise = Workflow.newPromise(); + waiting = true; + try { + result.set( + cancellable + ? promise.cancellableGet(timeoutMillis, TimeUnit.MILLISECONDS) + : promise.get(timeoutMillis, TimeUnit.MILLISECONDS)); + } catch (TimeoutException e) { + result.set("timeout"); + } catch (CanceledFailure e) { + result.set("canceled"); + } + }); + timedWaitScope.run(); + return result.get(); + } + + @Override + public void complete() { + promise.complete("completed"); + } + + @Override + public void cancelTimedWait() { + timedWaitScope.cancel("test cancellation"); + } + + @Override + public boolean isWaiting() { + return waiting; + } + } + + @WorkflowInterface + public interface ActivityCancellationWorkflow { + @WorkflowMethod + String execute(); + + @SignalMethod + void cancelActivityWait(); + } + + public static class ActivityCancellationWorkflowImpl implements ActivityCancellationWorkflow { + private CancellationScope activityScope; + + @Override + public String execute() { + AtomicReference outcome = new AtomicReference<>(); + activityScope = + Workflow.newCancellationScope( + () -> { + CancellableActivity activity = + Workflow.newActivityStub( + CancellableActivity.class, + ActivityOptions.newBuilder() + .setScheduleToCloseTimeout(LONG_TIMEOUT) + .setStartToCloseTimeout(LONG_TIMEOUT) + .setHeartbeatTimeout(Duration.ofSeconds(1)) + .setCancellationType( + ActivityCancellationType.WAIT_CANCELLATION_COMPLETED) + .build()); + Promise result = Async.function(activity::execute); + try { + outcome.set(result.get(LONG_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS)); + } catch (TimeoutException e) { + outcome.set("timeout"); + } catch (ActivityFailure e) { + outcome.set( + e.getCause() instanceof CanceledFailure + ? "activity-canceled" + : "activity-failed"); + } + }); + activityScope.run(); + return outcome.get(); + } + + @Override + public void cancelActivityWait() { + activityScope.cancel("test cancellation"); + } + } + + @ActivityInterface + public interface CancellableActivity { + String execute(); + } + + public static class CancellableActivityImpl implements CancellableActivity { + private final CountDownLatch activityStarted; + private final CountDownLatch activityFinished; + + public CancellableActivityImpl( + CountDownLatch activityStarted, CountDownLatch activityFinished) { + this.activityStarted = activityStarted; + this.activityFinished = activityFinished; + } + + @Override + public String execute() { + activityStarted.countDown(); + try { + while (true) { + Activity.getExecutionContext().heartbeat(null); + try { + Thread.sleep(50); + } catch (InterruptedException e) { + Thread.currentThread().interrupt(); + throw new RuntimeException(e); + } + } + } finally { + activityFinished.countDown(); + } + } + } + + @WorkflowInterface + public interface ChildStartCancellationWorkflow { + @WorkflowMethod + String execute(); + } + + public static class ChildStartCancellationWorkflowImpl implements ChildStartCancellationWorkflow { + @Override + public String execute() { + AtomicReference scope = new AtomicReference<>(); + AtomicReference outcome = new AtomicReference<>(); + scope.set( + Workflow.newCancellationScope( + () -> { + TestChildWorkflow child = Workflow.newChildWorkflowStub(TestChildWorkflow.class); + Async.procedure(child::execute).exceptionally((failure) -> null); + Promise execution = Workflow.getWorkflowExecution(child); + Async.procedure(() -> scope.get().cancel("test cancellation")); + try { + execution.get(LONG_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS); + outcome.set("started"); + } catch (TimeoutException e) { + outcome.set("timeout"); + } catch (ChildWorkflowFailure e) { + outcome.set(e.getCause() instanceof CanceledFailure ? "canceled" : "failed"); + } catch (CanceledFailure e) { + outcome.set("canceled"); + } + })); + scope.get().run(); + return outcome.get(); + } + } + + @WorkflowInterface + public interface TestChildWorkflow { + @WorkflowMethod + void execute(); + } + + public static class TestChildWorkflowImpl implements TestChildWorkflow { + @Override + public void execute() { + Workflow.sleep(Duration.ofHours(1)); + } + } + + @WorkflowInterface + public interface ReplayWorkflow { + @WorkflowMethod + String execute(); + } + + public static class ReplayWorkflowImpl implements ReplayWorkflow { + @Override + public String execute() { + AtomicReference scope = new AtomicReference<>(); + AtomicReference outcome = new AtomicReference<>(); + scope.set( + Workflow.newCancellationScope( + () -> { + CompletablePromise promise = Workflow.newPromise(); + Async.procedure(() -> scope.get().cancel("test cancellation")); + try { + promise.get(SHORT_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS); + outcome.set("completed"); + } catch (TimeoutException e) { + outcome.set("timeout"); + } + })); + scope.get().run(); + return outcome.get(); + } + } + + private static boolean hasSdkFlag(WorkflowExecutionHistory history, SdkFlag flag) { + for (HistoryEvent event : history.getEvents()) { + if (event.hasWorkflowTaskCompletedEventAttributes() + && event + .getWorkflowTaskCompletedEventAttributes() + .getSdkMetadata() + .getLangUsedFlagsList() + .contains(flag.getValue())) { + return true; + } + } + return false; + } +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityDetachedAwaitCancel.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityDetachedAwaitCancel.json new file mode 100644 index 0000000000..bb588c93fd --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityDetachedAwaitCancel.json @@ -0,0 +1,188 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:57:11.753Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ActivityCancellationWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-cancel"}, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "1ae42e69-8212-44c9-bb79-9f648e74521d", + "identity": "sdk-java-test", + "firstExecutionRunId": "1ae42e69-8212-44c9-bb79-9f648e74521d", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:57:11.753Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:57:11.753Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:57:11.755Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 4, 6], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:57:11.755Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED", + "activityTaskScheduledEventAttributes": { + "activityId": "7df0cb48-e08d-3de2-b1ab-1106fbd3f542", + "activityType": {"name": "Execute"}, + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-cancel"}, + "header": {}, + "input": {}, + "scheduleToCloseTimeout": "30s", + "scheduleToStartTimeout": "30s", + "startToCloseTimeout": "30s", + "heartbeatTimeout": "1s", + "workflowTaskCompletedEventId": "3", + "retryPolicy": { + "initialInterval": "1s", + "backoffCoefficient": 2.0, + "maximumInterval": "100s" + } + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:57:11.755Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "5440ff20-82d5-370b-838c-3ab30615a67f", + "startToFireTimeout": "30s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:57:11.755Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "cancelActivityWait", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:57:11.755Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:57:11.755Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "8", "identity": "sdk-java-test"} + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:57:11.756Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "8", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "11", + "eventTime": "2026-08-21T15:57:11.756Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_CANCEL_REQUESTED", + "activityTaskCancelRequestedEventAttributes": { + "scheduledEventId": "5", + "workflowTaskCompletedEventId": "9" + } + }, + { + "eventId": "12", + "eventTime": "2026-08-21T15:57:12.606Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_CANCELED", + "activityTaskCanceledEventAttributes": {"scheduledEventId": "5", "startedEventId": "-1"} + }, + { + "eventId": "13", + "eventTime": "2026-08-21T15:57:12.606Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "14", + "eventTime": "2026-08-21T15:57:12.606Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "13", "identity": "sdk-java-test"} + }, + { + "eventId": "15", + "eventTime": "2026-08-21T15:57:12.610Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "13", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "16", + "eventTime": "2026-08-21T15:57:12.610Z", + "eventType": "EVENT_TYPE_TIMER_CANCELED", + "timerCanceledEventAttributes": { + "timerId": "5440ff20-82d5-370b-838c-3ab30615a67f", + "startedEventId": "6", + "workflowTaskCompletedEventId": "14" + } + }, + { + "eventId": "17", + "eventTime": "2026-08-21T15:57:12.610Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ImFjdGl2aXR5LWNhbmNlbGVkIg\u003d\u003d"} + ] + }, + "workflowTaskCompletedEventId": "14" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityDetachedAwaitLegacy.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityDetachedAwaitLegacy.json new file mode 100644 index 0000000000..3378607c10 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityDetachedAwaitLegacy.json @@ -0,0 +1,188 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:57:10.857Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ActivityCancellationWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-legacy"}, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "7505ecb8-582f-4a81-97e9-5962f9404f1f", + "identity": "sdk-java-test", + "firstExecutionRunId": "7505ecb8-582f-4a81-97e9-5962f9404f1f", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:57:10.857Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:57:10.858Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:57:10.861Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 6], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:57:10.861Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED", + "activityTaskScheduledEventAttributes": { + "activityId": "09d09061-2cbb-3bc1-a4d6-b6486942828e", + "activityType": {"name": "Execute"}, + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-legacy"}, + "header": {}, + "input": {}, + "scheduleToCloseTimeout": "30s", + "scheduleToStartTimeout": "30s", + "startToCloseTimeout": "30s", + "heartbeatTimeout": "1s", + "workflowTaskCompletedEventId": "3", + "retryPolicy": { + "initialInterval": "1s", + "backoffCoefficient": 2.0, + "maximumInterval": "100s" + } + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:57:10.861Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "43b2a8b5-cc5a-3c97-893c-cdafea78a789", + "startToFireTimeout": "30s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:57:10.862Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "cancelActivityWait", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:57:10.862Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:57:10.863Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "8", "identity": "sdk-java-test"} + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:57:10.864Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "8", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "11", + "eventTime": "2026-08-21T15:57:10.864Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_CANCEL_REQUESTED", + "activityTaskCancelRequestedEventAttributes": { + "scheduledEventId": "5", + "workflowTaskCompletedEventId": "9" + } + }, + { + "eventId": "12", + "eventTime": "2026-08-21T15:57:11.721Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_CANCELED", + "activityTaskCanceledEventAttributes": {"scheduledEventId": "5", "startedEventId": "-1"} + }, + { + "eventId": "13", + "eventTime": "2026-08-21T15:57:11.721Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-detached-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "14", + "eventTime": "2026-08-21T15:57:11.721Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "13", "identity": "sdk-java-test"} + }, + { + "eventId": "15", + "eventTime": "2026-08-21T15:57:11.735Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "13", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "16", + "eventTime": "2026-08-21T15:57:11.735Z", + "eventType": "EVENT_TYPE_TIMER_CANCELED", + "timerCanceledEventAttributes": { + "timerId": "43b2a8b5-cc5a-3c97-893c-cdafea78a789", + "startedEventId": "6", + "workflowTaskCompletedEventId": "14" + } + }, + { + "eventId": "17", + "eventTime": "2026-08-21T15:57:11.735Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ImFjdGl2aXR5LWNhbmNlbGVkIg\u003d\u003d"} + ] + }, + "workflowTaskCompletedEventId": "14" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityLegacyAwaitCancel.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityLegacyAwaitCancel.json new file mode 100644 index 0000000000..3441db5e3a --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityLegacyAwaitCancel.json @@ -0,0 +1,155 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:57:09.813Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ActivityCancellationWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-cancel"}, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "56bbea45-72d4-44af-88bd-d40936d07731", + "identity": "sdk-java-test", + "firstExecutionRunId": "56bbea45-72d4-44af-88bd-d40936d07731", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:57:09.813Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:57:09.813Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:57:09.815Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 4], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:57:09.815Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED", + "activityTaskScheduledEventAttributes": { + "activityId": "d195f7cf-41dc-36b0-8d28-ec19bd022494", + "activityType": {"name": "Execute"}, + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-cancel"}, + "header": {}, + "input": {}, + "scheduleToCloseTimeout": "30s", + "scheduleToStartTimeout": "30s", + "startToCloseTimeout": "30s", + "heartbeatTimeout": "1s", + "workflowTaskCompletedEventId": "3", + "retryPolicy": { + "initialInterval": "1s", + "backoffCoefficient": 2.0, + "maximumInterval": "100s" + } + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:57:09.815Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "f753a4f9-82f3-3e9b-bd6b-21d19d1be8ea", + "startToFireTimeout": "30s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:57:09.815Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "cancelActivityWait", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:57:09.815Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:57:09.815Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "8", "identity": "sdk-java-test"} + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:57:09.817Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "8", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "11", + "eventTime": "2026-08-21T15:57:09.817Z", + "eventType": "EVENT_TYPE_TIMER_CANCELED", + "timerCanceledEventAttributes": { + "timerId": "f753a4f9-82f3-3e9b-bd6b-21d19d1be8ea", + "startedEventId": "6", + "workflowTaskCompletedEventId": "9" + } + }, + { + "eventId": "12", + "eventTime": "2026-08-21T15:57:09.817Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_CANCEL_REQUESTED", + "activityTaskCancelRequestedEventAttributes": { + "scheduledEventId": "5", + "workflowTaskCompletedEventId": "9" + } + }, + { + "eventId": "13", + "eventTime": "2026-08-21T15:57:09.817Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "InRpbWVvdXQi"} + ] + }, + "workflowTaskCompletedEventId": "9" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityLegacyAwaitLegacy.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityLegacyAwaitLegacy.json new file mode 100644 index 0000000000..f9dc5b766b --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationActivityLegacyAwaitLegacy.json @@ -0,0 +1,155 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:57:08.826Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ActivityCancellationWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-legacy"}, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "3184d327-9dbe-4faa-b0ac-af3cacf2370d", + "identity": "sdk-java-test", + "firstExecutionRunId": "3184d327-9dbe-4faa-b0ac-af3cacf2370d", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:57:08.826Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:57:08.834Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:57:08.913Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:57:08.913Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_SCHEDULED", + "activityTaskScheduledEventAttributes": { + "activityId": "22dab2c1-79a1-3da5-aebc-2997bf5cfb98", + "activityType": {"name": "Execute"}, + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-legacy"}, + "header": {}, + "input": {}, + "scheduleToCloseTimeout": "30s", + "scheduleToStartTimeout": "30s", + "startToCloseTimeout": "30s", + "heartbeatTimeout": "1s", + "workflowTaskCompletedEventId": "3", + "retryPolicy": { + "initialInterval": "1s", + "backoffCoefficient": 2.0, + "maximumInterval": "100s" + } + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:57:08.913Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "2e08b957-8dae-3b99-93e7-e346580c699d", + "startToFireTimeout": "30s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:57:08.922Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "cancelActivityWait", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:57:08.922Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-activity-legacy-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:57:08.922Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "8", "identity": "sdk-java-test"} + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:57:08.931Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "8", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "11", + "eventTime": "2026-08-21T15:57:08.931Z", + "eventType": "EVENT_TYPE_ACTIVITY_TASK_CANCEL_REQUESTED", + "activityTaskCancelRequestedEventAttributes": { + "scheduledEventId": "5", + "workflowTaskCompletedEventId": "9" + } + }, + { + "eventId": "12", + "eventTime": "2026-08-21T15:57:08.931Z", + "eventType": "EVENT_TYPE_TIMER_CANCELED", + "timerCanceledEventAttributes": { + "timerId": "2e08b957-8dae-3b99-93e7-e346580c699d", + "startedEventId": "6", + "workflowTaskCompletedEventId": "9" + } + }, + { + "eventId": "13", + "eventTime": "2026-08-21T15:57:08.931Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "InRpbWVvdXQi"} + ] + }, + "workflowTaskCompletedEventId": "9" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationChildAwaitCancel.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationChildAwaitCancel.json new file mode 100644 index 0000000000..919dc11999 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationChildAwaitCancel.json @@ -0,0 +1,67 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:42:29.925Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ChildStartCancellationWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-child-await-cancel"}, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "217203e9-7740-4867-a972-6e90503f3683", + "identity": "sdk-java-test", + "firstExecutionRunId": "217203e9-7740-4867-a972-6e90503f3683", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:42:29.925Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-child-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:42:29.925Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:42:29.926Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 4, 6], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:42:29.926Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ImNhbmNlbGVkIg\u003d\u003d"} + ] + }, + "workflowTaskCompletedEventId": "3" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationChildAwaitLegacy.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationChildAwaitLegacy.json new file mode 100644 index 0000000000..73d4885e88 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationChildAwaitLegacy.json @@ -0,0 +1,67 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:42:29.624Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ChildStartCancellationWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-child-await-legacy"}, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "f0513048-6ef2-4a0c-961f-cf110e493fb8", + "identity": "sdk-java-test", + "firstExecutionRunId": "f0513048-6ef2-4a0c-961f-cf110e493fb8", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:42:29.624Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-child-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:42:29.624Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:42:29.633Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 6], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:42:29.633Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ImNhbmNlbGVkIg\u003d\u003d"} + ] + }, + "workflowTaskCompletedEventId": "3" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationCompletionAwaitCancel.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationCompletionAwaitCancel.json new file mode 100644 index 0000000000..64f3103d43 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationCompletionAwaitCancel.json @@ -0,0 +1,193 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:42:29.939Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ControlledPromiseWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-completion-await-cancel"}, + "input": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "MzAwMDA\u003d"}, + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ZmFsc2U\u003d"} + ] + }, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "f3d9bcd9-91df-42fb-8d1e-2b0586ad4e19", + "identity": "sdk-java-test", + "firstExecutionRunId": "f3d9bcd9-91df-42fb-8d1e-2b0586ad4e19", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:42:29.939Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:42:29.939Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:42:29.940Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 4, 6], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:42:29.940Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "a05d66d8-6061-3a7e-9919-5b7efb87c64e", + "startToFireTimeout": "30s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:42:29.940Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 2 + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:42:29.940Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "6", "identity": "sdk-java-test"} + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:42:29.940Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "6", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "cancelTimedWait", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "11", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "10", "identity": "sdk-java-test"} + }, + { + "eventId": "12", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "10", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "13", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "complete", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "14", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-cancel"}, + "startToCloseTimeout": "10s", + "attempt": 2 + } + }, + { + "eventId": "15", + "eventTime": "2026-08-21T15:42:29.941Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "14", "identity": "sdk-java-test"} + }, + { + "eventId": "16", + "eventTime": "2026-08-21T15:42:29.942Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "14", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "17", + "eventTime": "2026-08-21T15:42:29.942Z", + "eventType": "EVENT_TYPE_TIMER_CANCELED", + "timerCanceledEventAttributes": { + "timerId": "a05d66d8-6061-3a7e-9919-5b7efb87c64e", + "startedEventId": "5", + "workflowTaskCompletedEventId": "15" + } + }, + { + "eventId": "18", + "eventTime": "2026-08-21T15:42:29.942Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ImNvbXBsZXRlZCI\u003d"} + ] + }, + "workflowTaskCompletedEventId": "15" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationCompletionAwaitLegacy.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationCompletionAwaitLegacy.json new file mode 100644 index 0000000000..854d734347 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationCompletionAwaitLegacy.json @@ -0,0 +1,193 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:42:29.683Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": {"name": "ControlledPromiseWorkflow"}, + "taskQueue": {"name": "promise-get-timeout-completion-await-legacy"}, + "input": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "MzAwMDA\u003d"}, + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ZmFsc2U\u003d"} + ] + }, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "ae5d2049-4640-447b-907e-a6f5e4d0b386", + "identity": "sdk-java-test", + "firstExecutionRunId": "ae5d2049-4640-447b-907e-a6f5e4d0b386", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:42:29.683Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:42:29.683Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "2", "identity": "sdk-java-test"} + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:42:29.684Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [1, 3, 6], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:42:29.684Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "16e032f5-d075-374b-8f6c-23b7272e51db", + "startToFireTimeout": "30s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:42:29.684Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 2 + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:42:29.684Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "6", "identity": "sdk-java-test"} + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:42:29.685Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "6", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:42:29.685Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "cancelTimedWait", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:42:29.685Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "11", + "eventTime": "2026-08-21T15:42:29.685Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "10", "identity": "sdk-java-test"} + }, + { + "eventId": "12", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "10", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "13", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_SIGNALED", + "workflowExecutionSignaledEventAttributes": { + "signalName": "complete", + "input": {}, + "identity": "sdk-java-test" + } + }, + { + "eventId": "14", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": {"name": "promise-get-timeout-completion-await-legacy"}, + "startToCloseTimeout": "10s", + "attempt": 2 + } + }, + { + "eventId": "15", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": {"scheduledEventId": "14", "identity": "sdk-java-test"} + }, + { + "eventId": "16", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "14", + "identity": "sdk-java-test", + "sdkMetadata": {"sdkName": "temporal-java", "sdkVersion": "1.38.0"}, + "meteringMetadata": {} + } + }, + { + "eventId": "17", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_TIMER_CANCELED", + "timerCanceledEventAttributes": { + "timerId": "16e032f5-d075-374b-8f6c-23b7272e51db", + "startedEventId": "5", + "workflowTaskCompletedEventId": "15" + } + }, + { + "eventId": "18", + "eventTime": "2026-08-21T15:42:29.686Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + {"metadata": {"encoding": "anNvbi9wbGFpbg\u003d\u003d"}, "data": "ImNvbXBsZXRlZCI\u003d"} + ] + }, + "workflowTaskCompletedEventId": "15" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationDetachedAwaitCancel.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationDetachedAwaitCancel.json new file mode 100644 index 0000000000..af6b146740 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationDetachedAwaitCancel.json @@ -0,0 +1,142 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:25:22.965Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": { + "name": "ReplayWorkflow" + }, + "taskQueue": { + "name": "promise-get-timeout-cancellation-detached-await-cancel" + }, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "f8969f3a-663d-41a6-a779-f9f88ecf305b", + "identity": "sdk-java-test", + "firstExecutionRunId": "f8969f3a-663d-41a6-a779-f9f88ecf305b", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:25:22.965Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": { + "name": "promise-get-timeout-cancellation-detached-await-cancel" + }, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:25:22.965Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "historySizeBytes": "487" + } + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:25:22.966Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [ + 1, + 3, + 4, + 6 + ], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:25:22.966Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "a9f9acc2-3390-3419-9925-5bf7bd219417", + "startToFireTimeout": "0.100s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:25:23.068Z", + "eventType": "EVENT_TYPE_TIMER_FIRED", + "timerFiredEventAttributes": { + "timerId": "a9f9acc2-3390-3419-9925-5bf7bd219417", + "startedEventId": "5" + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:25:23.068Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": { + "name": "promise-get-timeout-cancellation-detached-await-cancel" + }, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:25:23.068Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": { + "scheduledEventId": "7", + "identity": "sdk-java-test", + "historySizeBytes": "915" + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:25:23.069Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "7", + "identity": "sdk-java-test", + "sdkMetadata": { + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:25:23.069Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + { + "metadata": { + "encoding": "anNvbi9wbGFpbg\u003d\u003d" + }, + "data": "InRpbWVvdXQi" + } + ] + }, + "workflowTaskCompletedEventId": "8" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationDetachedAwaitLegacy.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationDetachedAwaitLegacy.json new file mode 100644 index 0000000000..71c63c5044 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationDetachedAwaitLegacy.json @@ -0,0 +1,141 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:25:22.714Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": { + "name": "ReplayWorkflow" + }, + "taskQueue": { + "name": "promise-get-timeout-cancellation-detached-await-legacy" + }, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "f6dacd9b-47ea-46e5-9e0d-2b4a51fe1a00", + "identity": "sdk-java-test", + "firstExecutionRunId": "f6dacd9b-47ea-46e5-9e0d-2b4a51fe1a00", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:25:22.714Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": { + "name": "promise-get-timeout-cancellation-detached-await-legacy" + }, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:25:22.714Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "historySizeBytes": "489" + } + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:25:22.715Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [ + 1, + 3, + 6 + ], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:25:22.715Z", + "eventType": "EVENT_TYPE_TIMER_STARTED", + "timerStartedEventAttributes": { + "timerId": "f190739d-3f5e-3995-86e8-c6c58c49fc6f", + "startToFireTimeout": "0.100s", + "workflowTaskCompletedEventId": "3" + } + }, + { + "eventId": "6", + "eventTime": "2026-08-21T15:25:22.820Z", + "eventType": "EVENT_TYPE_TIMER_FIRED", + "timerFiredEventAttributes": { + "timerId": "f190739d-3f5e-3995-86e8-c6c58c49fc6f", + "startedEventId": "5" + } + }, + { + "eventId": "7", + "eventTime": "2026-08-21T15:25:22.820Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": { + "name": "promise-get-timeout-cancellation-detached-await-legacy" + }, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "8", + "eventTime": "2026-08-21T15:25:22.820Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": { + "scheduledEventId": "7", + "identity": "sdk-java-test", + "historySizeBytes": "919" + } + }, + { + "eventId": "9", + "eventTime": "2026-08-21T15:25:22.821Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "7", + "identity": "sdk-java-test", + "sdkMetadata": { + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "10", + "eventTime": "2026-08-21T15:25:22.821Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + { + "metadata": { + "encoding": "anNvbi9wbGFpbg\u003d\u003d" + }, + "data": "InRpbWVvdXQi" + } + ] + }, + "workflowTaskCompletedEventId": "8" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationLegacyAwaitCancel.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationLegacyAwaitCancel.json new file mode 100644 index 0000000000..130cfdc860 --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationLegacyAwaitCancel.json @@ -0,0 +1,86 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:25:22.560Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": { + "name": "ReplayWorkflow" + }, + "taskQueue": { + "name": "promise-get-timeout-cancellation-legacy-await-cancel" + }, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "d7f44ef3-2ca4-48b1-b451-20438f3e0658", + "identity": "sdk-java-test", + "firstExecutionRunId": "d7f44ef3-2ca4-48b1-b451-20438f3e0658", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:25:22.560Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": { + "name": "promise-get-timeout-cancellation-legacy-await-cancel" + }, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:25:22.560Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "historySizeBytes": "489" + } + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:25:22.561Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [ + 1, + 3, + 4 + ], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:25:22.561Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + { + "metadata": { + "encoding": "anNvbi9wbGFpbg\u003d\u003d" + }, + "data": "InRpbWVvdXQi" + } + ] + }, + "workflowTaskCompletedEventId": "3" + } + } + ] +} diff --git a/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationLegacyAwaitLegacy.json b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationLegacyAwaitLegacy.json new file mode 100644 index 0000000000..c84722715d --- /dev/null +++ b/temporal-sdk/src/test/resources/promiseGetTimeoutCancellationLegacyAwaitLegacy.json @@ -0,0 +1,85 @@ +{ + "events": [ + { + "eventId": "1", + "eventTime": "2026-08-21T15:25:22.368Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_STARTED", + "workflowExecutionStartedEventAttributes": { + "workflowType": { + "name": "ReplayWorkflow" + }, + "taskQueue": { + "name": "promise-get-timeout-cancellation-legacy-await-legacy" + }, + "input": {}, + "workflowExecutionTimeout": "315360000s", + "workflowRunTimeout": "315360000s", + "workflowTaskTimeout": "10s", + "originalExecutionRunId": "2327f43d-d86f-4b4a-aca1-94cea1e4172f", + "identity": "sdk-java-test", + "firstExecutionRunId": "2327f43d-d86f-4b4a-aca1-94cea1e4172f", + "attempt": 1, + "firstWorkflowTaskBackoff": "0s", + "header": {} + } + }, + { + "eventId": "2", + "eventTime": "2026-08-21T15:25:22.368Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_SCHEDULED", + "workflowTaskScheduledEventAttributes": { + "taskQueue": { + "name": "promise-get-timeout-cancellation-legacy-await-legacy" + }, + "startToCloseTimeout": "10s", + "attempt": 1 + } + }, + { + "eventId": "3", + "eventTime": "2026-08-21T15:25:22.369Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_STARTED", + "workflowTaskStartedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "historySizeBytes": "491" + } + }, + { + "eventId": "4", + "eventTime": "2026-08-21T15:25:22.374Z", + "eventType": "EVENT_TYPE_WORKFLOW_TASK_COMPLETED", + "workflowTaskCompletedEventAttributes": { + "scheduledEventId": "2", + "identity": "sdk-java-test", + "sdkMetadata": { + "langUsedFlags": [ + 1, + 3 + ], + "sdkName": "temporal-java", + "sdkVersion": "1.38.0" + }, + "meteringMetadata": {} + } + }, + { + "eventId": "5", + "eventTime": "2026-08-21T15:25:22.374Z", + "eventType": "EVENT_TYPE_WORKFLOW_EXECUTION_COMPLETED", + "workflowExecutionCompletedEventAttributes": { + "result": { + "payloads": [ + { + "metadata": { + "encoding": "anNvbi9wbGFpbg\u003d\u003d" + }, + "data": "InRpbWVvdXQi" + } + ] + }, + "workflowTaskCompletedEventId": "3" + } + } + ] +}