Add client reset functionality for FSC CMAB test isolation

Author: Mat001

pkg/handlers/reset.go

@@ -0,0 +1,61 @@
+/****************************************************************************
+ * Copyright 2025, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+// Package handlers //
+package handlers
+
+import (
+	"errors"
+	"net/http"
+
+	"github.com/go-chi/render"
+
+	"github.com/optimizely/agent/pkg/middleware"
+)
+
+// ResetClient handles the /v1/reset endpoint from FSC tests
+// This clears the client cache to ensure clean state between test scenarios,
+// particularly important for CMAB cache testing
+func ResetClient(w http.ResponseWriter, r *http.Request) {
+	// Get SDK key from header
+	sdkKey := r.Header.Get("X-Optimizely-SDK-Key")
+	if sdkKey == "" {
+		RenderError(errors.New("SDK key required for reset"), http.StatusBadRequest, w, r)
+		return
+	}
+
+	// Get the cache from context
+	cache, err := middleware.GetOptlyCache(r)
+	if err != nil {
+		RenderError(errors.New("cache not available"), http.StatusInternalServerError, w, r)
+		return
+	}
+
+	// Get logger for debugging
+	logger := middleware.GetLogger(r)
+	logger.Debug().Str("sdkKey", sdkKey).Msg("Resetting client for FSC test")
+
+	// Reset the client using the cache interface
+	if optlyCache, ok := cache.(interface{ ResetClient(string) }); ok {
+		optlyCache.ResetClient(sdkKey)
+	} else {
+		RenderError(errors.New("cache reset not supported"), http.StatusInternalServerError, w, r)
+		return
+	}
+
+	// Return success
+	render.JSON(w, r, map[string]interface{}{"result": true})
+}

pkg/handlers/reset_test.go

@@ -0,0 +1,140 @@
+/****************************************************************************
+ * Copyright 2025, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+
+// Package handlers //
+package handlers
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/optimizely/agent/pkg/middleware"
+	"github.com/optimizely/agent/pkg/optimizely"
+	"github.com/optimizely/agent/pkg/optimizely/optimizelytest"
+
+	"github.com/go-chi/chi/v5"
+	"github.com/stretchr/testify/mock"
+	"github.com/stretchr/testify/suite"
+)
+
+type MockCache struct {
+	mock.Mock
+}
+
+func (m *MockCache) GetClient(key string) (*optimizely.OptlyClient, error) {
+	args := m.Called(key)
+	return args.Get(0).(*optimizely.OptlyClient), args.Error(1)
+}
+
+func (m *MockCache) UpdateConfigs(_ string) {
+}
+
+func (m *MockCache) SetUserProfileService(sdkKey, userProfileService string) {
+	m.Called(sdkKey, userProfileService)
+}
+
+func (m *MockCache) SetODPCache(sdkKey, odpCache string) {
+	m.Called(sdkKey, odpCache)
+}
+
+func (m *MockCache) ResetClient(sdkKey string) {
+	m.Called(sdkKey)
+}
+
+type ResetTestSuite struct {
+	suite.Suite
+	oc    *optimizely.OptlyClient
+	tc    *optimizelytest.TestClient
+	mux   *chi.Mux
+	cache *MockCache
+}
+
+func (suite *ResetTestSuite) ClientCtx(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		ctx := context.WithValue(r.Context(), middleware.OptlyClientKey, suite.oc)
+		ctx = context.WithValue(ctx, middleware.OptlyCacheKey, suite.cache)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
+
+func (suite *ResetTestSuite) SetupTest() {
+	testClient := optimizelytest.NewClient()
+	suite.tc = testClient
+	suite.oc = &optimizely.OptlyClient{OptimizelyClient: testClient.OptimizelyClient}
+	
+	mockCache := new(MockCache)
+	mockCache.On("ResetClient", "test-sdk-key").Return()
+	suite.cache = mockCache
+
+	mux := chi.NewMux()
+	mux.Use(suite.ClientCtx)
+	mux.Post("/reset", ResetClient)
+	suite.mux = mux
+}
+
+func (suite *ResetTestSuite) TestResetClient() {
+	req := httptest.NewRequest("POST", "/reset", nil)
+	req.Header.Set("X-Optimizely-SDK-Key", "test-sdk-key")
+	recorder := httptest.NewRecorder()
+
+	suite.mux.ServeHTTP(recorder, req)
+
+	suite.Equal(http.StatusOK, recorder.Code)
+	suite.Contains(recorder.Header().Get("content-type"), "application/json")
+	suite.Contains(recorder.Body.String(), `"result":true`)
+	
+	// Verify ResetClient was called with correct SDK key
+	suite.cache.AssertCalled(suite.T(), "ResetClient", "test-sdk-key")
+}
+
+func (suite *ResetTestSuite) TestResetClientMissingSDKKey() {
+	req := httptest.NewRequest("POST", "/reset", nil)
+	recorder := httptest.NewRecorder()
+
+	suite.mux.ServeHTTP(recorder, req)
+
+	suite.Equal(http.StatusBadRequest, recorder.Code)
+	suite.Contains(recorder.Body.String(), "SDK key required for reset")
+}
+
+func (suite *ResetTestSuite) TestResetClientCacheNotAvailable() {
+	// Create a context without cache
+	req := httptest.NewRequest("POST", "/reset", nil)
+	req.Header.Set("X-Optimizely-SDK-Key", "test-sdk-key")
+	recorder := httptest.NewRecorder()
+
+	// Use middleware that doesn't include cache
+	mux := chi.NewMux()
+	mux.Use(func(next http.Handler) http.Handler {
+		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+			ctx := context.WithValue(r.Context(), middleware.OptlyClientKey, suite.oc)
+			// Note: no cache in context
+			next.ServeHTTP(w, r.WithContext(ctx))
+		})
+	})
+	mux.Post("/reset", ResetClient)
+
+	mux.ServeHTTP(recorder, req)
+
+	suite.Equal(http.StatusInternalServerError, recorder.Code)
+	suite.Contains(recorder.Body.String(), "cache not available")
+}
+
+func TestResetTestSuite(t *testing.T) {
+	suite.Run(t, new(ResetTestSuite))
+}

pkg/middleware/cached.go

@@ -41,6 +41,9 @@ const OptlyFeatureKey = contextKey("featureKey")
 // OptlyExperimentKey is the context key used by ExperimentCtx for setting an Experiment
 const OptlyExperimentKey = contextKey("experimentKey")
 
+// OptlyCacheKey is the context key for the OptlyCache
+const OptlyCacheKey = contextKey("optlyCache")
+
 // OptlySDKHeader is the header key for an ad-hoc SDK key
 const OptlySDKHeader = "X-Optimizely-SDK-Key"
 
@@ -98,6 +101,7 @@ func (mw *CachedOptlyMiddleware) ClientCtx(next http.Handler) http.Handler {
 		}
 
 		ctx := context.WithValue(r.Context(), OptlyClientKey, optlyClient)
+		ctx = context.WithValue(ctx, OptlyCacheKey, mw.Cache)
 		next.ServeHTTP(w, r.WithContext(ctx))
 	})
 }

pkg/middleware/utils.go

@@ -47,6 +47,16 @@ func GetOptlyClient(r *http.Request) (*optimizely.OptlyClient, error) {
 	return optlyClient, nil
 }
 
+// GetOptlyCache is a utility to extract the OptlyCache from the http request context.
+func GetOptlyCache(r *http.Request) (optimizely.Cache, error) {
+	cache, ok := r.Context().Value(OptlyCacheKey).(optimizely.Cache)
+	if !ok || cache == nil {
+		return nil, fmt.Errorf("optlyCache not available")
+	}
+
+	return cache, nil
+}
+
 // GetLogger gets the logger with some info coming from http request
 func GetLogger(r *http.Request) *zerolog.Logger {
 	reqID := r.Header.Get(OptlyRequestHeader)

pkg/optimizely/cache.go

@@ -432,3 +432,24 @@ func getServiceWithType(serviceType, sdkKey string, serviceMap cmap.ConcurrentMa
 	}
 	return nil
 }
+
+// ResetClient removes the optimizely client from cache to ensure clean state for testing
+// This is primarily used by FSC tests to clear CMAB cache between test scenarios
+func (c *OptlyCache) ResetClient(sdkKey string) {
+	// Remove the client from the cache
+	if val, exists := c.optlyMap.Get(sdkKey); exists {
+		c.optlyMap.Remove(sdkKey)
+		
+		// Close the client to clean up resources
+		if client, ok := val.(*OptlyClient); ok {
+			client.Close()
+		}
+		
+		message := "Reset Optimizely client for testing"
+		if ShouldIncludeSDKKey {
+			log.Info().Str("sdkKey", sdkKey).Msg(message)
+		} else {
+			log.Info().Msg(message)
+		}
+	}
+}

pkg/optimizely/cache_test.go

@@ -310,6 +310,33 @@ func (suite *CacheTestSuite) TestNilCreatorAddedforODPCache() {
 	suite.Nil(odpCache)
 }
 
+func (suite *CacheTestSuite) TestResetClient() {
+	// First, get a client to put it in the cache
+	client, err := suite.cache.GetClient("test-sdk-key")
+	suite.NoError(err)
+	suite.NotNil(client)
+	
+	// Verify client is in cache
+	cachedClient, exists := suite.cache.optlyMap.Get("test-sdk-key")
+	suite.True(exists)
+	suite.NotNil(cachedClient)
+	
+	// Reset the client
+	suite.cache.ResetClient("test-sdk-key")
+	
+	// Verify client is removed from cache
+	_, exists = suite.cache.optlyMap.Get("test-sdk-key")
+	suite.False(exists)
+}
+
+func (suite *CacheTestSuite) TestResetClientNonExistent() {
+	// Reset a client that doesn't exist - should not panic
+	suite.cache.ResetClient("non-existent-key")
+	
+	// Verify no clients are in cache
+	suite.Equal(0, suite.cache.optlyMap.Count())
+}
+
 // In order for 'go test' to run this suite, we need to create
 // a normal test function and pass our suite to suite.Run
 func TestCacheTestSuite(t *testing.T) {

pkg/routers/api.go

@@ -49,6 +49,7 @@ type APIOptions struct {
 	overrideHandler     http.HandlerFunc
 	lookupHandler       http.HandlerFunc
 	saveHandler         http.HandlerFunc
+	resetHandler        http.HandlerFunc
 	sendOdpEventHandler http.HandlerFunc
 	nStreamHandler      http.HandlerFunc
 	oAuthHandler        http.HandlerFunc
@@ -80,6 +81,7 @@ func NewDefaultAPIRouter(optlyCache optimizely.Cache, conf config.AgentConfig, m
 	if !conf.API.EnableOverrides {
 		overrideHandler = forbiddenHandler("Overrides not enabled")
 	}
+	resetHandler := handlers.ResetClient
 
 	nStreamHandler := forbiddenHandler("Notification stream not enabled")
 	if conf.API.EnableNotifications {
@@ -102,6 +104,7 @@ func NewDefaultAPIRouter(optlyCache optimizely.Cache, conf config.AgentConfig, m
 		overrideHandler:     overrideHandler,
 		lookupHandler:       handlers.Lookup,
 		saveHandler:         handlers.Save,
+		resetHandler:        resetHandler,
 		trackHandler:        handlers.TrackEvent,
 		sendOdpEventHandler: handlers.SendOdpEvent,
 		sdkMiddleware:       mw.ClientCtx,
@@ -131,6 +134,7 @@ func WithAPIRouter(opt *APIOptions, r chi.Router) {
 	overrideTimer := middleware.Metricize("override", opt.metricsRegistry)
 	lookupTimer := middleware.Metricize("lookup", opt.metricsRegistry)
 	saveTimer := middleware.Metricize("save", opt.metricsRegistry)
+	resetTimer := middleware.Metricize("reset", opt.metricsRegistry)
 	trackTimer := middleware.Metricize("track-event", opt.metricsRegistry)
 	sendOdpEventTimer := middleware.Metricize("send-odp-event", opt.metricsRegistry)
 	createAccesstokenTimer := middleware.Metricize("create-api-access-token", opt.metricsRegistry)
@@ -144,6 +148,7 @@ func WithAPIRouter(opt *APIOptions, r chi.Router) {
 	overrideTracer := middleware.AddTracing("overrideHandler", "Override")
 	lookupTracer := middleware.AddTracing("lookupHandler", "Lookup")
 	saveTracer := middleware.AddTracing("saveHandler", "Save")
+	resetTracer := middleware.AddTracing("resetHandler", "Reset")
 	sendOdpEventTracer := middleware.AddTracing("sendOdpEventHandler", "SendOdpEvent")
 	nStreamTracer := middleware.AddTracing("notificationHandler", "SendNotificationEvent")
 	authTracer := middleware.AddTracing("authHandler", "AuthToken")
@@ -164,6 +169,7 @@ func WithAPIRouter(opt *APIOptions, r chi.Router) {
 		r.With(decideTimer, opt.oAuthMiddleware, contentTypeMiddleware, decideTracer).Post("/decide", opt.decideHandler)
 		r.With(trackTimer, opt.oAuthMiddleware, contentTypeMiddleware, trackTracer).Post("/track", opt.trackHandler)
 		r.With(overrideTimer, opt.oAuthMiddleware, contentTypeMiddleware, overrideTracer).Post("/override", opt.overrideHandler)
+		r.With(resetTimer, opt.oAuthMiddleware, contentTypeMiddleware, resetTracer).Post("/reset", opt.resetHandler)
 		r.With(lookupTimer, opt.oAuthMiddleware, contentTypeMiddleware, lookupTracer).Post("/lookup", opt.lookupHandler)
 		r.With(saveTimer, opt.oAuthMiddleware, contentTypeMiddleware, saveTracer).Post("/save", opt.saveHandler)
 		r.With(sendOdpEventTimer, opt.oAuthMiddleware, contentTypeMiddleware, sendOdpEventTracer).Post("/send-odp-event", opt.sendOdpEventHandler)