fix: report an event after a delete event as imminent reconciliation

Context.isNextReconciliationImminent() only checked ResourceState.eventPresent(),
which is false for ADDITIONAL_EVENT_PRESENT_AFTER_DELETE_EVENT. In
triggerReconcilerOnAllEvents mode that state does trigger a new reconciliation
right after the current one, both on the success path
(eventProcessingFinished) and on the failure path (handleRetryOnException), so
the method contradicted its own contract and a reconciler could skip a status
update that nothing else would produce.

Extract the condition handleRetryOnException already computed into a shared
helper and use it for isNextReconciliationImminent() too, so the two cannot
drift apart again. The condition is the one that holds regardless of whether
the current reconciliation succeeds or throws; documented on Context.

Author: csviri

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/api/reconciler/Context.java

@@ -253,6 +253,10 @@ default ResourceEventRecorder eventRecorder() {
    * reconciliation is already scheduled, which would in turn trigger another status update, thus
    * rendering the current one moot.
    *
+   * <p>This holds regardless of whether the current reconciliation succeeds or throws, so with
+   * {@link ControllerConfiguration#triggerReconcilerOnAllEvents()} it also covers an event that
+   * arrived after a delete event.
+   *
    * @return {@code true} is another reconciliation is already scheduled, {@code false} otherwise
    */
   boolean isNextReconciliationImminent();

operator-framework-core/src/main/java/io/javaoperatorsdk/operator/processing/event/EventProcessor.java

@@ -380,9 +380,7 @@ private void handleRetryOnException(
       ExecutionScope<P> executionScope, Exception exception, boolean errorHandledByReconciler) {
     final var state = getOrInitRetryExecution(executionScope);
     var resourceID = state.getId();
-    boolean eventPresent =
-        state.eventPresent()
-            || (triggerOnAllEvents() && state.isAdditionalEventPresentAfterDeleteEvent());
+    boolean eventPresent = nextReconciliationImminent(state);
     state.markEventReceived();
     retryAwareErrorLogging(
         state.getRetry(), eventPresent, errorHandledByReconciler, exception, executionScope);
@@ -511,7 +509,19 @@ public synchronized void start() throws OperatorException {
   }
 
   public boolean isNextReconciliationImminent(ResourceID resourceID) {
-    return resourceStateManager.getOrCreate(resourceID).eventPresent();
+    return nextReconciliationImminent(resourceStateManager.getOrCreate(resourceID));
+  }
+
+  /**
+   * An event that arrives after a delete event is tracked in a dedicated state, so {@link
+   * ResourceState#eventPresent()} alone does not cover it. Such an event triggers a new
+   * reconciliation right after the current one, both when it succeeds (see {@link
+   * #eventProcessingFinished}) and when it fails (see {@link #handleRetryOnException}), so it has
+   * to be reported as imminent too.
+   */
+  private boolean nextReconciliationImminent(ResourceState state) {
+    return state.eventPresent()
+        || (triggerOnAllEvents() && state.isAdditionalEventPresentAfterDeleteEvent());
   }
 
   private void handleAlreadyMarkedEvents() {

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

@@ -96,9 +96,9 @@ public UpdateControl<TriggerReconcilerOnAllEventCustomResource> reconcile(
       // 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.
+      // re-triggering because of a superseding event. isNextReconciliationImminent() reports the
+      // same condition the framework evaluates 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) {