1 package ldevents
2
3 import (
4 "testing"
5
6 "github.com/launchdarkly/go-sdk-common/v3/ldcontext"
7 "github.com/launchdarkly/go-sdk-common/v3/ldtime"
8 "github.com/launchdarkly/go-sdk-common/v3/ldvalue"
9
10 "github.com/stretchr/testify/assert"
11 )
12
13 func makeEvalEventWithContext(context ldcontext.Context, creationDate ldtime.UnixMillisecondTime, flagKey string,
14 flagVersion ldvalue.OptionalInt, variation ldvalue.OptionalInt, value, defaultValue string) EvaluationData {
15 return EvaluationData{
16 BaseEvent: BaseEvent{CreationDate: creationDate, Context: Context(context)},
17 Key: flagKey,
18 Version: flagVersion,
19 Variation: variation,
20 Value: ldvalue.String(value),
21 Default: ldvalue.String(defaultValue),
22 }
23 }
24
25 func makeEvalEvent(creationDate ldtime.UnixMillisecondTime, flagKey string,
26 flagVersion ldvalue.OptionalInt, variation ldvalue.OptionalInt, value, defaultValue string) EvaluationData {
27 return makeEvalEventWithContext(ldcontext.New("key"),
28 creationDate, flagKey, flagVersion, variation, value, defaultValue)
29 }
30
31 func TestSummarizeEventSetsStartAndEndDates(t *testing.T) {
32 es := newEventSummarizer()
33 flagKey := "key"
34 event1 := makeEvalEvent(2000, flagKey, ldvalue.NewOptionalInt(1), ldvalue.NewOptionalInt(0), "", "")
35 event2 := makeEvalEvent(1000, flagKey, ldvalue.NewOptionalInt(1), ldvalue.NewOptionalInt(0), "", "")
36 event3 := makeEvalEvent(1500, flagKey, ldvalue.NewOptionalInt(1), ldvalue.NewOptionalInt(0), "", "")
37 es.summarizeEvent(event1)
38 es.summarizeEvent(event2)
39 es.summarizeEvent(event3)
40 data := es.snapshot()
41
42 assert.Equal(t, ldtime.UnixMillisecondTime(1000), data.startDate)
43 assert.Equal(t, ldtime.UnixMillisecondTime(2000), data.endDate)
44 }
45
46 func TestSummarizeEventIncrementsCounters(t *testing.T) {
47 es := newEventSummarizer()
48 flagKey1, flagKey2, unknownFlagKey := "key1", "key2", "badkey"
49 flagVersion1, flagVersion2 := ldvalue.NewOptionalInt(11), ldvalue.NewOptionalInt(22)
50 variation1, variation2 := ldvalue.NewOptionalInt(1), ldvalue.NewOptionalInt(2)
51
52 event1 := makeEvalEvent(0, flagKey1, flagVersion1, variation1, "value1", "default1")
53 event2 := makeEvalEvent(0, flagKey1, flagVersion1, variation2, "value2", "default1")
54 event3 := makeEvalEvent(0, flagKey2, flagVersion2, variation1, "value99", "default2")
55 event4 := makeEvalEvent(0, flagKey1, flagVersion1, variation1, "value1", "default1")
56 event5 := makeEvalEvent(0, unknownFlagKey, undefInt, undefInt, "default3", "default3")
57 for _, e := range []EvaluationData{event1, event2, event3, event4, event5} {
58 es.summarizeEvent(e)
59 }
60 data := es.snapshot()
61
62 expectedFlags := map[string]flagSummary{
63 flagKey1: {
64 defaultValue: ldvalue.String("default1"),
65 contextKinds: map[ldcontext.Kind]struct{}{ldcontext.DefaultKind: {}},
66 counters: map[counterKey]*counterValue{
67 {variation1, flagVersion1}: {2, ldvalue.String("value1")},
68 {variation2, flagVersion1}: {1, ldvalue.String("value2")},
69 },
70 },
71 flagKey2: {
72 defaultValue: ldvalue.String("default2"),
73 contextKinds: map[ldcontext.Kind]struct{}{ldcontext.DefaultKind: {}},
74 counters: map[counterKey]*counterValue{
75 {variation1, flagVersion2}: {1, ldvalue.String("value99")},
76 },
77 },
78 unknownFlagKey: {
79 defaultValue: ldvalue.String("default3"),
80 contextKinds: map[ldcontext.Kind]struct{}{ldcontext.DefaultKind: {}},
81 counters: map[counterKey]*counterValue{
82 {undefInt, undefInt}: {1, ldvalue.String("default3")},
83 },
84 },
85 }
86 assert.Equal(t, expectedFlags, data.flags)
87 }
88
89 func TestCounterForNilVariationIsDistinctFromOthers(t *testing.T) {
90 es := newEventSummarizer()
91 flagKey := "key1"
92 flagVersion := ldvalue.NewOptionalInt(11)
93 variation1, variation2 := ldvalue.NewOptionalInt(1), ldvalue.NewOptionalInt(2)
94 event1 := makeEvalEvent(0, flagKey, flagVersion, variation1, "value1", "default1")
95 event2 := makeEvalEvent(0, flagKey, flagVersion, variation2, "value2", "default1")
96 event3 := makeEvalEvent(0, flagKey, flagVersion, undefInt, "default1", "default1")
97 for _, e := range []EvaluationData{event1, event2, event3} {
98 es.summarizeEvent(e)
99 }
100 data := es.snapshot()
101
102 expectedFlags := map[string]flagSummary{
103 flagKey: {
104 defaultValue: ldvalue.String("default1"),
105 contextKinds: map[ldcontext.Kind]struct{}{ldcontext.DefaultKind: {}},
106 counters: map[counterKey]*counterValue{
107 {variation1, flagVersion}: {1, ldvalue.String("value1")},
108 {variation2, flagVersion}: {1, ldvalue.String("value2")},
109 {undefInt, flagVersion}: {1, ldvalue.String("default1")},
110 },
111 },
112 }
113 assert.Equal(t, expectedFlags, data.flags)
114 }
115
116 func TestSummaryContextKindsAreTrackedPerFlag(t *testing.T) {
117 es := newEventSummarizer()
118 flagKey1, flagKey2 := "key1", "key2"
119 flagVersion1, flagVersion2 := ldvalue.NewOptionalInt(11), ldvalue.NewOptionalInt(22)
120 variation1, variation2 := ldvalue.NewOptionalInt(1), ldvalue.NewOptionalInt(2)
121 context1, context2, context3 := ldcontext.New("userkey1"), ldcontext.New("userkey2"), ldcontext.NewWithKind("org", "orgkey")
122
123 event1 := makeEvalEventWithContext(context1, 0, flagKey1, flagVersion1, variation1, "value1", "default1")
124 event2 := makeEvalEventWithContext(context2, 0, flagKey1, flagVersion1, variation2, "value2", "default1")
125 event3 := makeEvalEventWithContext(context2, 0, flagKey2, flagVersion2, variation1, "value99", "default2")
126 event4 := makeEvalEventWithContext(context3, 0, flagKey1, flagVersion1, variation1, "value1", "default1")
127 for _, e := range []EvaluationData{event1, event2, event3, event4} {
128 es.summarizeEvent(e)
129 }
130 data := es.snapshot()
131
132 expectedFlags := map[string]flagSummary{
133 flagKey1: {
134 defaultValue: ldvalue.String("default1"),
135 contextKinds: map[ldcontext.Kind]struct{}{ldcontext.DefaultKind: {}, "org": {}},
136 counters: map[counterKey]*counterValue{
137 {variation1, flagVersion1}: {2, ldvalue.String("value1")},
138 {variation2, flagVersion1}: {1, ldvalue.String("value2")},
139 },
140 },
141 flagKey2: {
142 defaultValue: ldvalue.String("default2"),
143 contextKinds: map[ldcontext.Kind]struct{}{ldcontext.DefaultKind: {}},
144 counters: map[counterKey]*counterValue{
145 {variation1, flagVersion2}: {1, ldvalue.String("value99")},
146 },
147 },
148 }
149 assert.Equal(t, expectedFlags, data.flags)
150 }
151
View as plain text