test: deflake additionalEventDuringRetryOnDeleteEvent

The test released the blocked reconciler right after the update call returned,
but the update event still had to travel back through the informer. When the
reconciliation failed before the event was registered, the framework treated
the failure as a plain retry (consuming the last attempt) instead of instantly
re-triggering because of a superseding event, so only 4 instead of 5
reconciliations happened.

Wait for isNextReconciliationImminent() in the reconciler, which reflects
exactly the state the framework checks after the reconciliation fails and
cannot be unset while it is in progress. Also fix the isWaiting() assertion
that had no terminal assertion and was therefore a no-op.

Author: csviri

operator-framework/src/test/java/io/javaoperatorsdk/operator/baseapi/triggerallevent/eventing/TriggerReconcilerOnAllEventIT.java

@@ -192,14 +192,16 @@ void additionalEventDuringRetryOnDeleteEvent() {
     await()
         .untilAsserted(
             () -> {
-              assertThat(reconciler.isWaiting());
+              assertThat(reconciler.isWaiting()).isTrue();
             });
 
     // trigger reconciliation while waiting in reconciler
     res = getResource();
     res.getMetadata().getAnnotations().put("my-annotation", "true");
     extension.update(res);
-    // continue reconciliation
+    // continue reconciliation; the reconciler additionally waits until the framework actually
+    // registered the event above, otherwise the failure below would consume a retry attempt
+    // instead of being instantly re-triggered by the superseding event
     reconciler.setContinuerOnRetryWait(true);
 
     await()

operator-framework/src/test/java/io/javaoperatorsdk/operator/baseapi/triggerallevent/eventing/TriggerReconcilerOnAllEventReconciler.java

@@ -35,6 +35,10 @@ public class TriggerReconcilerOnAllEventReconciler
   public static final String ADDITIONAL_FINALIZER = "all.event.mode/finalizer2";
   public static final String NO_MORE_EXCEPTION_ANNOTATION_KEY = "no.more.exception";
 
+  // safety net so a missing event does not block the reconciler thread forever, the test assertions
+  // fail long before this elapses
+  private static final long MAX_WAIT_FOR_SUPERSEDING_EVENT_MILLIS = 30_000;
+
   private static final Logger log =
       LoggerFactory.getLogger(TriggerReconcilerOnAllEventReconciler.class);
 
@@ -82,7 +86,16 @@ public UpdateControl<TriggerReconcilerOnAllEventCustomResource> reconcile(
         && context.getRetryInfo().isPresent()
         && context.getRetryInfo().orElseThrow().getAttemptCount() == 1) {
       waiting = true;
-      while (!continuerOnRetryWait) {
+      // Releasing on continuerOnRetryWait alone is racy: the test sets that flag right after the
+      // update call returns, but the update event still has to travel back through the informer.
+      // If this reconciliation failed before the event was registered, the framework would treat
+      // the failure as a plain retry (consuming the last attempt) instead of instantly
+      // re-triggering because of a superseding event. isNextReconciliationImminent() reflects
+      // exactly the state (event marked as received) the framework checks after this
+      // reconciliation fails, and it cannot be unset while this reconciliation is in progress.
+      var waitUntil = System.currentTimeMillis() + MAX_WAIT_FOR_SUPERSEDING_EVENT_MILLIS;
+      while ((!continuerOnRetryWait || !context.isNextReconciliationImminent())
+          && System.currentTimeMillis() < waitUntil) {
         Thread.sleep(50);
       }
       waiting = false;