Updated treatments functions

nmayorsplit · nmayorsplit · commit dd17f1c3ba8e · 2025-12-05T11:38:14.000-03:00
diff --git a/splitio/client/client.go b/splitio/client/client.go
@@ -23,22 +23,14 @@ import (
 )
 
 const (
-	treatment                                          = "Treatment"
-	treatments                                         = "Treatments"
-	treatmentsByFlagSet                                = "TreatmentsByFlagSet"
-	treatmentsByFlagSets                               = "TreatmentsByFlagSets"
-	treatmentWithConfig                                = "TreatmentWithConfig"
-	treatmentsWithConfig                               = "TreatmentsWithConfig"
-	treatmentsWithConfigByFlagSet                      = "TreatmentsWithConfigByFlagSet"
-	treatmentsWithConfigByFlagSets                     = "TreatmentsWithConfigByFlagSets"
-	treatmentWithEvaluationOptions                     = "TreatmentWithEvaluationOptions"
-	treatmentsWithEvaluationOptions                    = "TreatmentsWithEvaluationOptions"
-	treatmentsByFlagSetWithEvaluationOptions           = "TreatmentsByFlagSetWithEvaluationOptions"
-	treatmentsByFlagSetsWithEvaluationOptions          = "TreatmentsByFlagSetsWithEvaluationOptions"
-	treatmentWithConfigAndEvaluationOptions            = "TreatmentWithConfigWithEvaluationOptions"
-	treatmentsWithConfigAndEvaluationOptions           = "TreatmentsWithConfigWithEvaluationOptions"
-	treatmentsWithConfigByFlagSetAndEvaluationOptions  = "TreatmentsWithConfigByFlagSetWithEvaluationOptions"
-	treatmentsWithConfigByFlagSetsAndEvaluationOptions = "TreatmentsWithConfigByFlagSetsWithEvaluationOptions"
+	treatment                      = "Treatment"
+	treatments                     = "Treatments"
+	treatmentsByFlagSet            = "TreatmentsByFlagSet"
+	treatmentsByFlagSets           = "TreatmentsByFlagSets"
+	treatmentWithConfig            = "TreatmentWithConfig"
+	treatmentsWithConfig           = "TreatmentsWithConfig"
+	treatmentsWithConfigByFlagSet  = "TreatmentsWithConfigByFlagSet"
+	treatmentsWithConfigByFlagSets = "TreatmentsWithConfigByFlagSets"
 )
 
 // SplitClient is the entry-point of the split SDK.
@@ -63,6 +55,22 @@ type TreatmentResult struct {
 	Config    *string `json:"config"`
 }
 
