test: Add comprehensive tests for holdout implementation and fix linting

- Added 3 unit tests for GetHoldoutsForFlag() in config_test.go
- Created holdout_test.go with 7 comprehensive mapper tests:
  - Empty holdouts
  - Global holdouts with exclusions
  - Specific holdouts with inclusions
  - Non-running holdouts filtering
  - Mixed global and specific holdouts
  - Audience conditions mapping
  - Variations and traffic allocation mapping
- Fixed govet shadow linting error in holdout_service.go line 105

All tests passing. Improves code coverage for new holdout functionality.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: Mat001

pkg/config/datafileprojectconfig/config_test.go

@@ -728,3 +728,64 @@ func TestGetAttributeByKeyWithDirectMapping(t *testing.T) {
 	assert.Nil(t, err)
 	assert.Equal(t, attribute, actual)
 }
+
+func TestGetHoldoutsForFlagWithHoldouts(t *testing.T) {
+	flagKey := "test_flag"
+	holdout1 := entities.Holdout{
+		ID:     "holdout_1",
+		Key:    "test_holdout_1",
+		Status: entities.HoldoutStatusRunning,
+	}
+	holdout2 := entities.Holdout{
+		ID:     "holdout_2",
+		Key:    "test_holdout_2",
+		Status: entities.HoldoutStatusRunning,
+	}
+
+	flagHoldoutsMap := make(map[string][]entities.Holdout)
+	flagHoldoutsMap[flagKey] = []entities.Holdout{holdout1, holdout2}
+
+	config := &DatafileProjectConfig{
+		flagHoldoutsMap: flagHoldoutsMap,
+	}
+
+	actual := config.GetHoldoutsForFlag(flagKey)
+	assert.Len(t, actual, 2)
+	assert.Equal(t, holdout1, actual[0])
+	assert.Equal(t, holdout2, actual[1])
+}
+
+func TestGetHoldoutsForFlagWithNoHoldouts(t *testing.T) {
+	flagKey := "test_flag"
+	flagHoldoutsMap := make(map[string][]entities.Holdout)
+
+	config := &DatafileProjectConfig{
+		flagHoldoutsMap: flagHoldoutsMap,
+	}
+
+	actual := config.GetHoldoutsForFlag(flagKey)
+	assert.Len(t, actual, 0)
+	assert.Equal(t, []entities.Holdout{}, actual)
+}
+
+func TestGetHoldoutsForFlagWithDifferentFlag(t *testing.T) {
+	flagKey := "test_flag"
+	otherFlagKey := "other_flag"
+	holdout := entities.Holdout{
+		ID:     "holdout_1",
+		Key:    "test_holdout_1",
+		Status: entities.HoldoutStatusRunning,
+	}
+
+	flagHoldoutsMap := make(map[string][]entities.Holdout)
+	flagHoldoutsMap[otherFlagKey] = []entities.Holdout{holdout}
+
+	config := &DatafileProjectConfig{
+		flagHoldoutsMap: flagHoldoutsMap,
+	}
+
+	// Request different flag - should return empty
+	actual := config.GetHoldoutsForFlag(flagKey)
+	assert.Len(t, actual, 0)
+	assert.Equal(t, []entities.Holdout{}, actual)
+}

pkg/config/datafileprojectconfig/mappers/holdout_test.go

@@ -0,0 +1,267 @@
+/****************************************************************************
+ * 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 mappers
+
+import (
+	"testing"
+
+	datafileEntities "github.com/optimizely/go-sdk/v2/pkg/config/datafileprojectconfig/entities"
+	"github.com/optimizely/go-sdk/v2/pkg/entities"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestMapHoldoutsEmpty(t *testing.T) {
+	rawHoldouts := []datafileEntities.Holdout{}
+	featureMap := map[string]entities.Feature{}
+
+	holdoutList, holdoutIDMap, flagHoldoutsMap := MapHoldouts(rawHoldouts, featureMap)
+
+	assert.Empty(t, holdoutList)
+	assert.Empty(t, holdoutIDMap)
+	assert.Empty(t, flagHoldoutsMap)
+}
+
+func TestMapHoldoutsGlobalHoldout(t *testing.T) {
+	// Global holdout: no includedFlags, applies to all flags except excluded
+	rawHoldouts := []datafileEntities.Holdout{
+		{
+			ID:            "holdout_1",
+			Key:           "global_holdout",
+			Status:        "Running",
+			ExcludedFlags: []string{"feature_2"},
+			Variations: []datafileEntities.Variation{
+				{ID: "var_1", Key: "variation_1"},
+			},
+			TrafficAllocation: []datafileEntities.TrafficAllocation{
+				{EntityID: "var_1", EndOfRange: 10000},
+			},
+		},
+	}
+
+	featureMap := map[string]entities.Feature{
+		"feature_1": {ID: "feature_1", Key: "feature_1"},
+		"feature_2": {ID: "feature_2", Key: "feature_2"},
+		"feature_3": {ID: "feature_3", Key: "feature_3"},
+	}
+
+	holdoutList, holdoutIDMap, flagHoldoutsMap := MapHoldouts(rawHoldouts, featureMap)
+
+	// Verify holdout list and ID map
+	assert.Len(t, holdoutList, 1)
+	assert.Len(t, holdoutIDMap, 1)
+	assert.Equal(t, "holdout_1", holdoutList[0].ID)
+	assert.Equal(t, "global_holdout", holdoutList[0].Key)
+
+	// Global holdout should apply to feature_1 and feature_3, but NOT feature_2 (excluded)
+	assert.Contains(t, flagHoldoutsMap, "feature_1")
+	assert.NotContains(t, flagHoldoutsMap, "feature_2")
+	assert.Contains(t, flagHoldoutsMap, "feature_3")
+
+	assert.Len(t, flagHoldoutsMap["feature_1"], 1)
+	assert.Len(t, flagHoldoutsMap["feature_3"], 1)
+}
+
+func TestMapHoldoutsSpecificHoldout(t *testing.T) {
+	// Specific holdout: has includedFlags, only applies to those flags
+	rawHoldouts := []datafileEntities.Holdout{
+		{
+			ID:            "holdout_1",
+			Key:           "specific_holdout",
+			Status:        "Running",
+			IncludedFlags: []string{"feature_1", "feature_2"},
+			Variations: []datafileEntities.Variation{
+				{ID: "var_1", Key: "variation_1"},
+			},
+			TrafficAllocation: []datafileEntities.TrafficAllocation{
+				{EntityID: "var_1", EndOfRange: 10000},
+			},
+		},
+	}
+
+	featureMap := map[string]entities.Feature{
+		"feature_1": {ID: "feature_1", Key: "feature_1"},
+		"feature_2": {ID: "feature_2", Key: "feature_2"},
+		"feature_3": {ID: "feature_3", Key: "feature_3"},
+	}
+
+	holdoutList, holdoutIDMap, flagHoldoutsMap := MapHoldouts(rawHoldouts, featureMap)
+
+	// Verify holdout list and ID map
+	assert.Len(t, holdoutList, 1)
+	assert.Len(t, holdoutIDMap, 1)
+
+	// Specific holdout should only apply to feature_1 and feature_2
+	assert.Contains(t, flagHoldoutsMap, "feature_1")
+	assert.Contains(t, flagHoldoutsMap, "feature_2")
+	assert.NotContains(t, flagHoldoutsMap, "feature_3")
+
+	assert.Len(t, flagHoldoutsMap["feature_1"], 1)
+	assert.Len(t, flagHoldoutsMap["feature_2"], 1)
+}
+
+func TestMapHoldoutsNotRunning(t *testing.T) {
+	// Holdout with non-Running status should be filtered out
+	rawHoldouts := []datafileEntities.Holdout{
+		{
+			ID:     "holdout_1",
+			Key:    "paused_holdout",
+			Status: "Paused",
+			Variations: []datafileEntities.Variation{
+				{ID: "var_1", Key: "variation_1"},
+			},
+		},
+	}
+
+	featureMap := map[string]entities.Feature{
+		"feature_1": {ID: "feature_1", Key: "feature_1"},
+	}
+
+	holdoutList, holdoutIDMap, flagHoldoutsMap := MapHoldouts(rawHoldouts, featureMap)
+
+	// Non-running holdouts should be filtered out
+	assert.Empty(t, holdoutList)
+	assert.Empty(t, holdoutIDMap)
+	assert.Empty(t, flagHoldoutsMap)
+}
+
+func TestMapHoldoutsMixed(t *testing.T) {
+	// Mix of global and specific holdouts
+	rawHoldouts := []datafileEntities.Holdout{
+		{
+			ID:            "holdout_global",
+			Key:           "global_holdout",
+			Status:        "Running",
+			ExcludedFlags: []string{"feature_2"},
+			Variations: []datafileEntities.Variation{
+				{ID: "var_global", Key: "variation_global"},
+			},
+			TrafficAllocation: []datafileEntities.TrafficAllocation{
+				{EntityID: "var_global", EndOfRange: 5000},
+			},
+		},
+		{
+			ID:            "holdout_specific",
+			Key:           "specific_holdout",
+			Status:        "Running",
+			IncludedFlags: []string{"feature_2"},
+			Variations: []datafileEntities.Variation{
+				{ID: "var_specific", Key: "variation_specific"},
+			},
+			TrafficAllocation: []datafileEntities.TrafficAllocation{
+				{EntityID: "var_specific", EndOfRange: 10000},
+			},
+		},
+	}
+
+	featureMap := map[string]entities.Feature{
+		"feature_1": {ID: "feature_1", Key: "feature_1"},
+		"feature_2": {ID: "feature_2", Key: "feature_2"},
+	}
+
+	holdoutList, holdoutIDMap, flagHoldoutsMap := MapHoldouts(rawHoldouts, featureMap)
+
+	// Verify both holdouts are in the list
+	assert.Len(t, holdoutList, 2)
+	assert.Len(t, holdoutIDMap, 2)
+
+	// feature_1: should get global holdout only (not excluded, not specifically included)
+	assert.Contains(t, flagHoldoutsMap, "feature_1")
+	assert.Len(t, flagHoldoutsMap["feature_1"], 1)
+	assert.Equal(t, "global_holdout", flagHoldoutsMap["feature_1"][0].Key)
+
+	// feature_2: should get specific holdout only (excluded from global)
+	assert.Contains(t, flagHoldoutsMap, "feature_2")
+	assert.Len(t, flagHoldoutsMap["feature_2"], 1)
+	assert.Equal(t, "specific_holdout", flagHoldoutsMap["feature_2"][0].Key)
+}
+
+func TestMapHoldoutsWithAudienceConditions(t *testing.T) {
+	rawHoldouts := []datafileEntities.Holdout{
+		{
+			ID:                 "holdout_1",
+			Key:                "holdout_with_audience",
+			Status:             "Running",
+			AudienceIds:        []string{"audience_1", "audience_2"},
+			AudienceConditions: []interface{}{"or", "audience_1", "audience_2"},
+			Variations: []datafileEntities.Variation{
+				{ID: "var_1", Key: "variation_1"},
+			},
+			TrafficAllocation: []datafileEntities.TrafficAllocation{
+				{EntityID: "var_1", EndOfRange: 10000},
+			},
+		},
+	}
+
+	featureMap := map[string]entities.Feature{
+		"feature_1": {ID: "feature_1", Key: "feature_1"},
+	}
+
+	holdoutList, _, _ := MapHoldouts(rawHoldouts, featureMap)
+
+	// Verify audience conditions are mapped
+	assert.Len(t, holdoutList, 1)
+	assert.Equal(t, []string{"audience_1", "audience_2"}, holdoutList[0].AudienceIds)
+	assert.NotNil(t, holdoutList[0].AudienceConditionTree)
+}
+
+func TestMapHoldoutsVariationsMapping(t *testing.T) {
+	rawHoldouts := []datafileEntities.Holdout{
+		{
+			ID:     "holdout_1",
+			Key:    "holdout_variations",
+			Status: "Running",
+			Variations: []datafileEntities.Variation{
+				{
+					ID:             "var_1",
+					Key:            "variation_1",
+					FeatureEnabled: true,
+					Variables: []datafileEntities.VariationVariable{
+						{ID: "var_var_1", Value: "value_1"},
+					},
+				},
+				{
+					ID:             "var_2",
+					Key:            "variation_2",
+					FeatureEnabled: false,
+				},
+			},
+			TrafficAllocation: []datafileEntities.TrafficAllocation{
+				{EntityID: "var_1", EndOfRange: 5000},
+				{EntityID: "var_2", EndOfRange: 10000},
+			},
+		},
+	}
+
+	featureMap := map[string]entities.Feature{
+		"feature_1": {ID: "feature_1", Key: "feature_1"},
+	}
+
+	holdoutList, _, _ := MapHoldouts(rawHoldouts, featureMap)
+
+	// Verify variations are mapped correctly
+	assert.Len(t, holdoutList, 1)
+	assert.Len(t, holdoutList[0].Variations, 2)
+	assert.Contains(t, holdoutList[0].Variations, "var_1")
+	assert.Contains(t, holdoutList[0].Variations, "var_2")
+
+	// Verify traffic allocation
+	assert.Len(t, holdoutList[0].TrafficAllocation, 2)
+	assert.Equal(t, "var_1", holdoutList[0].TrafficAllocation[0].EntityID)
+	assert.Equal(t, 5000, holdoutList[0].TrafficAllocation[0].EndOfRange)
+	assert.Equal(t, "var_2", holdoutList[0].TrafficAllocation[1].EntityID)
+	assert.Equal(t, 10000, holdoutList[0].TrafficAllocation[1].EndOfRange)
+}

pkg/decision/holdout_service.go

@@ -102,7 +102,7 @@ func (h HoldoutService) GetDecision(decisionContext FeatureDecisionContext, user
 		variation, _, _ := h.bucketer.Bucket(bucketingID, experimentForBucketing, entities.Group{})
 
 		if variation != nil {
-			reason := reasons.AddInfo("User %s is in variation %s of holdout %s.", userContext.ID, variation.Key, holdout.Key)
+			reason = reasons.AddInfo("User %s is in variation %s of holdout %s.", userContext.ID, variation.Key, holdout.Key)
 			h.logger.Info(reason)
 
 			featureDecision := FeatureDecision{