Function TestConnStateMachine_FIFOOrdering

internal/pool/conn_state_test.go:393–462

(t *testing.T)

}

func TestConnStateMachine_FIFOOrdering(t *testing.T) {
	sm := NewConnStateMachine()
	sm.Transition(StateInitializing) // Start in INITIALIZING so all waiters must queue

	const numGoroutines = 10
	var executionOrder []int
	var orderMu sync.Mutex
	var wg sync.WaitGroup

	// Launch goroutines one at a time, ensuring each is queued before launching the next
	for i := 0; i < numGoroutines; i++ {
		wg.Add(1)
		expectedWaiters := int32(i + 1)

		go func(id int) {
			defer wg.Done()

			ctx := context.Background()

			// This should queue in FIFO order
			_, err := sm.AwaitAndTransition(ctx, []ConnState{StateIdle}, StateInitializing)
			if err != nil {
				t.Errorf("Goroutine %d: failed to transition: %v", id, err)
				return
			}

			// Record execution order
			orderMu.Lock()
			executionOrder = append(executionOrder, id)
			orderMu.Unlock()

			t.Logf("Goroutine %d: executed (position %d)", id, len(executionOrder))

			// Transition back to IDLE to allow next waiter
			sm.Transition(StateIdle)
		}(i)

		// Wait until this goroutine has been queued before launching the next
		// Poll the waiter count to ensure the goroutine is actually queued
		timeout := time.After(100 * time.Millisecond)
		for {
			if sm.waiterCount.Load() >= expectedWaiters {
				break
			}
			select {
			case <-timeout:
				t.Fatalf("Timeout waiting for goroutine %d to queue", i)
			case <-time.After(1 * time.Millisecond):
				// Continue polling
			}
		}
	}

	// Give all goroutines time to fully settle in the queue
	time.Sleep(10 * time.Millisecond)

	// Transition to IDLE to start processing the queue
	sm.Transition(StateIdle)