+type options struct {
+	evaluationOptions *dtos.EvaluationOptions
+}
+
+type OptFn = func(o *options)
+
+func (c *SplitClient) WithEvaluationOptions(e *dtos.EvaluationOptions) OptFn {
+	return func(o *options) { o.evaluationOptions = e }
+}
+
+func defaultOpts() options {
+	return options{
+		evaluationOptions: nil,
+	}
+}
+
 // getEvaluationResult calls evaluation for one particular feature flag
 func (c *SplitClient) getEvaluationResult(matchingKey string, bucketingKey *string, featureFlag string, attributes map[string]interface{}, operation string) *evaluator.Result {
 	if c.isReady() {
@@ -224,26 +232,24 @@ func serializeProperties(opts *dtos.EvaluationOptions) string {
 
 // Treatment implements the main functionality of split. Retrieve treatments of a specific feature flag
 // for a certain key and set of attributes
-func (c *SplitClient) Treatment(key interface{}, featureFlagName string, attributes map[string]interface{}) string {
-	return c.doTreatmentCall(key, featureFlagName, attributes, treatment, telemetry.Treatment, nil).Treatment
+func (c *SplitClient) Treatment(key interface{}, featureFlagName string, attributes map[string]interface{}, optFns ...OptFn) string {
+	options := getOptions(optFns...)
+	return c.doTreatmentCall(key, featureFlagName, attributes, treatment, telemetry.Treatment, options.evaluationOptions).Treatment
 }
 
-// TreatmentWithConfig implements the main functionality of split. Retrieves the treatment of a specific feature flag
-// with the corresponding configuration if it is present
-func (c *SplitClient) TreatmentWithConfig(key interface{}, featureFlagName string, attributes map[string]interface{}) TreatmentResult {
-	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithConfig, telemetry.TreatmentWithConfig, nil)
-}
-
-// TreatmentWithEvaluationOptions implements the main functionality of split. Retrieve treatments of a specific feature flag
-// for a certain key and set of attributes
-func (c *SplitClient) TreatmentWithEvaluationOptions(key interface{}, featureFlagName string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) string {
-	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithEvaluationOptions, telemetry.TreatmentWithEvaluationOptions, &evaluationOptions).Treatment
+func getOptions(optFns ...OptFn) options {
+	options := defaultOpts()
+	for _, optFn := range optFns {
+		optFn(&options)
+	}
+	return options
 }
 
-// TreatmentWithConfigAndEvaluationOptions implements the main functionality of split. Retrieves the treatment of a specific feature flag
+// TreatmentWithConfig implements the main functionality of split. Retrieves the treatment of a specific feature flag
 // with the corresponding configuration if it is present
-func (c *SplitClient) TreatmentWithConfigAndEvaluationOptions(key interface{}, featureFlagName string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) TreatmentResult {
-	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithConfigAndEvaluationOptions, telemetry.TreatmentWithConfigAndEvaluationOptions, &evaluationOptions)
+func (c *SplitClient) TreatmentWithConfig(key interface{}, featureFlagName string, attributes map[string]interface{}, optFns ...OptFn) TreatmentResult {
+	options := getOptions(optFns...)
+	return c.doTreatmentCall(key, featureFlagName, attributes, treatmentWithConfig, telemetry.TreatmentWithConfig, options.evaluationOptions)
 }
 
 // Generates control treatments
@@ -357,19 +363,10 @@ func (c *SplitClient) doTreatmentsCallByFlagSets(key interface{}, flagSets []str
 }
 
 // Treatments evaluates multiple feature flag names for a single user and set of attributes at once
-func (c *SplitClient) Treatments(key interface{}, featureFlagNames []string, attributes map[string]interface{}) map[string]string {
+func (c *SplitClient) Treatments(key interface{}, featureFlagNames []string, attributes map[string]interface{}, optFns ...OptFn) map[string]string {
+	options := getOptions(optFns...)
 	treatmentsResult := map[string]string{}
-	result := c.doTreatmentsCall(key, featureFlagNames, attributes, treatments, telemetry.Treatments, nil)
-	for feature, treatmentResult := range result {
-		treatmentsResult[feature] = treatmentResult.Treatment
-	}
-	return treatmentsResult
-}
-
-// TreatmentsWithEvaluationOptions evaluates multiple feature flag names for a single user and set of attributes at once
-func (c *SplitClient) TreatmentsWithEvaluationOptions(key interface{}, featureFlagNames []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]string {
-	treatmentsResult := map[string]string{}
-	result := c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithEvaluationOptions, telemetry.TreatmentsWithEvaluationOptions, &evaluationOptions)
+	result := c.doTreatmentsCall(key, featureFlagNames, attributes, treatments, telemetry.Treatments, options.evaluationOptions)
 	for feature, treatmentResult := range result {
 		treatmentsResult[feature] = treatmentResult.Treatment
 	}
@@ -397,55 +394,29 @@ func (c *SplitClient) validateSets(flagSets []string) []string {
 }
 
 // Treatments evaluate multiple feature flag names belonging to a flag set for a single user and a set of attributes at once
-func (c *SplitClient) TreatmentsByFlagSet(key interface{}, flagSet string, attributes map[string]interface{}) map[string]string {
+func (c *SplitClient) TreatmentsByFlagSet(key interface{}, flagSet string, attributes map[string]interface{}, optFns ...OptFn) map[string]string {
+	options := getOptions(optFns...)
 	treatmentsResult := map[string]string{}
 	sets := c.validateSets([]string{flagSet})
 	if sets == nil {
 		return treatmentsResult
 	}
-	result := c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsByFlagSet, telemetry.TreatmentsByFlagSet, nil)
+	result := c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsByFlagSet, telemetry.TreatmentsByFlagSet, options.evaluationOptions)
 	for feature, treatmentResult := range result {
 		treatmentsResult[feature] = treatmentResult.Treatment
 	}
 	return treatmentsResult
 }
 
 // Treatments evaluate multiple feature flag names belonging to flag sets for a single user and a set of attributes at once
-func (c *SplitClient) TreatmentsByFlagSets(key interface{}, flagSets []string, attributes map[string]interface{}) map[string]string {
-	treatmentsResult := map[string]string{}
-	flagSets = c.validateSets(flagSets)
-	if flagSets == nil {
-		return treatmentsResult
-	}
-	result := c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsByFlagSets, telemetry.TreatmentsByFlagSets, nil)
-	for feature, treatmentResult := range result {
-		treatmentsResult[feature] = treatmentResult.Treatment
-	}
-	return treatmentsResult
-}
-
-// TreatmentsByFlagSetWithEvaluationOptions evaluate multiple feature flag names belonging to a flag set for a single user and a set of attributes at once
-func (c *SplitClient) TreatmentsByFlagSetWithEvaluationOptions(key interface{}, flagSet string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]string {
-	treatmentsResult := map[string]string{}
-	sets := c.validateSets([]string{flagSet})
-	if sets == nil {
-		return treatmentsResult
-	}
-	result := c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsByFlagSetWithEvaluationOptions, telemetry.TreatmentsByFlagSetWithEvaluationOptions, &evaluationOptions)
-	for feature, treatmentResult := range result {
-		treatmentsResult[feature] = treatmentResult.Treatment
-	}
-	return treatmentsResult
-}
-
-// TreatmentsByFlagSetsWithEvaluationOptions evaluate multiple feature flag names belonging to flag sets for a single user and a set of attributes at once
-func (c *SplitClient) TreatmentsByFlagSetsWithEvaluationOptions(key interface{}, flagSets []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]string {
+func (c *SplitClient) TreatmentsByFlagSets(key interface{}, flagSets []string, attributes map[string]interface{}, optFns ...OptFn) map[string]string {
+	options := getOptions(optFns...)
 	treatmentsResult := map[string]string{}
 	flagSets = c.validateSets(flagSets)
 	if flagSets == nil {
 		return treatmentsResult
 	}
-	result := c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsByFlagSetsWithEvaluationOptions, telemetry.TreatmentsByFlagSetsWithEvaluationOptions, &evaluationOptions)
+	result := c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsByFlagSets, telemetry.TreatmentsByFlagSets, options.evaluationOptions)
 	for feature, treatmentResult := range result {
 		treatmentsResult[feature] = treatmentResult.Treatment
 	}
@@ -465,53 +436,31 @@ func (c *SplitClient) filterSetsAreInConfig(flagSets []string) []string {
 }
 
 // TreatmentsWithConfig evaluates multiple feature flag names for a single user and set of attributes at once and returns configurations
-func (c *SplitClient) TreatmentsWithConfig(key interface{}, featureFlagNames []string, attributes map[string]interface{}) map[string]TreatmentResult {
-	return c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithConfig, telemetry.TreatmentsWithConfig, nil)
-}
-
-// TreatmentsWithConfigAndEvaluationOptions evaluates multiple feature flag names for a single user and set of attributes at once and returns configurations
-func (c *SplitClient) TreatmentsWithConfigAndEvaluationOptions(key interface{}, featureFlagNames []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]TreatmentResult {
-	return c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithConfigAndEvaluationOptions, telemetry.TreatmentsWithConfigByFlagSetAndEvaluationOptions, &evaluationOptions)
+func (c *SplitClient) TreatmentsWithConfig(key interface{}, featureFlagNames []string, attributes map[string]interface{}, optFns ...OptFn) map[string]TreatmentResult {
+	options := getOptions(optFns...)
+	return c.doTreatmentsCall(key, featureFlagNames, attributes, treatmentsWithConfig, telemetry.TreatmentsWithConfig, options.evaluationOptions)
 }
 
 // TreatmentsWithConfigByFlagSet evaluates multiple feature flag names belonging to a flag set for a single user and set of attributes at once and returns configurations
-func (c *SplitClient) TreatmentsWithConfigByFlagSet(key interface{}, flagSet string, attributes map[string]interface{}) map[string]TreatmentResult {
-	treatmentsResult := make(map[string]TreatmentResult)
-	sets := c.validateSets([]string{flagSet})
-	if sets == nil {
-		return treatmentsResult
-	}
-	return c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsWithConfigByFlagSet, telemetry.TreatmentsWithConfigByFlagSet, nil)
-}
-
-// TreatmentsWithConfigByFlagSetAndEvaluationOptions evaluates multiple feature flag names belonging to a flag set for a single user and set of attributes at once and returns configurations
-func (c *SplitClient) TreatmentsWithConfigByFlagSetAndEvaluationOptions(key interface{}, flagSet string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]TreatmentResult {
+func (c *SplitClient) TreatmentsWithConfigByFlagSet(key interface{}, flagSet string, attributes map[string]interface{}, optFns ...OptFn) map[string]TreatmentResult {
+	options := getOptions(optFns...)
 	treatmentsResult := make(map[string]TreatmentResult)
 	sets := c.validateSets([]string{flagSet})
 	if sets == nil {
 		return treatmentsResult
 	}
-	return c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsWithConfigByFlagSetAndEvaluationOptions, telemetry.TreatmentsWithConfigByFlagSetAndEvaluationOptions, &evaluationOptions)
+	return c.doTreatmentsCallByFlagSets(key, sets, attributes, treatmentsWithConfigByFlagSet, telemetry.TreatmentsWithConfigByFlagSet, options.evaluationOptions)
 }
 
 // TreatmentsWithConfigByFlagSet evaluates multiple feature flag names belonging to a flag sets for a single user and set of attributes at once and returns configurations
