1 package datasource
2
3 import (
4 "testing"
5
6 "github.com/stretchr/testify/assert"
7 "github.com/stretchr/testify/require"
8
9 "github.com/launchdarkly/go-server-sdk-evaluation/v2/ldbuilders"
10 "github.com/launchdarkly/go-server-sdk/v6/internal/datakinds"
11 "github.com/launchdarkly/go-server-sdk/v6/internal/sharedtest"
12 )
13
14 func TestParsePutData(t *testing.T) {
15 allDataJSON := `{
16 "flags": {
17 "flag1": {"key": "flag1", "version": 1},
18 "flag2": {"key": "flag2", "version": 2}
19 },
20 "segments": {
21 "segment1": {"key": "segment1","version": 3}
22 }
23 }`
24 expectedAllData := sharedtest.NewDataSetBuilder().
25 Flags(ldbuilders.NewFlagBuilder("flag1").Version(1).Build(),
26 ldbuilders.NewFlagBuilder("flag2").Version(2).Build()).
27 Segments(ldbuilders.NewSegmentBuilder("segment1").Version(3).Build()).
28 Build()
29
30 t.Run("valid", func(t *testing.T) {
31 input := []byte(`{"path": "/", "data": ` + allDataJSON + `}`)
32
33 result, err := parsePutData(input)
34 require.NoError(t, err)
35
36 assert.Equal(t, "/", result.Path)
37 assert.Equal(t, sharedtest.NormalizeDataSet(expectedAllData), sharedtest.NormalizeDataSet(result.Data))
38 })
39
40 t.Run("missing path", func(t *testing.T) {
41 input := []byte(`{"data": ` + allDataJSON + `}`)
42 result, err := parsePutData(input)
43 require.NoError(t, err)
44 assert.Equal(t, "", result.Path)
45 assert.Equal(t, sharedtest.NormalizeDataSet(expectedAllData), sharedtest.NormalizeDataSet(result.Data))
46 })
47
48 t.Run("missing data", func(t *testing.T) {
49 input := []byte(`{"path": "/"}`)
50 _, err := parsePutData(input)
51 require.Error(t, err)
52 })
53 }
54
55 func TestParsePatchData(t *testing.T) {
56 flag := ldbuilders.NewFlagBuilder("flagkey").Version(2).On(true).Build()
57 segment := ldbuilders.NewSegmentBuilder("segmentkey").Version(3).Included("x").Build()
58 flagJSON := `{"key": "flagkey", "version": 2, "on": true}`
59 segmentJSON := `{"key": "segmentkey", "version": 3, "included": ["x"]}`
60
61 t.Run("valid flag", func(t *testing.T) {
62 input := []byte(`{"path": "/flags/flagkey", "data": ` + flagJSON + `}`)
63 result, err := parsePatchData(input)
64 require.NoError(t, err)
65
66 assert.Equal(t, datakinds.Features, result.Kind)
67 assert.Equal(t, "flagkey", result.Key)
68 assert.Equal(t, sharedtest.FlagDescriptor(flag), result.Data)
69 })
70
71 t.Run("valid segment", func(t *testing.T) {
72 input := []byte(`{"path": "/segments/segmentkey", "data": ` + segmentJSON + `}`)
73 result, err := parsePatchData(input)
74 require.NoError(t, err)
75
76 assert.Equal(t, datakinds.Segments, result.Kind)
77 assert.Equal(t, "segmentkey", result.Key)
78 assert.Equal(t, sharedtest.SegmentDescriptor(segment), result.Data)
79 })
80
81 t.Run("valid but data property appears before path", func(t *testing.T) {
82 input := []byte(`{"data": ` + flagJSON + `, "path": "/flags/flagkey"}`)
83 result, err := parsePatchData(input)
84 require.NoError(t, err)
85
86 assert.Equal(t, datakinds.Features, result.Kind)
87 assert.Equal(t, "flagkey", result.Key)
88 assert.Equal(t, sharedtest.FlagDescriptor(flag), result.Data)
89 })
90
91 t.Run("unrecognized path", func(t *testing.T) {
92 input := []byte(`{"path": "/cats/lucy", "data": ` + flagJSON + `}`)
93 result, err := parsePatchData(input)
94 require.NoError(t, err)
95
96 assert.Nil(t, result.Kind)
97 assert.Equal(t, "", result.Key)
98 })
99
100 t.Run("missing path", func(t *testing.T) {
101 input := []byte(`{"data": ` + flagJSON + `}`)
102 _, err := parsePatchData(input)
103 require.Error(t, err)
104 })
105
106 t.Run("missing data", func(t *testing.T) {
107 input := []byte(`{"path": "/flags/flagkey"}`)
108 _, err := parsePatchData(input)
109 require.Error(t, err)
110 })
111 }
112
113 func TestParseDeleteData(t *testing.T) {
114 t.Run("valid flag", func(t *testing.T) {
115 input := []byte(`{"path": "/flags/flagkey", "version": 3}`)
116 result, err := parseDeleteData(input)
117 require.NoError(t, err)
118
119 assert.Equal(t, datakinds.Features, result.Kind)
120 assert.Equal(t, "flagkey", result.Key)
121 assert.Equal(t, 3, result.Version)
122 })
123
124 t.Run("valid segment", func(t *testing.T) {
125 input := []byte(`{"path": "/segments/segmentkey", "version": 4}`)
126 result, err := parseDeleteData(input)
127 require.NoError(t, err)
128
129 assert.Equal(t, datakinds.Segments, result.Kind)
130 assert.Equal(t, "segmentkey", result.Key)
131 assert.Equal(t, 4, result.Version)
132 })
133
134 t.Run("unrecognized path", func(t *testing.T) {
135 input := []byte(`{"path": "/cats/macavity", "version": 9}`)
136 result, err := parseDeleteData(input)
137 require.NoError(t, err)
138
139 assert.Nil(t, result.Kind)
140 assert.Equal(t, "", result.Key)
141 })
142
143 t.Run("missing path", func(t *testing.T) {
144 input := []byte(`{"version": 1}`)
145 _, err := parseDeleteData(input)
146 require.Error(t, err)
147 })
148
149 t.Run("missing version", func(t *testing.T) {
150 input := []byte(`{"path": "/flags/flagkey"}`)
151 _, err := parseDeleteData(input)
152 require.Error(t, err)
153 })
154 }
155
View as plain text