[FSSDK-12275] Add experiment type filtering to skip unsupported types during flag decision

- Add Type field to Experiment struct in entities/experiment.go
- Define supportedExperimentTypes map with values: a/b, mab, cmab, feature_rollouts
- Update FeatureExperimentService.GetDecision to check experiment types
- Skip evaluation only if Type is non-empty but not in supported list
- Evaluate normally if Type is empty or is supported
- Add comprehensive unit tests covering all scenarios

Co-Authored-By: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: raju-opti

pkg/decision/feature_experiment_service.go

@@ -25,6 +25,14 @@ import (
 	"github.com/optimizely/go-sdk/v2/pkg/logging"
 )
 
+// supportedExperimentTypes defines the experiment types that the SDK can handle
+var supportedExperimentTypes = map[string]bool{
+	"a/b":              true,
+	"mab":              true,
+	"cmab":             true,
+	"feature_rollouts": true,
+}
+
 // FeatureExperimentService helps evaluate feature test associated with the feature
 type FeatureExperimentService struct {
 	compositeExperimentService ExperimentService
@@ -46,6 +54,18 @@ func (f FeatureExperimentService) GetDecision(decisionContext FeatureDecisionCon
 	// @TODO this can be improved by getting group ID first and determining experiment and then bucketing in experiment
 	for _, featureExperiment := range feature.FeatureExperiments {
 
+		// Check if experiment type is supported
+		if featureExperiment.Type != "" && !supportedExperimentTypes[featureExperiment.Type] {
+			message := fmt.Sprintf(
+				"Experiment %q has unsupported type %q. Skipping to next experiment.",
+				featureExperiment.Key,
+				featureExperiment.Type,
+			)
+			f.logger.Debug(message)
+			reasons.AddInfo(message)
+			continue
+		}
+
 		// Checking for forced decision
 		if decisionContext.ForcedDecisionService != nil {
 			forcedDecision, _reasons, err := decisionContext.ForcedDecisionService.FindValidatedForcedDecision(decisionContext.ProjectConfig, OptimizelyDecisionContext{FlagKey: feature.Key, RuleKey: featureExperiment.Key}, options)

pkg/decision/feature_experiment_service_test.go

@@ -295,6 +295,224 @@ func (s *FeatureExperimentServiceTestSuite) TestGetDecisionWithCmabError() {
 	s.mockExperimentService.AssertExpectations(s.T())
 }
 
+func (s *FeatureExperimentServiceTestSuite) TestGetDecisionSkipsUnsupportedExperimentType() {
+	testUserContext := entities.UserContext{
+		ID: "test_user_1",
+	}
+
+	// Create experiment with unsupported type
+	unsupportedExp := testExp1113
+	unsupportedExp.Type = "unsupported_type"
+
+	// Create feature with the unsupported experiment
+	featureWithUnsupportedExp := testFeat3335
+	featureWithUnsupportedExp.FeatureExperiments = []entities.Experiment{unsupportedExp}
+
+	testFeatureDecisionContext := FeatureDecisionContext{
+		Feature:       &featureWithUnsupportedExp,
+		ProjectConfig: s.mockConfig,
+	}
+
+	featureExperimentService := &FeatureExperimentService{
+		compositeExperimentService: s.mockExperimentService,
+		logger:                     logging.GetLogger("sdkKey", "FeatureExperimentService"),
+	}
+
+	decision, _, err := featureExperimentService.GetDecision(testFeatureDecisionContext, testUserContext, s.options)
+
+	// Should return empty decision since experiment was skipped
+	s.Equal(FeatureDecision{}, decision)
+	s.NoError(err)
+}
+
+func (s *FeatureExperimentServiceTestSuite) TestGetDecisionEvaluatesExperimentWithSupportedTypeAB() {
+	testUserContext := entities.UserContext{
+		ID: "test_user_1",
+	}
+
+	// Create experiment with supported type "a/b"
+	abExp := testExp1113
+	abExp.Type = "a/b"
+
+	expectedVariation := abExp.Variations["2223"]
+	returnExperimentDecision := ExperimentDecision{
+		Variation: &expectedVariation,
+	}
+	testExperimentDecisionContext := ExperimentDecisionContext{
+		Experiment:    &abExp,
+		ProjectConfig: s.mockConfig,
+	}
+	s.mockExperimentService.On("GetDecision", testExperimentDecisionContext, testUserContext, s.options).Return(returnExperimentDecision, s.reasons, nil)
+
+	// Create feature with the a/b experiment
+	featureWithABExp := testFeat3335
+	featureWithABExp.FeatureExperiments = []entities.Experiment{abExp}
+
+	testFeatureDecisionContext := FeatureDecisionContext{
+		Feature:       &featureWithABExp,
+		ProjectConfig: s.mockConfig,
+	}
+
+	featureExperimentService := &FeatureExperimentService{
+		compositeExperimentService: s.mockExperimentService,
+		logger:                     logging.GetLogger("sdkKey", "FeatureExperimentService"),
+	}
+
+	expectedFeatureDecision := FeatureDecision{
+		Experiment: *testExperimentDecisionContext.Experiment,
+		Variation:  &expectedVariation,
+		Source:     FeatureTest,
+	}
+
+	decision, _, err := featureExperimentService.GetDecision(testFeatureDecisionContext, testUserContext, s.options)
+	s.Equal(expectedFeatureDecision, decision)
+	s.NoError(err)
+	s.mockExperimentService.AssertExpectations(s.T())
+}
+
+func (s *FeatureExperimentServiceTestSuite) TestGetDecisionEvaluatesExperimentWithSupportedTypeMAB() {
+	testUserContext := entities.UserContext{
+		ID: "test_user_1",
+	}
+
+	// Create experiment with supported type "mab"
+	mabExp := testExp1113
+	mabExp.Type = "mab"
+
+	expectedVariation := mabExp.Variations["2223"]
+	returnExperimentDecision := ExperimentDecision{
+		Variation: &expectedVariation,
+	}
+	testExperimentDecisionContext := ExperimentDecisionContext{
+		Experiment:    &mabExp,
+		ProjectConfig: s.mockConfig,
+	}
+	s.mockExperimentService.On("GetDecision", testExperimentDecisionContext, testUserContext, s.options).Return(returnExperimentDecision, s.reasons, nil)
+
+	// Create feature with the mab experiment
+	featureWithMABExp := testFeat3335
+	featureWithMABExp.FeatureExperiments = []entities.Experiment{mabExp}
+
+	testFeatureDecisionContext := FeatureDecisionContext{
+		Feature:       &featureWithMABExp,
+		ProjectConfig: s.mockConfig,
+	}
+
+	featureExperimentService := &FeatureExperimentService{
+		compositeExperimentService: s.mockExperimentService,
+		logger:                     logging.GetLogger("sdkKey", "FeatureExperimentService"),
+	}
+
+	expectedFeatureDecision := FeatureDecision{
+		Experiment: *testExperimentDecisionContext.Experiment,
+		Variation:  &expectedVariation,
+		Source:     FeatureTest,
+	}
+
+	decision, _, err := featureExperimentService.GetDecision(testFeatureDecisionContext, testUserContext, s.options)
+	s.Equal(expectedFeatureDecision, decision)
+	s.NoError(err)
+	s.mockExperimentService.AssertExpectations(s.T())
+}
+
+func (s *FeatureExperimentServiceTestSuite) TestGetDecisionEvaluatesExperimentWithEmptyType() {
+	testUserContext := entities.UserContext{
+		ID: "test_user_1",
+	}
+
+	// Create experiment with empty type (backward compatible)
+	emptyTypeExp := testExp1113
+	emptyTypeExp.Type = ""
+
+	expectedVariation := emptyTypeExp.Variations["2223"]
+	returnExperimentDecision := ExperimentDecision{
+		Variation: &expectedVariation,
+	}
+	testExperimentDecisionContext := ExperimentDecisionContext{
+		Experiment:    &emptyTypeExp,
+		ProjectConfig: s.mockConfig,
+	}
+	s.mockExperimentService.On("GetDecision", testExperimentDecisionContext, testUserContext, s.options).Return(returnExperimentDecision, s.reasons, nil)
+
+	// Create feature with the empty type experiment
+	featureWithEmptyTypeExp := testFeat3335
+	featureWithEmptyTypeExp.FeatureExperiments = []entities.Experiment{emptyTypeExp}
+
+	testFeatureDecisionContext := FeatureDecisionContext{
+		Feature:       &featureWithEmptyTypeExp,
+		ProjectConfig: s.mockConfig,
+	}
+
+	featureExperimentService := &FeatureExperimentService{
+		compositeExperimentService: s.mockExperimentService,
+		logger:                     logging.GetLogger("sdkKey", "FeatureExperimentService"),
+	}
+
+	expectedFeatureDecision := FeatureDecision{
+		Experiment: *testExperimentDecisionContext.Experiment,
+		Variation:  &expectedVariation,
+		Source:     FeatureTest,
+	}
+
+	decision, _, err := featureExperimentService.GetDecision(testFeatureDecisionContext, testUserContext, s.options)
+	s.Equal(expectedFeatureDecision, decision)
+	s.NoError(err)
+	s.mockExperimentService.AssertExpectations(s.T())
+}
+
+func (s *FeatureExperimentServiceTestSuite) TestGetDecisionSkipsUnsupportedAndEvaluatesSupported() {
+	testUserContext := entities.UserContext{
+		ID: "test_user_1",
+	}
+
+	// Create unsupported experiment
+	unsupportedExp := testExp1113
+	unsupportedExp.Type = "unsupported_type"
+	unsupportedExp.Key = "unsupported_exp"
+
+	// Create supported experiment
+	supportedExp := testExp1113
+	supportedExp.Type = "a/b"
+	supportedExp.Key = "supported_exp"
+
+	expectedVariation := supportedExp.Variations["2223"]
+	returnExperimentDecision := ExperimentDecision{
+		Variation: &expectedVariation,
+	}
+	testExperimentDecisionContext := ExperimentDecisionContext{
+		Experiment:    &supportedExp,
+		ProjectConfig: s.mockConfig,
+	}
+	s.mockExperimentService.On("GetDecision", testExperimentDecisionContext, testUserContext, s.options).Return(returnExperimentDecision, s.reasons, nil)
+
+	// Create feature with both experiments
+	featureWithBothExp := testFeat3335
+	featureWithBothExp.FeatureExperiments = []entities.Experiment{unsupportedExp, supportedExp}
+
+	testFeatureDecisionContext := FeatureDecisionContext{
+		Feature:       &featureWithBothExp,
+		ProjectConfig: s.mockConfig,
+	}
+
+	featureExperimentService := &FeatureExperimentService{
+		compositeExperimentService: s.mockExperimentService,
+		logger:                     logging.GetLogger("sdkKey", "FeatureExperimentService"),
+	}
+
+	expectedFeatureDecision := FeatureDecision{
+		Experiment: *testExperimentDecisionContext.Experiment,
+		Variation:  &expectedVariation,
+		Source:     FeatureTest,
+	}
+
+	decision, _, err := featureExperimentService.GetDecision(testFeatureDecisionContext, testUserContext, s.options)
+
+	// Should skip unsupported and evaluate supported
+	s.Equal(expectedFeatureDecision, decision)
+	s.NoError(err)
+	s.mockExperimentService.AssertExpectations(s.T())
+}
+
 func TestFeatureExperimentServiceTestSuite(t *testing.T) {
 	suite.Run(t, new(FeatureExperimentServiceTestSuite))
 }

pkg/entities/experiment.go

@@ -45,6 +45,7 @@ type Experiment struct {
 	AudienceConditionTree *TreeNode
 	Whitelist             map[string]string
 	IsFeatureExperiment   bool
+	Type                  string
 	Cmab                  *Cmab
 }