-func (c *SplitClient) TreatmentsWithConfigByFlagSets(key interface{}, flagSets []string, attributes map[string]interface{}) map[string]TreatmentResult {
-	treatmentsResult := make(map[string]TreatmentResult)
-	flagSets = c.validateSets(flagSets)
-	if flagSets == nil {
-		return treatmentsResult
-	}
-	return c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsWithConfigByFlagSets, telemetry.TreatmentsWithConfigByFlagSets, nil)
-}
-
-// TreatmentsWithConfigByFlagSetsAndEvaluationOptions evaluates multiple feature flag names belonging to a flag sets for a single user and set of attributes at once and returns configurations
-func (c *SplitClient) TreatmentsWithConfigByFlagSetsAndEvaluationOptions(key interface{}, flagSets []string, attributes map[string]interface{}, evaluationOptions dtos.EvaluationOptions) map[string]TreatmentResult {
+func (c *SplitClient) TreatmentsWithConfigByFlagSets(key interface{}, flagSets []string, attributes map[string]interface{}, optFns ...OptFn) map[string]TreatmentResult {
+	options := getOptions(optFns...)
 	treatmentsResult := make(map[string]TreatmentResult)
 	flagSets = c.validateSets(flagSets)
 	if flagSets == nil {
 		return treatmentsResult
 	}
-	return c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsWithConfigByFlagSetsAndEvaluationOptions, telemetry.TreatmentsWithConfigByFlagSetsAndEvaluationOptions, &evaluationOptions)
+	return c.doTreatmentsCallByFlagSets(key, flagSets, attributes, treatmentsWithConfigByFlagSets, telemetry.TreatmentsWithConfigByFlagSets, options.evaluationOptions)
 }
 
 // isDestroyed returns true if the client has been destroyed
