HYPERFLEET-1062 - fix: remove transient state assertions from E2E tests

E2E tests were asserting on transient intermediate states (Reconciled=False,
Applied=False) that could complete before the first poll, causing flaky
tier0-nightly failures. Replaced with final-state-only validation per
distributed systems testing best practices. Also reduced cl-job sleep
duration from 15s to 1s.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ciaranRoche

e2e/cluster/creation.go

@@ -2,7 +2,6 @@ package cluster
 
 import (
 	"context"
-	"time"
 
 	"github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega" //nolint:staticcheck // dot import for test readability
@@ -35,28 +34,10 @@ var _ = ginkgo.Describe("[Suite: cluster][baseline] Cluster Resource Type Lifecy
 
 		ginkgo.Describe("Basic Workflow Validation", ginkgo.Label(labels.Tier0), func() {
 			// This test validates the end-to-end cluster lifecycle workflow:
-			// 1. Cluster creation via API with initial condition validation
-			// 2. Required adapter execution with comprehensive metadata validation
-			// 3. Final cluster state verification (Reconciled and Available conditions)
+			// 1. Required adapter execution with comprehensive metadata validation
+			// 2. Final cluster state verification (Reconciled and Available conditions)
 			ginkgo.It("should validate complete workflow from creation to Reconciled state",
 				func(ctx context.Context) {
-					ginkgo.By("Verify initial status of cluster")
-					// Verify initial conditions are False, indicating workflow has not completed yet
-					// This ensures the cluster starts in the correct initial state
-					cluster, err := h.Client.GetCluster(ctx, clusterID)
-					Expect(err).NotTo(HaveOccurred(), "failed to get cluster")
-					Expect(cluster.Status).NotTo(BeNil(), "cluster status should be present")
-
-					hasReconciledFalse := h.HasResourceCondition(cluster.Status.Conditions,
-						client.ConditionTypeReconciled, openapi.ResourceConditionStatusFalse)
-					Expect(hasReconciledFalse).To(BeTrue(),
-						"initial cluster conditions should have Reconciled=False")
-
-					hasAvailableFalse := h.HasResourceCondition(cluster.Status.Conditions,
-						client.ConditionTypeAvailable, openapi.ResourceConditionStatusFalse)
-					Expect(hasAvailableFalse).To(BeTrue(),
-						"initial cluster conditions should have Available=False")
-
 					ginkgo.By("Verify required adapter execution results")
 					// Validate required adapters from config have completed successfully
 					// If an adapter fails, we can identify which specific adapter failed
@@ -238,137 +219,54 @@ var _ = ginkgo.Describe("[Suite: cluster][baseline] Cluster Resource Type Lifecy
 		})
 
 		ginkgo.Describe("Adapter Dependency Relationships Workflow Validation", ginkgo.Label(labels.Tier0), func() {
-			// This test validates adapter dependency relationships:
-			// 1. During cl-job execution: cl-deployment Applied=False and Available=Unknown (never False)
-			// 2. After cl-job completes: cl-deployment can proceed (no validation on Available during execution)
-			// 3. Eventually: cl-deployment Available becomes True (success)
+			// This test validates that dependent adapters complete successfully.
+			// cl-deployment depends on cl-job — the workflow engine enforces this ordering.
+			// We validate the final converged state: both adapters reach Applied=True, Available=True, Health=True.
 			ginkgo.It("should validate cl-deployment dependency on cl-job with comprehensive condition checks",
 				func(ctx context.Context) {
-					pollingInterval := "1s"
-
-					ginkgo.By("Verify cl-deployment initial state and dependency waiting behavior")
-					// Capture cl-deployment's initial waiting state
-					// Poll until cl-deployment appears in the statuses
-					var foundInitialState bool
+					ginkgo.By("Verify cl-job and cl-deployment both reach final converged state")
 					Eventually(func(g Gomega) {
-						foundInitialState = false
 						statuses, err := h.Client.GetClusterStatuses(ctx, clusterID)
 						g.Expect(err).NotTo(HaveOccurred(), "failed to get cluster statuses")
 
-						// Find cl-deployment adapter
+						adapterMap := make(map[string]openapi.AdapterStatus)
 						for _, adapter := range statuses.Items {
-							if adapter.Adapter == "cl-deployment" {
-								foundInitialState = true
-
-								// Verify initial waiting state
-								hasAppliedFalse := h.HasAdapterCondition(
-									adapter.Conditions,
-									client.ConditionTypeApplied,
-									openapi.AdapterConditionStatusFalse,
-								)
-								g.Expect(hasAppliedFalse).To(BeTrue(),
-									"cl-deployment Applied condition should be False initially (waiting for cl-job)")
-
-								hasAvailableUnknown := h.HasAdapterCondition(
-									adapter.Conditions,
-									client.ConditionTypeAvailable,
-									openapi.AdapterConditionStatusUnknown,
-								)
-								g.Expect(hasAvailableUnknown).To(BeTrue(),
-									"cl-deployment Available condition should be Unknown initially (waiting for cl-job)")
-
-								hasHealthTrue := h.HasAdapterCondition(
-									adapter.Conditions,
-									client.ConditionTypeHealth,
-									openapi.AdapterConditionStatusTrue,
-								)
-								g.Expect(hasHealthTrue).To(BeTrue(),
-									"cl-deployment Health condition should be True (adapter is healthy, just waiting)")
-
-								return
-							}
+							adapterMap[adapter.Adapter] = adapter
 						}
-						g.Expect(foundInitialState).To(BeTrue(), "cl-deployment adapter should appear in statuses")
-					}, h.Cfg.Timeouts.Adapter.Processing, pollingInterval).Should(Succeed())
-
-					ginkgo.By("Verify dependency: cl-deployment Applied=False and Available=Unknown during cl-job execution")
-					// Poll continuously until cl-deployment Available becomes True:
-					// - Before cl-job Available=True: verify cl-deployment Applied=False and Available!=False
-					// - After cl-job Available=True: only wait for cl-deployment Available=True
-					// - Exit when cl-deployment Available=True
-					timeout := time.After(h.Cfg.Timeouts.Adapter.Processing)
-					ticker := time.NewTicker(1 * time.Second)
-					defer ticker.Stop()
-
-					var jobAvailableReachedTrue bool
-
-				pollLoop:
-					for {
-						select {
-						case <-timeout:
-							ginkgo.Fail("Timed out waiting for cl-deployment Available condition to become True")
-						case <-ticker.C:
-							statuses, err := h.Client.GetClusterStatuses(ctx, clusterID)
-							Expect(err).NotTo(HaveOccurred(), "failed to get cluster statuses")
-
-							var jobAvailableTrue bool
-							var deploymentAppliedTrue bool
-							var deploymentAvailableTrue bool
-							var deploymentAvailableFalse bool
-
-							for _, adapter := range statuses.Items {
-								if adapter.Adapter == "cl-job" {
-									jobAvailableTrue = h.HasAdapterCondition(
-										adapter.Conditions,
-										client.ConditionTypeAvailable,
-										openapi.AdapterConditionStatusTrue,
-									)
-								}
-								if adapter.Adapter == "cl-deployment" {
-									deploymentAppliedTrue = h.HasAdapterCondition(
-										adapter.Conditions,
-										client.ConditionTypeApplied,
-										openapi.AdapterConditionStatusTrue,
-									)
-									deploymentAvailableTrue = h.HasAdapterCondition(
-										adapter.Conditions,
-										client.ConditionTypeAvailable,
-										openapi.AdapterConditionStatusTrue,
-									)
-									deploymentAvailableFalse = h.HasAdapterCondition(
-										adapter.Conditions,
-										client.ConditionTypeAvailable,
-										openapi.AdapterConditionStatusFalse,
-									)
-								}
-							}
 
-							// Track when cl-job Available first becomes True
-							if jobAvailableTrue && !jobAvailableReachedTrue {
-								jobAvailableReachedTrue = true
-								ginkgo.GinkgoWriter.Printf("cl-job Available=True reached, cl-deployment can now proceed\n")
-							}
+						for _, name := range []string{"cl-job", "cl-deployment"} {
+							adapter, exists := adapterMap[name]
+							g.Expect(exists).To(BeTrue(), "adapter %s should be present in statuses", name)
 
-							// Validate dependency enforcement: only check while cl-job is still executing
-							if !jobAvailableReachedTrue {
-								// cl-deployment should not start applying resources until cl-job completes
-								Expect(deploymentAppliedTrue).To(BeFalse(),
-									"cl-deployment Applied should remain False while cl-job Available is not True yet")
+							g.Expect(adapter.ObservedGeneration).To(Equal(int32(1)),
+								"adapter %s should have observed_generation=1 for new creation request", name)
 
-								// cl-deployment Available should stay Unknown (not False) while waiting for cl-job
-								Expect(deploymentAvailableFalse).To(BeFalse(),
-									"cl-deployment Available must be Unknown (not False) during cl-job execution")
-							}
+							g.Expect(h.HasAdapterCondition(adapter.Conditions,
+								client.ConditionTypeApplied, openapi.AdapterConditionStatusTrue)).To(BeTrue(),
+								"adapter %s should have Applied=True", name)
+
+							g.Expect(h.HasAdapterCondition(adapter.Conditions,
+								client.ConditionTypeAvailable, openapi.AdapterConditionStatusTrue)).To(BeTrue(),
+								"adapter %s should have Available=True", name)
 
-							// Exit when cl-deployment Available becomes True (workflow complete)
-							if deploymentAvailableTrue {
-								ginkgo.GinkgoWriter.Printf("cl-deployment Available=True reached, dependency validation successful\n")
-								break pollLoop
+							g.Expect(h.HasAdapterCondition(adapter.Conditions,
+								client.ConditionTypeHealth, openapi.AdapterConditionStatusTrue)).To(BeTrue(),
+								"adapter %s should have Health=True", name)
+
+							for _, condition := range adapter.Conditions {
+								g.Expect(condition.Reason).NotTo(BeNil(),
+									"adapter %s condition %s should have non-nil reason", name, condition.Type)
+								g.Expect(*condition.Reason).NotTo(BeEmpty(),
+									"adapter %s condition %s should have non-empty reason", name, condition.Type)
+								g.Expect(condition.Message).NotTo(BeNil(),
+									"adapter %s condition %s should have non-nil message", name, condition.Type)
+								g.Expect(*condition.Message).NotTo(BeEmpty(),
+									"adapter %s condition %s should have non-empty message", name, condition.Type)
+								g.Expect(condition.LastTransitionTime).NotTo(BeZero(),
+									"adapter %s condition %s should have valid last_transition_time", name, condition.Type)
 							}
 						}
-					}
-
-					ginkgo.GinkgoWriter.Printf("Successfully validated cl-deployment dependency on cl-job with correct condition transitions\n")
+					}, h.Cfg.Timeouts.Adapter.Processing, h.Cfg.Polling.Interval).Should(Succeed())
 				})
 		})
 

e2e/nodepool/creation.go

@@ -3,7 +3,6 @@ package nodepool
 import (
 	"context"
 	"fmt"
-	"time"
 
 	"github.com/onsi/ginkgo/v2"
 	. "github.com/onsi/gomega" //nolint:staticcheck // dot import for test readability
@@ -43,37 +42,10 @@ var _ = ginkgo.Describe("[Suite: nodepool][baseline] NodePool Resource Type Life
 
 		ginkgo.Describe("Basic Workflow Validation", ginkgo.Label(labels.Tier0), func() {
 			// This test validates the end-to-end nodepool lifecycle workflow:
-			// 1. Initial condition validation (Reconciled=False, Available=False)
-			// 2. Required adapter execution with comprehensive metadata validation
-			// 3. Final nodepool state verification (Reconciled and Available conditions)
+			// 1. Required adapter execution with comprehensive metadata validation
+			// 2. Final nodepool state verification (Reconciled and Available conditions)
 			ginkgo.It("should validate complete workflow from creation to Reconciled state",
 				func(ctx context.Context) {
-					var err error
-
-					ginkgo.By("Verify initial status of nodepool")
-					// Verify initial conditions are False, indicating workflow has not completed yet
-					// This ensures the nodepool starts in the correct initial state
-					// Use Eventually to handle race conditions where conditions might not be populated yet
-					initStatusPollInterval := time.Second
-					initCheckTimeout := 3 * time.Second
-					Eventually(func(g Gomega) {
-
-						np, err := h.Client.GetNodePool(ctx, clusterID, nodepoolID)
-						g.Expect(err).NotTo(HaveOccurred(), "failed to get nodepool")
-						g.Expect(np.Status).NotTo(BeNil(), "nodepool status should be present")
-						g.Expect(np.Status.Conditions).NotTo(BeEmpty(), "conditions should be populated")
-
-						hasReconciledFalse := h.HasResourceCondition(np.Status.Conditions,
-							client.ConditionTypeReconciled, openapi.ResourceConditionStatusFalse)
-						g.Expect(hasReconciledFalse).To(BeTrue(),
-							"initial nodepool conditions should have Reconciled=False")
-
-						hasAvailableFalse := h.HasResourceCondition(np.Status.Conditions,
-							client.ConditionTypeAvailable, openapi.ResourceConditionStatusFalse)
-						g.Expect(hasAvailableFalse).To(BeTrue(),
-							"initial nodepool conditions should have Available=False")
-					}, initCheckTimeout, initStatusPollInterval).Should(Succeed())
-
 					ginkgo.By("Verify required adapter execution results")
 					// Validate required adapters from config have completed successfully
 					// If an adapter fails, we can identify which specific adapter failed

test-design/testcases/cluster.md

@@ -58,20 +58,8 @@ curl -X POST ${API_URL}/api/hyperfleet/v1/clusters \
 
 **Expected Result:**
 - Response includes the created cluster ID and initial metadata
-- Initial cluster conditions have `status: False` for both condition `{"type": "Reconciled"}` and `{"type": "Available"}`
 
-#### Step 2: Verify initial status of cluster
-**Action:**
-- Poll cluster status for initial response
-```bash
-curl -X GET ${API_URL}/api/hyperfleet/v1/clusters/{cluster_id}
-```
-
-**Expected Result:**
-- Cluster `Reconciled` condition `status: False`
-- Cluster `Available` condition `status: False`
-
-#### Step 3: Verify required adapter execution results
+#### Step 2: Verify required adapter execution results
 
 **Action:**
 - Retrieve adapter statuses information:
@@ -100,7 +88,7 @@ curl -X GET ${API_URL}/api/hyperfleet/v1/clusters/{cluster_id}/statuses
 - Config file: `configs/config.yaml` under `adapters.cluster`
 - Environment variable: `HYPERFLEET_ADAPTERS_CLUSTER` (comma-separated list)
 
-#### Step 4: Verify final cluster state
+#### Step 3: Verify final cluster state
 
 **Action:**
 - Wait for cluster Reconciled condition to transition to True
@@ -110,12 +98,11 @@ curl -X GET ${API_URL}/api/hyperfleet/v1/clusters/{cluster_id}
 ```
 
 **Expected Result:**
-- Cluster `Reconciled` condition transitions from `status: False` to `status: True`
 - Final cluster conditions have `status: True` for both condition `{"type": "Reconciled"}` and `{"type": "Available"}`
 - Validate that the observedGeneration for the Reconciled and Available conditions is 1 for a new creation request
 - This confirms the cluster has reached the desired end state
 
-#### Step 5: Cleanup resources
+#### Step 4: Cleanup resources
 
 **Action:**
 - Delete the cluster via the API:
@@ -252,7 +239,7 @@ kubectl delete namespace {cluster_id} --ignore-not-found
 
 ### Description
 
-This test validates that CLM correctly handles adapter dependency relationships when processing a clusters resource request. Specifically, it verifies the dependency relationship where the cl-deployment adapter depends on the cl-job adapter completion. The test continuously polls and validates throughout the workflow period to ensure: (1) cl-deployment's Applied condition remains False until cl-job's Available condition reaches True, enforcing the dependency precondition; (2) during cl-job execution, cl-deployment's Available condition stays Unknown (never False), confirming the adapter waits correctly without attempting execution; (3) successful completion with cl-deployment's Available eventually transitioning to True. This validation demonstrates that the workflow engine properly enforces adapter dependencies and ensures dependent adapters wait for prerequisites before executing.
+This test validates that CLM correctly handles adapter dependency relationships when processing a clusters resource request. Specifically, it verifies the dependency relationship where the cl-deployment adapter depends on the cl-job adapter completion. The test validates the final converged state: both cl-job and cl-deployment reach Applied=True, Available=True, and Health=True. Dependency ordering is enforced by the workflow engine and validated at the unit/integration test level; the E2E test confirms the end-to-end outcome.
 
 ---
 
@@ -291,47 +278,20 @@ curl -X POST ${API_URL}/api/hyperfleet/v1/clusters \
 **Expected Result:**
 - API returns successful response
 
-#### Step 2: Verify cl-deployment initial state and dependency waiting behavior
-
-**Action:**
-- Poll adapter statuses to capture cl-deployment's initial waiting state:
-```bash
-curl -X GET ${API_URL}/api/hyperfleet/v1/clusters/{cluster_id}/statuses
-```
-
-**Expected Result:**
-At the initial state (when cl-deployment first appears in statuses):
-- Response returns HTTP 200 (OK) status code
-- The `cl-deployment` adapter is present with initial waiting state:
-  - `Applied` condition has `status: "False"` (deployment hasn't been applied yet, waiting for cl-job dependency)
-  - `Available` condition has `status: "Unknown"` (deployment hasn't been applied yet)
-  - `Health` condition has `status: "True"` (adapter itself is healthy, just waiting)
-
-#### Step 3: Verify dependency relationship and condition transitions throughout entire workflow
+#### Step 2: Verify cl-job and cl-deployment both reach final state
 
 **Action:**
-- Continuously poll adapter statuses from the initial state until cl-deployment completes:
+- Poll adapter statuses until both adapters reach their final state:
 ```bash
 curl -X GET ${API_URL}/api/hyperfleet/v1/clusters/{cluster_id}/statuses
 ```
 
 **Expected Result:**
-Throughout the entire period (from initial state until cl-deployment completes), validate the following on each poll:
-
-**Validation 1 - Dependency enforcement (during cl-job execution):**
-- While `cl-job` adapter's `Available` condition has NOT reached `status: "True"`:
-  - The `cl-deployment` adapter's `Applied` condition must remain `status: "False"`
-  - The `cl-deployment` adapter's `Available` condition must remain `status: "Unknown"` (never `status: "False"`)
-  - This validates that cl-deployment waits for cl-job to complete without attempting to apply resources
-
-**Validation 2 - Success condition:**
-- Once `cl-job` adapter's `Available` reaches `status: "True"`, cl-deployment can proceed with execution
-- Once `cl-deployment` completes execution, its `Available` condition eventually becomes `status: "True"`
-- This confirms the complete dependency workflow succeeded
+- Both `cl-job` and `cl-deployment` adapters are present in the statuses response
+- Each adapter has all three conditions with `status: "True"`: `Applied`, `Available`, `Health`
+- This confirms the dependency workflow completed successfully end-to-end
 
-**Note:** After cl-job completes, cl-deployment's `Available` condition may temporarily be `False` (e.g., `MinimumReplicasUnavailable` during deployment startup) before becoming `True`, which is expected behavior and not validated.
-
-#### Step 4: Cleanup resources
+#### Step 3: Cleanup resources
 
 **Action:**
 - Delete the cluster via the API: