Adds ability to pass a context.Context to provider with new public methods.

Author: leoromanovsky

openfeature/context_aware_test.go

@@ -0,0 +1,210 @@
+package openfeature
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+// testContextAwareProvider is a test provider that implements ContextAwareStateHandler
+type testContextAwareProvider struct {
+	initDelay time.Duration
+}
+
+func (p *testContextAwareProvider) Metadata() Metadata {
+	return Metadata{Name: "test-context-aware-provider"}
+}
+
+// InitWithContext implements ContextAwareStateHandler
+func (p *testContextAwareProvider) InitWithContext(ctx context.Context, evalCtx EvaluationContext) error {
+	select {
+	case <-time.After(p.initDelay):
+		return nil
+	case <-ctx.Done():
+		return ctx.Err()
+	}
+}
+
+// Init implements StateHandler for backward compatibility
+func (p *testContextAwareProvider) Init(evalCtx EvaluationContext) error {
+	return p.InitWithContext(context.Background(), evalCtx)
+}
+
+func (p *testContextAwareProvider) Shutdown() {}
+
+func (p *testContextAwareProvider) BooleanEvaluation(ctx context.Context, flag string, defaultValue bool, flatCtx FlattenedContext) BoolResolutionDetail {
+	return BoolResolutionDetail{
+		Value:                    defaultValue,
+		ProviderResolutionDetail: ProviderResolutionDetail{Reason: DefaultReason},
+	}
+}
+
+func (p *testContextAwareProvider) StringEvaluation(ctx context.Context, flag string, defaultValue string, flatCtx FlattenedContext) StringResolutionDetail {
+	return StringResolutionDetail{
+		Value:                    defaultValue,
+		ProviderResolutionDetail: ProviderResolutionDetail{Reason: DefaultReason},
+	}
+}
+
+func (p *testContextAwareProvider) FloatEvaluation(ctx context.Context, flag string, defaultValue float64, flatCtx FlattenedContext) FloatResolutionDetail {
+	return FloatResolutionDetail{
+		Value:                    defaultValue,
+		ProviderResolutionDetail: ProviderResolutionDetail{Reason: DefaultReason},
+	}
+}
+
+func (p *testContextAwareProvider) IntEvaluation(ctx context.Context, flag string, defaultValue int64, flatCtx FlattenedContext) IntResolutionDetail {
+	return IntResolutionDetail{
+		Value:                    defaultValue,
+		ProviderResolutionDetail: ProviderResolutionDetail{Reason: DefaultReason},
+	}
+}
+
+func (p *testContextAwareProvider) ObjectEvaluation(ctx context.Context, flag string, defaultValue any, flatCtx FlattenedContext) InterfaceResolutionDetail {
+	return InterfaceResolutionDetail{
+		Value:                    defaultValue,
+		ProviderResolutionDetail: ProviderResolutionDetail{Reason: DefaultReason},
+	}
+}
+
+func (p *testContextAwareProvider) Hooks() []Hook {
+	return []Hook{}
+}
+
+func TestContextAwareInitialization(t *testing.T) {
+	// Save original state
+	originalAPI := api
+	originalEventing := eventing
+	defer func() {
+		api = originalAPI
+		eventing = originalEventing
+	}()
+
+	// Create fresh API for isolated testing
+	exec := newEventExecutor()
+	testAPI := newEvaluationAPI(exec)
+	api = testAPI
+	eventing = exec
+
+	t.Run("fast provider succeeds within timeout", func(t *testing.T) {
+		fastProvider := &testContextAwareProvider{initDelay: 10 * time.Millisecond}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+		defer cancel()
+
+		err := SetProviderWithContextAndWait(ctx, fastProvider)
+		if err != nil {
+			t.Errorf("Expected fast provider to succeed, got error: %v", err)
+		}
+	})
+
+	t.Run("slow provider times out", func(t *testing.T) {
+		slowProvider := &testContextAwareProvider{initDelay: 200 * time.Millisecond}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+		defer cancel()
+
+		err := SetProviderWithContextAndWait(ctx, slowProvider)
+		if err == nil {
+			t.Error("Expected timeout error but got success")
+		}
+		if err != context.DeadlineExceeded {
+			t.Errorf("Expected context deadline exceeded, got: %v", err)
+		}
+	})
+
+	t.Run("async initialization returns immediately", func(t *testing.T) {
+		asyncProvider := &testContextAwareProvider{initDelay: 50 * time.Millisecond}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 200*time.Millisecond)
+		defer cancel()
+
+		start := time.Now()
+		err := SetProviderWithContext(ctx, asyncProvider)
+		elapsed := time.Since(start)
+
+		if err != nil {
+			t.Errorf("Async setup should not fail: %v", err)
+		}
+		if elapsed > 25*time.Millisecond {
+			t.Errorf("Async setup took too long: %v", elapsed)
+		}
+	})
+
+	t.Run("named provider with context works", func(t *testing.T) {
+		namedProvider := &testContextAwareProvider{initDelay: 10 * time.Millisecond}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+		defer cancel()
+
+		err := SetNamedProviderWithContextAndWait(ctx, "test-domain", namedProvider)
+		if err != nil {
+			t.Errorf("Named provider should succeed: %v", err)
+		}
+	})
+
+	t.Run("backward compatibility with regular provider", func(t *testing.T) {
+		legacyProvider := &NoopProvider{}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 100*time.Millisecond)
+		defer cancel()
+
+		err := SetProviderWithContextAndWait(ctx, legacyProvider)
+		if err != nil {
+			t.Errorf("Legacy provider should work: %v", err)
+		}
+	})
+}
+
+func TestContextAwareStateHandlerDetection(t *testing.T) {
+	// Test that the initializerWithContext function correctly detects ContextAwareStateHandler
+	evalCtx := EvaluationContext{}
+
+	t.Run("detects ContextAwareStateHandler", func(t *testing.T) {
+		provider := &testContextAwareProvider{initDelay: 1 * time.Millisecond}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+		defer cancel()
+
+		event, err := initializerWithContext(ctx, provider, evalCtx)
+		if err != nil {
+			t.Errorf("Context-aware provider should initialize successfully: %v", err)
+		}
+		if event.EventType != ProviderReady {
+			t.Errorf("Expected ProviderReady event, got: %v", event.EventType)
+		}
+	})
+
+	t.Run("falls back to regular StateHandler", func(t *testing.T) {
+		provider := &NoopProvider{}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond)
+		defer cancel()
+
+		event, err := initializerWithContext(ctx, provider, evalCtx)
+		if err != nil {
+			t.Errorf("Regular provider should initialize successfully: %v", err)
+		}
+		if event.EventType != ProviderReady {
+			t.Errorf("Expected ProviderReady event, got: %v", event.EventType)
+		}
+	})
+
+	t.Run("handles timeout in context-aware provider", func(t *testing.T) {
+		provider := &testContextAwareProvider{initDelay: 100 * time.Millisecond}
+
+		ctx, cancel := context.WithTimeout(context.Background(), 10*time.Millisecond)
+		defer cancel()
+
+		event, err := initializerWithContext(ctx, provider, evalCtx)
+		if err == nil {
+			t.Error("Expected timeout error")
+		}
+		if err != context.DeadlineExceeded {
+			t.Errorf("Expected deadline exceeded, got: %v", err)
+		}
+		if event.EventType != ProviderError {
+			t.Errorf("Expected ProviderError event, got: %v", event.EventType)
+		}
+	})
+}