diff --git a/splitio/client/client_test.go b/splitio/client/client_test.go
@@ -243,7 +243,7 @@ func TestClientGetTreatmentWithEvaluationProperties(t *testing.T) {
 			"balance": 99.5,
 		},
 	}
-	expectedTreatment(client.TreatmentWithEvaluationOptions("key", "feature", nil, opts), "TreatmentA", t)
+	expectedTreatment(client.Treatment("key", "feature", nil, client.WithEvaluationOptions(&opts)), "TreatmentA", t)
 	impressionsQueue := client.impressions.(storage.ImpressionStorage)
 	impressions, _ := impressionsQueue.PopN(5000)
 	impression := impressions[0]
@@ -311,7 +311,7 @@ func TestClientGetTreatmentByFlagSetWithEvaluationProperties(t *testing.T) {
 		},
 	}
 
-	res := client.TreatmentsByFlagSetWithEvaluationOptions("user1", "set1", nil, opts)
+	res := client.TreatmentsByFlagSet("user1", "set1", nil, client.WithEvaluationOptions(&opts))
 
 	expectedTreatment(res["feature"], "TreatmentA", t)
 	impressionsQueue := client.impressions.(storage.ImpressionStorage)
@@ -387,7 +387,7 @@ func TestClientGetTreatmentByFlagSetsWithEvaluationProperties(t *testing.T) {
 		},
 	}
 
-	res := client.TreatmentsByFlagSetsWithEvaluationOptions("user1", []string{"set1", "set2"}, nil, opts)
+	res := client.TreatmentsByFlagSets("user1", []string{"set1", "set2"}, nil, client.WithEvaluationOptions(&opts))
 
 	expectedTreatment(res["feature"], "TreatmentA", t)
 	expectedTreatment(res["feature2"], "TreatmentB", t)
@@ -451,7 +451,7 @@ func TestClientGetTreatmentWithConfigByFlagSetAndEvaluationProperties(t *testing
 		},
 	}
 
-	res := client.TreatmentsWithConfigByFlagSetAndEvaluationOptions("user1", "set1", nil, opts)
+	res := client.TreatmentsWithConfigByFlagSet("user1", "set1", nil, client.WithEvaluationOptions(&opts))
 
 	expectedTreatment(res["feature"].Treatment, "TreatmentA", t)
 	impressionsQueue := client.impressions.(storage.ImpressionStorage)
@@ -526,7 +526,7 @@ func TestClientGetTreatmentWithConfigByFlagSetsAndEvaluationOptions(t *testing.T
 		},
 	}
 
-	res := client.TreatmentsWithConfigByFlagSetsAndEvaluationOptions("user1", []string{"set1", "set2"}, nil, opts)
+	res := client.TreatmentsWithConfigByFlagSets("user1", []string{"set1", "set2"}, nil, client.WithEvaluationOptions(&opts))
 
 	expectedTreatment(res["feature"].Treatment, "TreatmentA", t)
 	expectedTreatment(res["feature2"].Treatment, "TreatmentB", t)
@@ -567,7 +567,7 @@ func TestTreatmentsWithEvaluationOptions(t *testing.T) {
 		},
 	}
 
-	res := client.TreatmentsWithEvaluationOptions("user1", []string{"feature", "notFeature"}, nil, opts)
+	res := client.Treatments("user1", []string{"feature", "notFeature"}, nil, client.WithEvaluationOptions(&opts))
 
 	expectedTreatment(res["feature"], "TreatmentA", t)
 	expectedTreatment(res["notFeature"], evaluator.Control, t)
@@ -941,7 +941,7 @@ func TestImpressionListenerForTreatmentsWithEvaluationOptions(t *testing.T) {
 		},
 	}
 
-	res := client.TreatmentsWithEvaluationOptions("user1", []string{"feature", "feature2"}, attributes, opts)
+	res := client.Treatments("user1", []string{"feature", "feature2"}, attributes, client.WithEvaluationOptions(&opts))
 
 	expectedTreatment(res["feature"], "TreatmentA", t)
 	expectedTreatment(res["feature2"], "TreatmentB", t)
