Merge branch 'main' of github.com:splitio/go-split-commons

Author: mmelograno

.github/workflows/ci.yml

@@ -18,12 +18,12 @@ jobs:
           - 6379:6379
     steps:
       - name: Checkout code
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 
       - name: Set up Go version
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: '1.21'
 

.github/workflows/update-license-year.yml

@@ -13,7 +13,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Checkout
-        uses: actions/checkout@v4
+        uses: actions/checkout@v5
         with:
           fetch-depth: 0
 

dtos/split.go

@@ -16,6 +16,12 @@ type FeatureFlagsDTO struct {
 	Splits []SplitDTO `json:"d"`
 }
 
+type SplitsDTO struct {
+	Since  int64      `json:"since"`
+	Till   int64      `json:"till"`
+	Splits []SplitDTO `json:"splits"`
+}
+
 type RuleBasedSegmentsDTO struct {
 	Since             int64                 `json:"s"`
 	Till              int64                 `json:"t"`

dtos/splitchangewrapper.go

@@ -0,0 +1,206 @@
+package dtos
+
+import (
+	"encoding/json"
+)
+
+// FFResponse is an interface that abstracts the differences between different versions of feature flag responses.
+type FFResponse interface {
+	NeedsAnotherFetch() bool
+	RuleBasedSegments() []RuleBasedSegmentDTO
+	FeatureFlags() []SplitDTO
+	FFTill() int64
+	RBTill() int64
+	FFSince() int64
+	RBSince() int64
+}
+
+// FFResponseLegacy handles the legacy format of feature flag responses.
+type FFResponseLegacy struct {
+	SplitChanges SplitsDTO
+}
+
+// NewFFResponseLegacy creates a new FFResponseLegacy instance from the provided JSON data.
+func NewFFResponseLegacy(data []byte) (FFResponse, error) {
+	var splitChangesDto SplitsDTO
+	err := json.Unmarshal(data, &splitChangesDto)
+	if err == nil {
+		return &FFResponseLegacy{
+			SplitChanges: splitChangesDto,
+		}, nil
+	}
+	return nil, err
+}
+
+// NeedsAnotherFetch checks if another fetch is needed based on the since and till values.
+func (ffLegacy *FFResponseLegacy) NeedsAnotherFetch() bool {
+	return ffLegacy.SplitChanges.Since == ffLegacy.SplitChanges.Till
+}
+
+// FeatureFlags returns the list of feature flags (splits) from the response.
+func (ffLegacy *FFResponseLegacy) FeatureFlags() []SplitDTO {
+	return ffLegacy.SplitChanges.Splits
+}
+
+// RuleBasedSegments returns an empty list as legacy responses do not contain rule-based segments.
+func (ffLegacy *FFResponseLegacy) RuleBasedSegments() []RuleBasedSegmentDTO {
+	return []RuleBasedSegmentDTO{}
+}
+
+// FFTill returns the till value for feature flags.
+func (ffLegacy *FFResponseLegacy) FFTill() int64 {
+	return ffLegacy.SplitChanges.Till
+}
+
+// RBTill returns 0 as legacy responses do not contain rule-based segments.
+func (ffLegacy *FFResponseLegacy) RBTill() int64 {
+	return 0
+}
+
+// FFSince returns the since value for feature flags.
+func (ffLegacy *FFResponseLegacy) FFSince() int64 {
+	return ffLegacy.SplitChanges.Since
+}
+
+// RBSince returns 0 as legacy responses do not contain rule-based segments.
+func (ffLegacy *FFResponseLegacy) RBSince() int64 {
+	return 0
+}
+
+// FFResponseV13 handles the version 1.3 format of feature flag responses.
+type FFResponseV13 struct {
+	SplitChanges SplitChangesDTO
+}
+
+// NewFFResponseV13 creates a new FFResponseV13 instance from the provided JSON data.
+func NewFFResponseV13(data []byte) (FFResponse, error) {
+	var splitChangesDto SplitChangesDTO
+	err := json.Unmarshal(data, &splitChangesDto)
+	if err == nil {
+		return &FFResponseV13{
+			SplitChanges: splitChangesDto,
+		}, nil
+	}
+	return nil, err
+}
+
+// FeatureFlags returns the list of feature flags (splits) from the response.
+func (f13 *FFResponseV13) FeatureFlags() []SplitDTO {
+	return f13.SplitChanges.FeatureFlags.Splits
+}
+
+// RuleBasedSegments returns the list of rule-based segments from the response.
+func (f13 *FFResponseV13) RuleBasedSegments() []RuleBasedSegmentDTO {
+	return f13.SplitChanges.RuleBasedSegments.RuleBasedSegments
+}
+
+// NeedsAnotherFetch checks if another fetch is needed based on the since and till values for both feature flags and rule-based segments.
+func (f13 FFResponseV13) NeedsAnotherFetch() bool {
+	return f13.SplitChanges.FeatureFlags.Since == f13.SplitChanges.FeatureFlags.Till && f13.SplitChanges.RuleBasedSegments.Since == f13.SplitChanges.RuleBasedSegments.Till
+}
+
+// FFTill returns the till value for feature flags.
+func (f13 *FFResponseV13) FFTill() int64 {
+	return f13.SplitChanges.FeatureFlags.Till
+}
+
+// RBTill returns the till value for rule-based segments.
+func (f13 *FFResponseV13) RBTill() int64 {
+	return f13.SplitChanges.RuleBasedSegments.Till
+}
+
+// RBSince returns the since value for rule-based segments.
+func (f13 *FFResponseV13) RBSince() int64 {
+	return f13.SplitChanges.RuleBasedSegments.Since
+}
+
+// FFSince returns the since value for feature flags.
+func (f13 *FFResponseV13) FFSince() int64 {
+	return f13.SplitChanges.FeatureFlags.Since
+}
+
+// FFResponseLocalV13 is a local version of FFResponseV13 for internal use.
+type FFResponseLocalV13 struct {
+	SplitChanges SplitChangesDTO
+}
+
+// NewFFResponseLocalV13 creates a new FFResponseLocalV13 instance from the provided JSON data.
+func NewFFResponseLocalV13(data []byte) (*FFResponseLocalV13, error) {
+	var splitChangesDto SplitChangesDTO
+	err := json.Unmarshal(data, &splitChangesDto)
+	if err == nil {
+		return &FFResponseLocalV13{
+			SplitChanges: splitChangesDto,
+		}, nil
+	}
+	return nil, err
+}
+
+// FeatureFlags returns the list of feature flags (splits) from the response.
+func (f *FFResponseLocalV13) FeatureFlags() []SplitDTO {
+	return f.SplitChanges.FeatureFlags.Splits
+}
+
+// RuleBasedSegments returns the list of rule-based segments from the response.
+func (f *FFResponseLocalV13) RuleBasedSegments() []RuleBasedSegmentDTO {
+	return f.SplitChanges.RuleBasedSegments.RuleBasedSegments
+}
+
+// NeedsAnotherFetch checks if another fetch is needed based on the since and till values for both feature flags and rule-based segments.
+func (f FFResponseLocalV13) NeedsAnotherFetch() bool {
+	return f.SplitChanges.FeatureFlags.Since == f.SplitChanges.FeatureFlags.Till && f.SplitChanges.RuleBasedSegments.Since == f.SplitChanges.RuleBasedSegments.Till
+}
+
+// FFTill returns the till value for feature flags.
+func (f *FFResponseLocalV13) FFTill() int64 {
+	return f.SplitChanges.FeatureFlags.Till
+}
+
+// RBTill returns the till value for rule-based segments.
+func (f *FFResponseLocalV13) RBTill() int64 {
+	return f.SplitChanges.RuleBasedSegments.Till
+}
+
+// RBSince returns the since value for rule-based segments.
+func (f *FFResponseLocalV13) RBSince() int64 {
+	return f.SplitChanges.RuleBasedSegments.Since
+}
+
+// FFSince returns the since value for feature flags.
+func (f *FFResponseLocalV13) SetFFTill(till int64) {
+	f.SplitChanges.FeatureFlags.Till = till
+}
+
+// SetFFSince sets the since value for feature flags.
+func (f *FFResponseLocalV13) SetFFSince(since int64) {
+	f.SplitChanges.FeatureFlags.Since = since
+}
+
+// SetRBTill sets the till value for rule-based segments.
+func (f *FFResponseLocalV13) SetRBTill(till int64) {
+	f.SplitChanges.RuleBasedSegments.Till = till
+}
+
+// FFSince returns the since value for feature flags.
+func (f *FFResponseLocalV13) FFSince() int64 {
+	return f.SplitChanges.FeatureFlags.Since
+}
+
+// SetRBSince sets the since value for rule-based segments.
+func (f *FFResponseLocalV13) SetRBSince(since int64) {
+	f.SplitChanges.RuleBasedSegments.Since = since
+}
+
+// ReplaceFF replaces the feature flags (splits) in the response with the provided list.
+func (f *FFResponseLocalV13) ReplaceFF(featureFlags []SplitDTO) {
+	f.SplitChanges.FeatureFlags.Splits = featureFlags
+}
+
+// ReplaceRB replaces the rule-based segments in the response with the provided list.
+func (f *FFResponseLocalV13) ReplaceRB(ruleBasedSegments []RuleBasedSegmentDTO) {
+	f.SplitChanges.RuleBasedSegments.RuleBasedSegments = ruleBasedSegments
+}
+
+var _ FFResponse = (*FFResponseLegacy)(nil)
+var _ FFResponse = (*FFResponseV13)(nil)
+var _ FFResponse = (*FFResponseLocalV13)(nil)

dtos/splitchangewrapper_test.go

@@ -0,0 +1,150 @@
+package dtos
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestFFResponseLegacy(t *testing.T) {
+	some, err := NewFFResponseLegacy([]byte(`{wrong json}`))
+	assert.Nil(t, some)
+	assert.NotNil(t, err)
+
+	ok, err := NewFFResponseLegacy([]byte(`{"since":1,"till":2,"splits":[{"name":"split1"},{"name":"split2"}]}`))
+	assert.NotNil(t, ok)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), ok.FFTill())
+	assert.Equal(t, int64(0), ok.RBTill())
+	assert.Equal(t, int64(1), ok.FFSince())
+	assert.Equal(t, int64(0), ok.RBSince())
+	assert.False(t, ok.NeedsAnotherFetch())
+	assert.Len(t, ok.FeatureFlags(), 2)
+	assert.Empty(t, ok.RuleBasedSegments())
+
+	noFetch, err := NewFFResponseLegacy([]byte(`{"since":2,"till":2,"splits":[]}`))
+	assert.NotNil(t, noFetch)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), noFetch.FFTill())
+	assert.Equal(t, int64(0), noFetch.RBTill())
+	assert.Equal(t, int64(2), noFetch.FFSince())
+	assert.Equal(t, int64(0), noFetch.RBSince())
+	assert.True(t, noFetch.NeedsAnotherFetch())
+	assert.Len(t, noFetch.FeatureFlags(), 0)
+	assert.Empty(t, noFetch.RuleBasedSegments())
+}
+
+func TestFFResponseLatest(t *testing.T) {
+	some, err := NewFFResponseV13([]byte(`{wrong json}`))
+	assert.Nil(t, some)
+	assert.NotNil(t, err)
+
+	ok, err := NewFFResponseV13([]byte(`{
+		"ff":{
+			"s":1,
+			"t":2,
+			"d":[{"name":"split1"},{"name":"split2"}]
+		},
+		"rbs":{
+			"s":3,
+			"t":4,
+			"d":[{"name":"rb1"},{"name":"rb2"},{"name":"rb3"}]
+		}
+	}`))
+	assert.NotNil(t, ok)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), ok.FFTill())
+	assert.Equal(t, int64(4), ok.RBTill())
+	assert.Equal(t, int64(1), ok.FFSince())
+	assert.Equal(t, int64(3), ok.RBSince())
+	assert.Len(t, ok.FeatureFlags(), 2)
+	assert.Len(t, ok.RuleBasedSegments(), 3)
+	assert.False(t, ok.NeedsAnotherFetch())
+
+	noFetch, err := NewFFResponseV13([]byte(`{
+		"ff":{
+			"s":2,
+			"t":2,
+			"d":[]
+		},
+		"rbs":{
+			"s":4,
+			"t":4,
+			"d":[]
+		}
+	}`))
+	assert.NotNil(t, noFetch)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), noFetch.FFTill())
+	assert.Equal(t, int64(4), noFetch.RBTill())
+	assert.Equal(t, int64(2), noFetch.FFSince())
+	assert.Equal(t, int64(4), noFetch.RBSince())
+	assert.Len(t, noFetch.FeatureFlags(), 0)
+	assert.Len(t, noFetch.RuleBasedSegments(), 0)
+	assert.True(t, noFetch.NeedsAnotherFetch())
+}
+
+func TestFFResponseLocalV13(t *testing.T) {
+	some, err := NewFFResponseLocalV13([]byte(`{wrong json}`))
+	assert.Nil(t, some)
+	assert.NotNil(t, err)
+
+	ok, err := NewFFResponseLocalV13([]byte(`{
+		"ff":{
+			"s":1,
+			"t":2,
+			"d":[{"name":"split1"},{"name":"split2"}]
+		},
+		"rbs":{
+			"s":3,
+			"t":4,
+			"d":[{"name":"rb1"},{"name":"rb2"},{"name":"rb3"}]
+		}
+	}`))
+	assert.NotNil(t, ok)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), ok.FFTill())
+	assert.Equal(t, int64(4), ok.RBTill())
+	assert.Equal(t, int64(1), ok.FFSince())
+	assert.Equal(t, int64(3), ok.RBSince())
+	assert.Len(t, ok.FeatureFlags(), 2)
+	assert.Len(t, ok.RuleBasedSegments(), 3)
+	assert.False(t, ok.NeedsAnotherFetch())
+
+	ok.SetFFTill(5)
+	ok.SetFFSince(5)
+	ok.SetRBSince(5)
+	ok.SetRBTill(5)
+	assert.Equal(t, int64(5), ok.FFTill())
+	assert.Equal(t, int64(5), ok.RBTill())
+	assert.Equal(t, int64(5), ok.FFSince())
+	assert.Equal(t, int64(5), ok.RBSince())
+	ok.ReplaceFF([]SplitDTO{{Name: "other"}})
+	ok.ReplaceRB([]RuleBasedSegmentDTO{{Name: "other_rb"}})
+	assert.Len(t, ok.FeatureFlags(), 1)
+	assert.Len(t, ok.RuleBasedSegments(), 1)
+	assert.Equal(t, "other", ok.FeatureFlags()[0].Name)
+	assert.Equal(t, "other_rb", ok.RuleBasedSegments()[0].Name)
+
+	noFetch, err := NewFFResponseLocalV13([]byte(`{
+		"ff":{
+			"s":2,
+			"t":2,
+			"d":[]
+		},
+		"rbs":{
+			"s":4,
+			"t":4,
+			"d":[]
+		}
+	}`))
+	assert.NotNil(t, noFetch)
+	assert.Nil(t, err)
+	assert.Equal(t, int64(2), noFetch.FFTill())
+	assert.Equal(t, int64(4), noFetch.RBTill())
+	assert.Equal(t, int64(2), noFetch.FFSince())
+	assert.Equal(t, int64(4), noFetch.RBSince())
+	assert.Len(t, noFetch.FeatureFlags(), 0)
+	assert.Len(t, noFetch.RuleBasedSegments(), 0)
+	assert.True(t, noFetch.NeedsAnotherFetch())
+}