refactor: share EndpointPool construction logic

Signed-off-by: Varad <[email protected]>

Author: varad-ahirwadkar

cmd/epp/runner/runner.go

@@ -36,7 +36,6 @@ import (
 	uberzap "go.uber.org/zap"
 	"google.golang.org/grpc"
 	healthPb "google.golang.org/grpc/health/grpc_health_v1"
-	"k8s.io/apimachinery/pkg/labels"
 	"k8s.io/apimachinery/pkg/runtime/schema"
 	"k8s.io/apimachinery/pkg/types"
 	"k8s.io/client-go/rest"
@@ -350,18 +349,15 @@ func (r *Runner) Run(ctx context.Context) error {
 
 func setupDatastore(ctx context.Context, epFactory datalayer.EndpointFactory, modelServerMetricsPort int32,
 	startCrdReconcilers bool, namespace, name, endpointSelector string, endpointTargetPorts []int) (datastore.Datastore, error) {
+
 	if startCrdReconcilers {
 		return datastore.NewDatastore(ctx, epFactory, modelServerMetricsPort), nil
 	} else {
-		endpointPool := datalayer.NewEndpointPool(namespace, name)
-		labelsMap, err := labels.ConvertSelectorToLabelsMap(endpointSelector)
+		endpointPool, err := runserver.NewEndpointPoolFromOptions(namespace, name, endpointSelector, endpointTargetPorts)
 		if err != nil {
-			setupLog.Error(err, "Failed to parse flag %q with error: %w", "endpoint-selector", err)
+			setupLog.Error(err, "Failed to construct endpoint pool from options")
 			return nil, err
 		}
-		endpointPool.Selector = labelsMap
-		endpointPool.TargetPorts = append(endpointPool.TargetPorts, endpointTargetPorts...)
-
 		endpointPoolOption := datastore.WithEndpointPool(endpointPool)
 		return datastore.NewDatastore(ctx, epFactory, modelServerMetricsPort, endpointPoolOption), nil
 	}

pkg/epp/server/endpoint_pool_factory.go

@@ -0,0 +1,44 @@
+package server
+
+import (
+	"errors"
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/labels"
+
+	"sigs.k8s.io/gateway-api-inference-extension/pkg/epp/datalayer"
+)
+
+// NewEndpointPoolFromOptions constructs an EndpointPool from standalone options.
+// This is shared between the production runner and standalone integration tests.
+func NewEndpointPoolFromOptions(
+	namespace string,
+	name string,
+	endpointSelector string,
+	endpointTargetPorts []int,
+) (*datalayer.EndpointPool, error) {
+
+	if namespace == "" {
+		return nil, errors.New("namespace must not be empty")
+	}
+	if name == "" {
+		return nil, errors.New("name must not be empty")
+	}
+	if endpointSelector == "" {
+		return nil, errors.New("endpoint selector must not be empty")
+	}
+	if len(endpointTargetPorts) == 0 {
+		return nil, errors.New("endpoint target ports must not be empty")
+	}
+
+	selectorMap, err := labels.ConvertSelectorToLabelsMap(endpointSelector)
+	if err != nil {
+		return nil, fmt.Errorf("failed to parse endpoint selector %q: %w", endpointSelector, err)
+	}
+
+	pool := datalayer.NewEndpointPool(namespace, name)
+	pool.Selector = selectorMap
+	pool.TargetPorts = append(pool.TargetPorts, endpointTargetPorts...)
+
+	return pool, nil
+}

test/integration/epp/harness.go

@@ -180,12 +180,13 @@ func NewTestHarness(t *testing.T, ctx context.Context, opts ...HarnessOption) *T
 		// Disable CRD watching for Standalone mode.
 		runner.ControllerCfg = server.NewControllerConfig(false)
 
-		// Inject static Endpoint Pool.
-		// This replicates the manual pool construction that happens in runner.go CLI parsing.
-		// TODO(#2174): Refactor this to share logic with runner.go.
-		endpointPool := datalayer.NewEndpointPool(nsName, testPoolName)
-		endpointPool.Selector = map[string]string{"app": testPoolName}
-		endpointPool.TargetPorts = []int{epptestutil.DefaultTestPort}
+		endpointPool, err := server.NewEndpointPoolFromOptions(
+			nsName,
+			testPoolName,
+			"app="+testPoolName,
+			[]int{epptestutil.DefaultTestPort},
+		)
+		require.NoError(t, err)
 
 		runner.Datastore = datastore.NewDatastore(ctx, pmf, 0, datastore.WithEndpointPool(endpointPool))
 	} else {