test: depend on awaitility properly and use it for the new waits

versions.gradle has pinned awaitility 4.2.0 since forever, but tests/build.gradle
never declared it — so ApiClientTest was importing
org.testcontainers.shaded.org.awaitility.Awaitility, i.e. borrowing the copy
shaded inside testcontainers. That is a transitive accident: it breaks silently
whenever testcontainers changes its shading or is upgraded, and it is why nobody
noticed the real dependency was missing.

Declare the dependency, point ApiClientTest at the real package, and express the
two new waits (waitUntilSignalable, retryUntil) with awaitility instead of
hand-rolled while/sleep loops. failFast() gives the signal wait a proper
terminal-state abort rather than polling to the deadline after the workflow has
already failed.

waitForWorkflowStatus is deliberately left as-is: it is used across the whole
suite and rewriting it risks changing behaviour for tests unrelated to this
change. Its Thread.sleep is a poll interval, which is fine — the problem was
never sleeping, it was sleeping *instead of* checking a condition.

Author: manan164

tests/build.gradle

@@ -16,6 +16,7 @@ dependencies {
     testRuntimeOnly "org.junit.jupiter:junit-jupiter-engine:${versions.junit}"
     testImplementation "ch.qos.logback:logback-classic:1.5.32"
     testImplementation "org.mockito:mockito-core:${versions.mockito}"
+    testImplementation "org.awaitility:awaitility:${versions.awaitility}"
     testImplementation "org.testcontainers:localstack:${versions.testContainers}"
     testImplementation "org.testcontainers:testcontainers:${versions.testContainers}"
 }

tests/src/test/java/io/orkes/conductor/client/ApiClientTest.java

@@ -30,7 +30,7 @@
 import static java.util.concurrent.TimeUnit.SECONDS;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertNotNull;
-import static org.testcontainers.shaded.org.awaitility.Awaitility.await;
+import static org.awaitility.Awaitility.await;
 
 public class ApiClientTest {
     private static final String workflowName = "test_api_client_wf";

tests/src/test/java/io/orkes/conductor/client/util/TestUtil.java

@@ -15,6 +15,8 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
+import java.time.Duration;
+import java.util.concurrent.Callable;
 import java.util.concurrent.TimeoutException;
 
 import com.netflix.conductor.common.config.ObjectMapperProvider;
@@ -25,6 +27,8 @@
 
 import com.fasterxml.jackson.databind.ObjectMapper;
 
+import static org.awaitility.Awaitility.await;
+
 public class TestUtil {
     private static int RETRY_ATTEMPT_LIMIT = 4;
     protected static ObjectMapper objectMapper = new ObjectMapperProvider().getObjectMapper();
@@ -134,28 +138,34 @@ public static Workflow waitForWorkflowStatus(OrkesWorkflowClient workflowClient,
     public static void waitUntilSignalable(OrkesWorkflowClient workflowClient,
                                            String workflowId,
                                            long maxWaitTimeMs,
-                                           long pollIntervalMs) throws Exception {
-        long endTime = System.currentTimeMillis() + maxWaitTimeMs;
-
-        while (System.currentTimeMillis() < endTime) {
-            Workflow workflow = workflowClient.getWorkflow(workflowId, true);
+                                           long pollIntervalMs) {
+        await().atMost(Duration.ofMillis(maxWaitTimeMs))
+                .pollInterval(Duration.ofMillis(pollIntervalMs))
+                .failFast("workflow reached a terminal state before it could be signalled",
+                        () -> isTerminalFailure(workflowClient.getWorkflow(workflowId, true)))
+                .until(() -> {
+                    Workflow workflow = workflowClient.getWorkflow(workflowId, true);
+                    return workflow.getStatus() == Workflow.WorkflowStatus.RUNNING
+                            && workflow.getTasks() != null
+                            && workflow.getTasks().stream().anyMatch(t -> !t.getStatus().isTerminal());
+                });
+    }
 
-            if (workflow.getStatus() == Workflow.WorkflowStatus.FAILED
-                    || workflow.getStatus() == Workflow.WorkflowStatus.TERMINATED) {
-                throw new RuntimeException(describeFailure(workflow));
-            }
-            boolean hasPendingTask = workflow.getTasks() != null
-                    && workflow.getTasks().stream().anyMatch(t -> !t.getStatus().isTerminal());
-            if (workflow.getStatus() == Workflow.WorkflowStatus.RUNNING && hasPendingTask) {
-                return;
-            }
-            Thread.sleep(pollIntervalMs);
-        }
+    /**
+     * Retries {@code call} until it returns without throwing. For endpoints that are eventually
+     * consistent or intermittently slow, where a single attempt after a fixed sleep turns ordinary
+     * latency into a test failure.
+     */
+    public static <T> T retryUntil(Callable<T> call, long maxWaitTimeMs, long pollIntervalMs) {
+        return await().atMost(Duration.ofMillis(maxWaitTimeMs))
+                .pollInterval(Duration.ofMillis(pollIntervalMs))
+                .ignoreExceptions()
+                .until(call, result -> true);
+    }
 
-        Workflow finalState = workflowClient.getWorkflow(workflowId, true);
-        throw new TimeoutException(String.format(
-                "Workflow %s was not signalable within %dms. Status: %s, tasks: %s",
-                workflowId, maxWaitTimeMs, finalState.getStatus(), taskSummary(finalState)));
+    private static boolean isTerminalFailure(Workflow workflow) {
+        return workflow.getStatus() == Workflow.WorkflowStatus.FAILED
+                || workflow.getStatus() == Workflow.WorkflowStatus.TERMINATED;
     }
 
     /** Includes the reason and task states — without these a failure is undiagnosable from CI logs. */
@@ -177,27 +187,4 @@ private static String taskSummary(Workflow workflow) {
                 .append(' '));
         return sb.append(']').toString();
     }
-
-    /**
-     * Retries {@code call} until it returns without throwing. Intended for endpoints that are
-     * eventually consistent or intermittently slow, where a single attempt after a fixed sleep
-     * turns ordinary latency into a test failure.
-     */
-    public static <T> T retryUntil(java.util.concurrent.Callable<T> call,
-                                   long maxWaitTimeMs,
-                                   long pollIntervalMs) throws Exception {
-        long endTime = System.currentTimeMillis() + maxWaitTimeMs;
-        Exception last = null;
-
-        while (System.currentTimeMillis() < endTime) {
-            try {
-                return call.call();
-            } catch (Exception e) {
-                last = e;
-                Thread.sleep(pollIntervalMs);
-            }
-        }
-        throw new TimeoutException("Call did not succeed within " + maxWaitTimeMs + "ms"
-                + (last == null ? "" : ", last error: " + last));
-    }
 }