Make label private

Author: nmayorsplit

conf/conf.go

@@ -2,6 +2,8 @@ package conf
 
 import (
 	"crypto/tls"
+
+	"github.com/splitio/go-split-commons/v8/dtos"
 )
 
 // RedisConfig struct is used to cofigure the redis parameters
@@ -89,7 +91,7 @@ type AdvancedConfig struct {
 	FlagsSpecVersion       string
 	LargeSegment           *LargeSegmentConfig
 	RulesConfig            *RulesConfig
-	FallbackTreatment      FallbackTreatmentConf
+	FallbackTreatment      dtos.FallbackTreatmentConfig
 }
 
 type LargeSegmentConfig struct {
@@ -106,13 +108,3 @@ type RulesConfig struct {
 	FeatureFlagRules      []string
 	RuleBasedSegmentRules []string
 }
-
-type FallbackTreatmentConf struct {
-	GlobalFallbackTreatment *FallbackTreatmentForConf
-	ByFlagFallbackTreatment map[string]FallbackTreatmentForConf
-}
-
-type FallbackTreatmentForConf struct {
-	Treatment *string
-	Config    *string
-}

dtos/fallbacktreatment.go

@@ -7,7 +7,11 @@ const (
 type FallbackTreatment struct {
 	Treatment *string
 	Config    *string
-	Label     *string
+	label     *string
+}
+
+func (f *FallbackTreatment) Label() *string {
+	return f.label
 }
 
 type FallbackTreatmentConfig struct {
@@ -36,22 +40,22 @@ func (f *FallbackTreatmentCalculatorImp) Resolve(flagName string, label *string)
 				return FallbackTreatment{
 					Treatment: val.Treatment,
 					Config:    val.Config,
-					Label:     f.resolveLabel(label),
+					label:     f.resolveLabel(label),
 				}
 			}
 		}
 		if f.fallbackTreatmentConfig.GlobalFallbackTreatment != nil {
 			return FallbackTreatment{
 				Treatment: f.fallbackTreatmentConfig.GlobalFallbackTreatment.Treatment,
 				Config:    f.fallbackTreatmentConfig.GlobalFallbackTreatment.Config,
-				Label:     f.resolveLabel(label),
+				label:     f.resolveLabel(label),
 			}
 		}
 	}
 	controlTreatment := "control"
 	return FallbackTreatment{
 		Treatment: &controlTreatment,
-		Label:     label,
+		label:     label,
 	}
 }
 

dtos/fallbacktreatment_test.go

@@ -29,26 +29,26 @@ func TestFallbackTreatmentCalculatorResolve(t *testing.T) {
 	result := calc.Resolve("flag1", &label)
 	assert.Equal(t, "flag1_treatment", *result.Treatment)
 	assert.Equal(t, &stringConfig, result.Config)
-	assert.Equal(t, "fallback - some_label", *result.Label)
+	assert.Equal(t, "fallback - some_label", *result.label)
 
 	// Test fallback to global treatment when flag not found
 	result = calc.Resolve("flag2", &label)
 	assert.Equal(t, "global_treatment", *result.Treatment)
 	assert.Nil(t, result.Config)
-	assert.Equal(t, "fallback - some_label", *result.Label)
+	assert.Equal(t, "fallback - some_label", *result.label)
 
 	// Test nil label handling
 	result = calc.Resolve("flag1", nil)
 	assert.Equal(t, "flag1_treatment", *result.Treatment)
 	assert.Equal(t, &stringConfig, result.Config)
-	assert.Nil(t, result.Label)
+	assert.Nil(t, result.label)
 
 	// Test default control when no config
 	calcNoConfig := NewFallbackTreatmentCalculatorImp(nil)
 	result = calcNoConfig.Resolve("flag1", &label)
 	assert.Equal(t, "control", *result.Treatment)
 	assert.Nil(t, result.Config)
-	assert.Equal(t, "some_label", *result.Label)
+	assert.Equal(t, "some_label", *result.label)
 
 	// Test global treatment when no flag-specific treatments exist
 	configGlobalOnly := &FallbackTreatmentConfig{
@@ -61,5 +61,5 @@ func TestFallbackTreatmentCalculatorResolve(t *testing.T) {
 	result = calcGlobalOnly.Resolve("any_flag", &label)
 	assert.Equal(t, "global_treatment", *result.Treatment)
 	assert.Nil(t, result.Config)
-	assert.Equal(t, "fallback - some_label", *result.Label)
+	assert.Equal(t, "fallback - some_label", *result.label)
 }

engine/evaluator/evaluator.go

@@ -72,7 +72,7 @@ func (e *Evaluator) evaluateTreatment(key string, bucketingKey string, featureFl
 	if splitDto == nil {
 		fallbackTratment := e.fallbackTratmentCalculator.Resolve(featureFlag, &label)
 		e.logger.Warning(fmt.Sprintf("Feature flag %s not found, returning fallback treatment.", featureFlag))
-		return &Result{Treatment: *fallbackTratment.Treatment, Label: *fallbackTratment.Label, Config: fallbackTratment.Config}
+		return &Result{Treatment: *fallbackTratment.Treatment, Label: *fallbackTratment.Label(), Config: fallbackTratment.Config}
 	}
 
 	split := grammar.NewSplit(splitDto, e.logger, e.ruleBuilder)
@@ -122,7 +122,7 @@ func (e *Evaluator) evaluateTreatment(key string, bucketingKey string, featureFl
 		fallbackTreatment := e.fallbackTratmentCalculator.Resolve(featureFlag, &label)
 		return &Result{
 			Treatment: *fallbackTreatment.Treatment,
-			Label:     *fallbackTreatment.Label,
+			Label:     *fallbackTreatment.Label(),
 			Config:    fallbackTreatment.Config,
 		}
 	}