Split slow tests for speed

Author: GregoryTravis

…ityResultOverServerLongPollWaitTest.java …sultAsyncOverServerLongPollWaitTest.javatemporal-sdk/src/test/java/io/temporal/client/functional/GetActivityResultOverServerLongPollWaitTest.java renamed to temporal-sdk/src/test/java/io/temporal/client/functional/GetActivityResultAsyncOverServerLongPollWaitTest.java temporal-sdk/src/test/java/io/temporal/client/functional/GetActivityResultOverServerLongPollWaitTest.java renamed to temporal-sdk/src/test/java/io/temporal/client/functional/GetActivityResultAsyncOverServerLongPollWaitTest.java

@@ -16,13 +16,15 @@
 import org.junit.Test;
 
 /**
- * Verifies that {@link ActivityHandle#getResult()} and {@link ActivityHandle#getResultAsync()}
- * continue polling after the server cuts a long poll and returns an empty response. The server cuts
- * activity long polls after approximately {@value ACTIVITY_LONG_POLL_TIMEOUT_SECONDS} seconds; the
- * activity here runs for 1.5× that so the server-side cut fires at least once before the activity
- * completes.
+ * Verifies that {@link ActivityHandle#getResultAsync()} continues polling after the server cuts a
+ * long poll and returns an empty response. The server cuts activity long polls after approximately
+ * {@value ACTIVITY_LONG_POLL_TIMEOUT_SECONDS} seconds; the activity here runs for 1.5× that so the
+ * server-side cut fires at least once before the activity completes.
+ *
+ * <p>It has a sync version in {@link GetActivityResultSyncOverServerLongPollWaitTest} that is split
+ * to reduce the total execution time.
  */
-public class GetActivityResultOverServerLongPollWaitTest {
+public class GetActivityResultAsyncOverServerLongPollWaitTest {
   private static final int ACTIVITY_LONG_POLL_TIMEOUT_SECONDS = 20;
 
   @ActivityInterface
@@ -63,12 +65,6 @@ private StartActivityOptions slowOpts() {
         .build();
   }
 
-  @Test(timeout = 2 * ACTIVITY_LONG_POLL_TIMEOUT_SECONDS * 1000)
-  public void testGetResult() {
-    assumeTrue(SDKTestWorkflowRule.useExternalService);
-    newActivityClient().execute(SlowActivity.class, SlowActivity::run, slowOpts());
-  }
-
   @Test(timeout = 2 * ACTIVITY_LONG_POLL_TIMEOUT_SECONDS * 1000)
   public void testGetResultAsync() throws ExecutionException, InterruptedException {
     assumeTrue(SDKTestWorkflowRule.useExternalService);

temporal-sdk/src/test/java/io/temporal/client/functional/GetActivityResultSyncOverServerLongPollWaitTest.java

@@ -0,0 +1,72 @@
+package io.temporal.client.functional;
+
+import static org.junit.Assume.assumeTrue;
+
+import io.temporal.activity.ActivityInterface;
+import io.temporal.activity.ActivityMethod;
+import io.temporal.client.ActivityClient;
+import io.temporal.client.ActivityClientOptions;
+import io.temporal.client.ActivityHandle;
+import io.temporal.client.StartActivityOptions;
+import io.temporal.testing.internal.SDKTestWorkflowRule;
+import java.time.Duration;
+import java.util.UUID;
+import org.junit.Rule;
+import org.junit.Test;
+
+/**
+ * Verifies that {@link ActivityHandle#getResult()} continues polling after the server cuts a long
+ * poll and returns an empty response. The server cuts activity long polls after approximately
+ * {@value ACTIVITY_LONG_POLL_TIMEOUT_SECONDS} seconds; the activity here runs for 1.5× that so the
+ * server-side cut fires at least once before the activity completes.
+ *
+ * <p>It has an async version in {@link GetActivityResultAsyncOverServerLongPollWaitTest} that is
+ * split to reduce the total execution time.
+ */
+public class GetActivityResultSyncOverServerLongPollWaitTest {
+  private static final int ACTIVITY_LONG_POLL_TIMEOUT_SECONDS = 20;
+
+  @ActivityInterface
+  public interface SlowActivity {
+    @ActivityMethod(name = "SlowActivity")
+    void run();
+  }
+
+  public static class SlowActivityImpl implements SlowActivity {
+    @Override
+    public void run() {
+      try {
+        Thread.sleep(Duration.ofSeconds(3 * ACTIVITY_LONG_POLL_TIMEOUT_SECONDS / 2).toMillis());
+      } catch (InterruptedException e) {
+        Thread.currentThread().interrupt();
+      }
+    }
+  }
+
+  @Rule
+  public SDKTestWorkflowRule testWorkflowRule =
+      SDKTestWorkflowRule.newBuilder()
+          .setUseTimeskipping(false)
+          .setActivityImplementations(new SlowActivityImpl())
+          .build();
+
+  private ActivityClient newActivityClient() {
+    return ActivityClient.newInstance(
+        testWorkflowRule.getWorkflowClient().getWorkflowServiceStubs(),
+        ActivityClientOptions.newBuilder().setNamespace(SDKTestWorkflowRule.NAMESPACE).build());
+  }
+
+  private StartActivityOptions slowOpts() {
+    return StartActivityOptions.newBuilder()
+        .setId("slow-act-" + UUID.randomUUID())
+        .setTaskQueue(testWorkflowRule.getTaskQueue())
+        .setScheduleToCloseTimeout(Duration.ofMinutes(2))
+        .build();
+  }
+
+  @Test(timeout = 2 * ACTIVITY_LONG_POLL_TIMEOUT_SECONDS * 1000)
+  public void testGetResult() {
+    assumeTrue(SDKTestWorkflowRule.useExternalService);
+    newActivityClient().execute(SlowActivity.class, SlowActivity::run, slowOpts());
+  }
+}