openfeature/interfaces.go

@@ -67,6 +67,11 @@ type evaluationImpl interface {
 	SetLogger(l logr.Logger)
 
 	ForEvaluation(clientName string) (FeatureProvider, []Hook, EvaluationContext)
+
+	// Context-aware provider setup methods
+	SetProviderWithContext(ctx context.Context, provider FeatureProvider) error
+	SetProviderWithContextAndWait(ctx context.Context, provider FeatureProvider) error
+	SetNamedProviderWithContext(ctx context.Context, clientName string, provider FeatureProvider, async bool) error
 }
 
 // eventingImpl is an internal reference interface extending IEventing

openfeature/interfaces_mock.go

@@ -1,6 +1,9 @@
 package openfeature
 
-import "github.com/go-logr/logr"
+import (
+	"context"
+	"github.com/go-logr/logr"
+)
 
 // api is the global evaluationImpl implementation. This is a singleton and there can only be one instance.
 var (
@@ -47,6 +50,21 @@ func SetProviderAndWait(provider FeatureProvider) error {
 	return api.SetProviderAndWait(provider)
 }
 
+// SetProviderWithContext sets the default [FeatureProvider] with context-aware initialization.
+// If the provider implements ContextAwareStateHandler, InitWithContext will be called with the provided context.
+// Provider initialization is asynchronous and status can be checked from provider status.
+// Returns an error immediately if provider is nil, or if context is cancelled during setup.
+func SetProviderWithContext(ctx context.Context, provider FeatureProvider) error {
+	return api.SetProviderWithContext(ctx, provider)
+}
+
+// SetProviderWithContextAndWait sets the default [FeatureProvider] with context-aware initialization and waits for completion.
+// If the provider implements ContextAwareStateHandler, InitWithContext will be called with the provided context.
+// Returns an error if initialization causes an error, or if context is cancelled during initialization.
+func SetProviderWithContextAndWait(ctx context.Context, provider FeatureProvider) error {
+	return api.SetProviderWithContextAndWait(ctx, provider)
+}
+
 // ProviderMetadata returns the default [FeatureProvider] metadata
 func ProviderMetadata() Metadata {
 	return api.GetProviderMetadata()
@@ -64,6 +82,21 @@ func SetNamedProviderAndWait(domain string, provider FeatureProvider) error {
 	return api.SetNamedProvider(domain, provider, false)
 }
 
+// SetNamedProviderWithContext sets a [FeatureProvider] mapped to the given [Client] domain with context-aware initialization.
+// If the provider implements ContextAwareStateHandler, InitWithContext will be called with the provided context.
+// Provider initialization is asynchronous and status can be checked from provider status.
+// Returns an error immediately if provider is nil, or if context is cancelled during setup.
+func SetNamedProviderWithContext(ctx context.Context, domain string, provider FeatureProvider) error {
+	return api.SetNamedProviderWithContext(ctx, domain, provider, true)
+}
+
+// SetNamedProviderWithContextAndWait sets a provider mapped to the given [Client] domain with context-aware initialization and waits for completion.
+// If the provider implements ContextAwareStateHandler, InitWithContext will be called with the provided context.
+// Returns an error if initialization causes an error, or if context is cancelled during initialization.
+func SetNamedProviderWithContextAndWait(ctx context.Context, domain string, provider FeatureProvider) error {
+	return api.SetNamedProviderWithContext(ctx, domain, provider, false)
+}
+
 // NamedProviderMetadata returns the named provider's Metadata
 func NamedProviderMetadata(name string) Metadata {
 	return api.GetNamedProviderMetadata(name)