refactor(flowcontrol): Enable behavioral mocking (kubernetes-sigs#1202)

The existing mock implementations for the flow control framework
policies and accessors were simple stubs that returned fixed values.
This style of mocking is too restrictive for testing complex, concurrent
components where behavior needs to be dynamically controlled at test
time.

To prepare for testing more advanced orchestration logic, this commit
refactors the core mocks to use function fields instead of static return
values. This transforms them from simple stubs into flexible, behavioral
mocks. Tests can now inject custom logic at runtime to simulate a wide
range of policy decisions and interactions.

The following mocks were updated:
- MockPriorityBandAccessor
- MockIntraFlowDispatchPolicy
- MockInterFlowDispatchPolicy

The policy tests that consume these mocks have been updated to use this
new, more powerful mocking pattern.

Author: LukeAVanDrie

pkg/epp/flowcontrol/framework/mocks/mocks.go

@@ -21,7 +21,7 @@ import (
 	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/flowcontrol/types"
 )
 
-// MockItemComparator provides a mock implementation of the `framework.ItemComparator` interface.
+// MockItemComparator is a simple stub mock for the `framework.ItemComparator` interface.
 type MockItemComparator struct {
 	FuncV      framework.ItemComparatorFunc
 	ScoreTypeV string
@@ -30,12 +30,11 @@ type MockItemComparator struct {
 func (m *MockItemComparator) Func() framework.ItemComparatorFunc { return m.FuncV }
 func (m *MockItemComparator) ScoreType() string                  { return m.ScoreTypeV }
 
-var _ framework.ItemComparator = &MockItemComparator{}
-
-// MockFlowQueueAccessor is a mock implementation of the `framework.FlowQueueAccessor` interface.
+// MockFlowQueueAccessor is a simple stub mock for the `framework.FlowQueueAccessor` interface.
+// It is used for tests that require static, predictable return values from a queue accessor.
+// For complex, stateful queue behavior, use the mock in `contracts/mocks.MockManagedQueue`.
 type MockFlowQueueAccessor struct {
 	NameV         string
-	CapabilitiesV []framework.QueueCapability
 	LenV          int
 	ByteSizeV     uint64
 	PeekHeadV     types.QueueItemAccessor
@@ -44,12 +43,15 @@ type MockFlowQueueAccessor struct {
 	PeekTailErrV  error
 	FlowSpecV     types.FlowSpecification
 	ComparatorV   framework.ItemComparator
+	CapabilitiesV []framework.QueueCapability
 }
 
 func (m *MockFlowQueueAccessor) Name() string                              { return m.NameV }
-func (m *MockFlowQueueAccessor) Capabilities() []framework.QueueCapability { return m.CapabilitiesV }
 func (m *MockFlowQueueAccessor) Len() int                                  { return m.LenV }
 func (m *MockFlowQueueAccessor) ByteSize() uint64                          { return m.ByteSizeV }
+func (m *MockFlowQueueAccessor) Comparator() framework.ItemComparator      { return m.ComparatorV }
+func (m *MockFlowQueueAccessor) FlowSpec() types.FlowSpecification         { return m.FlowSpecV }
+func (m *MockFlowQueueAccessor) Capabilities() []framework.QueueCapability { return m.CapabilitiesV }
 
 func (m *MockFlowQueueAccessor) PeekHead() (types.QueueItemAccessor, error) {
 	return m.PeekHeadV, m.PeekHeadErrV
@@ -59,51 +61,47 @@ func (m *MockFlowQueueAccessor) PeekTail() (types.QueueItemAccessor, error) {
 	return m.PeekTailV, m.PeekTailErrV
 }
 
-func (m *MockFlowQueueAccessor) Comparator() framework.ItemComparator { return m.ComparatorV }
-func (m *MockFlowQueueAccessor) FlowSpec() types.FlowSpecification    { return m.FlowSpecV }
-
 var _ framework.FlowQueueAccessor = &MockFlowQueueAccessor{}
 
-// MockPriorityBandAccessor is a mock implementation of the `framework.PriorityBandAccessor` interface.
+// MockPriorityBandAccessor is a behavioral mock for the `framework.MockPriorityBandAccessor` interface.
+// Simple accessors are configured with public value fields (e.g., `PriorityV`).
+// Complex methods with logic are configured with function fields (e.g., `IterateQueuesFunc`).
 type MockPriorityBandAccessor struct {
-	PriorityV      uint
-	PriorityNameV  string
-	FlowIDsV       []string
-	QueueV         framework.FlowQueueAccessor // Value to return for any Queue(flowID) call
-	QueueFuncV     func(flowID string) framework.FlowQueueAccessor
-	IterateQueuesV func(callback func(queue framework.FlowQueueAccessor) bool)
+	PriorityV         uint
+	PriorityNameV     string
+	FlowIDsFunc       func() []string
+	QueueFunc         func(flowID string) framework.FlowQueueAccessor
+	IterateQueuesFunc func(callback func(queue framework.FlowQueueAccessor) (keepIterating bool))
 }
 
 func (m *MockPriorityBandAccessor) Priority() uint       { return m.PriorityV }
 func (m *MockPriorityBandAccessor) PriorityName() string { return m.PriorityNameV }
-func (m *MockPriorityBandAccessor) FlowIDs() []string    { return m.FlowIDsV }
+
+func (m *MockPriorityBandAccessor) FlowIDs() []string {
+	if m.FlowIDsFunc != nil {
+		return m.FlowIDsFunc()
+	}
+	return nil
+}
 
 func (m *MockPriorityBandAccessor) Queue(flowID string) framework.FlowQueueAccessor {
-	if m.QueueFuncV != nil {
-		return m.QueueFuncV(flowID)
+	if m.QueueFunc != nil {
+		return m.QueueFunc(flowID)
 	}
-	return m.QueueV
+	return nil
 }
 
 func (m *MockPriorityBandAccessor) IterateQueues(callback func(queue framework.FlowQueueAccessor) bool) {
-	if m.IterateQueuesV != nil {
-		m.IterateQueuesV(callback)
-	} else {
-		// Default behavior: iterate based on FlowIDsV and QueueV/QueueFuncV
-		for _, id := range m.FlowIDsV {
-			q := m.Queue(id)
-			if q != nil { // Only call callback if queue exists
-				if !callback(q) {
-					return
-				}
-			}
-		}
+	if m.IterateQueuesFunc != nil {
+		m.IterateQueuesFunc(callback)
 	}
 }
 
 var _ framework.PriorityBandAccessor = &MockPriorityBandAccessor{}
 
-// MockSafeQueue is a mock implementation of the `framework.SafeQueue` interface.
+// MockSafeQueue is a simple stub mock for the `framework.SafeQueue` interface.
+// It is used for tests that need to control the exact return values of a queue's methods without simulating the queue's
+// internal logic or state.
 type MockSafeQueue struct {
 	NameV         string
 	CapabilitiesV []framework.QueueCapability
@@ -162,24 +160,48 @@ func (m *MockSafeQueue) Drain() ([]types.QueueItemAccessor, error) {
 
 var _ framework.SafeQueue = &MockSafeQueue{}
 
-// MockIntraFlowDispatchPolicy is a mock implementation of the `framework.IntraFlowDispatchPolicy` interface.
+// MockIntraFlowDispatchPolicy is a behavioral mock for the `framework.IntraFlowDispatchPolicy` interface.
+// Simple accessors are configured with public value fields (e.g., `NameV`).
+// Complex methods with logic are configured with function fields (e.g., `SelectItemFunc`).
 type MockIntraFlowDispatchPolicy struct {
 	NameV                      string
-	SelectItemV                types.QueueItemAccessor
-	SelectItemErrV             error
 	ComparatorV                framework.ItemComparator
 	RequiredQueueCapabilitiesV []framework.QueueCapability
+	SelectItemFunc             func(queue framework.FlowQueueAccessor) (types.QueueItemAccessor, error)
 }
 
 func (m *MockIntraFlowDispatchPolicy) Name() string                         { return m.NameV }
 func (m *MockIntraFlowDispatchPolicy) Comparator() framework.ItemComparator { return m.ComparatorV }
+func (m *MockIntraFlowDispatchPolicy) RequiredQueueCapabilities() []framework.QueueCapability {
+	return m.RequiredQueueCapabilitiesV
+}
 
 func (m *MockIntraFlowDispatchPolicy) SelectItem(queue framework.FlowQueueAccessor) (types.QueueItemAccessor, error) {
-	return m.SelectItemV, m.SelectItemErrV
+	if m.SelectItemFunc != nil {
+		return m.SelectItemFunc(queue)
+	}
+	return nil, nil
 }
 
-func (m *MockIntraFlowDispatchPolicy) RequiredQueueCapabilities() []framework.QueueCapability {
-	return m.RequiredQueueCapabilitiesV
+var _ framework.IntraFlowDispatchPolicy = &MockIntraFlowDispatchPolicy{}
+
+// MockInterFlowDispatchPolicy is a behavioral mock for the `framework.InterFlowDispatchPolicy` interface.
+// Simple accessors are configured with public value fields (e.g., `NameV`).
+// Complex methods with logic are configured with function fields (e.g., `SelectQueueFunc`).
+type MockInterFlowDispatchPolicy struct {
+	NameV           string
+	SelectQueueFunc func(band framework.PriorityBandAccessor) (framework.FlowQueueAccessor, error)
 }
 
-var _ framework.IntraFlowDispatchPolicy = &MockIntraFlowDispatchPolicy{}
+func (m *MockInterFlowDispatchPolicy) Name() string {
+	return m.NameV
+}
+
+func (m *MockInterFlowDispatchPolicy) SelectQueue(band framework.PriorityBandAccessor) (framework.FlowQueueAccessor, error) {
+	if m.SelectQueueFunc != nil {
+		return m.SelectQueueFunc(band)
+	}
+	return nil, nil
+}
+
+var _ framework.InterFlowDispatchPolicy = &MockInterFlowDispatchPolicy{}