1 package ldcomponents
2
3 import (
4 "encoding/json"
5 "net/http/httptest"
6 "testing"
7 "time"
8
9 "github.com/launchdarkly/go-sdk-common/v3/ldattr"
10 "github.com/launchdarkly/go-sdk-common/v3/lduser"
11 "github.com/launchdarkly/go-sdk-common/v3/ldvalue"
12 ldevents "github.com/launchdarkly/go-sdk-events/v2"
13 "github.com/launchdarkly/go-server-sdk/v6/testhelpers/ldservices"
14
15 "github.com/launchdarkly/go-test-helpers/v3/httphelpers"
16 m "github.com/launchdarkly/go-test-helpers/v3/matchers"
17
18 "github.com/stretchr/testify/assert"
19 "github.com/stretchr/testify/require"
20 )
21
22
23
24
25 func TestEventProcessorBuilder(t *testing.T) {
26 t.Run("AllAttributesPrivate", func(t *testing.T) {
27 b := SendEvents()
28 assert.False(t, b.allAttributesPrivate)
29
30 b.AllAttributesPrivate(true)
31 assert.True(t, b.allAttributesPrivate)
32
33 b.AllAttributesPrivate(false)
34 assert.False(t, b.allAttributesPrivate)
35 })
36
37 t.Run("Capacity", func(t *testing.T) {
38 b := SendEvents()
39 assert.Equal(t, DefaultEventsCapacity, b.capacity)
40
41 b.Capacity(333)
42 assert.Equal(t, 333, b.capacity)
43 })
44
45 t.Run("DiagnosticRecordingInterval", func(t *testing.T) {
46 b := SendEvents()
47 assert.Equal(t, DefaultDiagnosticRecordingInterval, b.diagnosticRecordingInterval)
48
49 b.DiagnosticRecordingInterval(time.Hour)
50 assert.Equal(t, time.Hour, b.diagnosticRecordingInterval)
51
52 b.DiagnosticRecordingInterval(time.Second)
53 assert.Equal(t, MinimumDiagnosticRecordingInterval, b.diagnosticRecordingInterval)
54 })
55
56 t.Run("FlushInterval", func(t *testing.T) {
57 b := SendEvents()
58 assert.Equal(t, DefaultFlushInterval, b.flushInterval)
59
60 b.FlushInterval(time.Hour)
61 assert.Equal(t, time.Hour, b.flushInterval)
62 })
63
64 t.Run("PrivateAttributes", func(t *testing.T) {
65 b := SendEvents()
66 assert.Len(t, b.privateAttributes, 0)
67
68 b.PrivateAttributes("name", "/address/street")
69 assert.Equal(t, []ldattr.Ref{ldattr.NewRef("name"), ldattr.NewRef("/address/street")},
70 b.privateAttributes)
71 })
72
73 t.Run("ContextKeysCapacity", func(t *testing.T) {
74 b := SendEvents()
75 assert.Equal(t, DefaultContextKeysCapacity, b.contextKeysCapacity)
76
77 b.ContextKeysCapacity(333)
78 assert.Equal(t, 333, b.contextKeysCapacity)
79 })
80
81 t.Run("ContextKeysFlushInterval", func(t *testing.T) {
82 b := SendEvents()
83 assert.Equal(t, DefaultContextKeysFlushInterval, b.contextKeysFlushInterval)
84
85 b.ContextKeysFlushInterval(time.Hour)
86 assert.Equal(t, time.Hour, b.contextKeysFlushInterval)
87 })
88 }
89
90 func TestDefaultEventsConfigWithoutDiagnostics(t *testing.T) {
91 eventsHandler, requestsCh := httphelpers.RecordingHandler(ldservices.ServerSideEventsServiceHandler())
92 httphelpers.WithServer(eventsHandler, func(server *httptest.Server) {
93 ep, err := SendEvents().
94 Build(makeTestContextWithBaseURIs(server.URL))
95 require.NoError(t, err)
96
97 ef := ldevents.NewEventFactory(false, nil)
98 ce := ef.NewCustomEventData("event-key", ldevents.Context(lduser.NewUser("key")), ldvalue.Null(), false, 0)
99 ep.RecordCustomEvent(ce)
100 ep.Flush()
101
102 r := <-requestsCh
103 var jsonData ldvalue.Value
104 _ = json.Unmarshal(r.Body, &jsonData)
105 assert.Equal(t, 2, jsonData.Count())
106 assert.Equal(t, ldvalue.String("index"), jsonData.GetByIndex(0).GetByKey("kind"))
107 assert.Equal(t, ldvalue.String("custom"), jsonData.GetByIndex(1).GetByKey("kind"))
108 })
109 }
110
111 func TestDefaultEventsConfigWithDiagnostics(t *testing.T) {
112 eventsHandler, requestsCh := httphelpers.RecordingHandler(ldservices.ServerSideEventsServiceHandler())
113 diagnosticsManager := ldevents.NewDiagnosticsManager(
114 ldevents.NewDiagnosticID("sdk-key"),
115 ldvalue.Null(),
116 ldvalue.Null(),
117 time.Now(),
118 nil,
119 )
120 httphelpers.WithServer(eventsHandler, func(server *httptest.Server) {
121 context := makeTestContextWithBaseURIs(server.URL)
122 context.DiagnosticsManager = diagnosticsManager
123 _, err := SendEvents().
124 Build(context)
125 require.NoError(t, err)
126
127 r := <-requestsCh
128 var jsonData ldvalue.Value
129 _ = json.Unmarshal(r.Body, &jsonData)
130 assert.Equal(t, ldvalue.String("diagnostic-init"), jsonData.GetByKey("kind"))
131 })
132 }
133
134 func TestEventsAllAttributesPrivate(t *testing.T) {
135 eventsHandler, requestsCh := httphelpers.RecordingHandler(ldservices.ServerSideEventsServiceHandler())
136 httphelpers.WithServer(eventsHandler, func(server *httptest.Server) {
137 ep, err := SendEvents().
138 AllAttributesPrivate(true).
139 Build(makeTestContextWithBaseURIs(server.URL))
140 require.NoError(t, err)
141
142 ef := ldevents.NewEventFactory(false, nil)
143 ie := ef.NewIdentifyEventData(ldevents.Context(lduser.NewUserBuilder("user-key").Name("user-name").Build()))
144 ep.RecordIdentifyEvent(ie)
145 ep.Flush()
146
147 r := <-requestsCh
148 var jsonData ldvalue.Value
149 _ = json.Unmarshal(r.Body, &jsonData)
150 assert.Equal(t, 1, jsonData.Count())
151 event := jsonData.GetByIndex(0)
152 m.In(t).Assert(event, m.AllOf(
153 m.JSONProperty("kind").Should(m.Equal("identify")),
154 m.JSONProperty("context").Should(m.AllOf(
155 m.JSONProperty("key").Should(m.Equal("user-key")),
156 m.JSONOptProperty("name").Should(m.BeNil()),
157 m.JSONProperty("_meta").Should(m.JSONProperty("redactedAttributes").Should(m.JSONStrEqual(`["name"]`))),
158 )),
159 ))
160 })
161 }
162
163 func TestEventsCapacity(t *testing.T) {
164 eventsHandler, requestsCh := httphelpers.RecordingHandler(ldservices.ServerSideEventsServiceHandler())
165 httphelpers.WithServer(eventsHandler, func(server *httptest.Server) {
166 ep, err := SendEvents().
167 Capacity(1).
168 Build(makeTestContextWithBaseURIs(server.URL))
169 require.NoError(t, err)
170
171 ef := ldevents.NewEventFactory(false, nil)
172 ie := ef.NewIdentifyEventData(ldevents.Context(lduser.NewUserBuilder("user-key").Name("user-name").Build()))
173 ep.RecordIdentifyEvent(ie)
174 ep.RecordIdentifyEvent(ie)
175 ep.Flush()
176
177 r := <-requestsCh
178 var jsonData ldvalue.Value
179 _ = json.Unmarshal(r.Body, &jsonData)
180 assert.Equal(t, 1, jsonData.Count())
181 })
182 }
183
184 func TestEventsSomeAttributesPrivate(t *testing.T) {
185 eventsHandler, requestsCh := httphelpers.RecordingHandler(ldservices.ServerSideEventsServiceHandler())
186 httphelpers.WithServer(eventsHandler, func(server *httptest.Server) {
187 ep, err := SendEvents().
188 PrivateAttributes("name").
189 Build(makeTestContextWithBaseURIs(server.URL))
190 require.NoError(t, err)
191
192 ef := ldevents.NewEventFactory(false, nil)
193 ie := ef.NewIdentifyEventData(ldevents.Context(lduser.NewUserBuilder("user-key").Email("user-email").Name("user-name").Build()))
194 ep.RecordIdentifyEvent(ie)
195 ep.Flush()
196
197 r := <-requestsCh
198 var jsonData ldvalue.Value
199 _ = json.Unmarshal(r.Body, &jsonData)
200 assert.Equal(t, 1, jsonData.Count())
201 event := jsonData.GetByIndex(0)
202 m.In(t).Assert(event, m.AllOf(
203 m.JSONProperty("kind").Should(m.Equal("identify")),
204 m.JSONProperty("context").Should(m.AllOf(
205 m.JSONProperty("key").Should(m.Equal("user-key")),
206 m.JSONProperty("email").Should(m.Equal("user-email")),
207 m.JSONOptProperty("name").Should(m.BeNil()),
208 m.JSONProperty("_meta").Should(m.JSONProperty("redactedAttributes").Should(m.JSONStrEqual(`["name"]`))),
209 )),
210 ))
211 })
212 }
213
View as plain text