moira

1
package redis
2

3
import (
4
	"sort"
5
	"testing"
6
	"time"
7

8
	. "github.com/smartystreets/goconvey/convey"
9

10
	"go.avito.ru/DO/moira"
11
	"go.avito.ru/DO/moira/database"
12
	"go.avito.ru/DO/moira/test-helpers"
13
)
14

15
func StringSetShouldResemble(actual interface{}, expected ...interface{}) string {
16
	sortedActual := append([]string{}, actual.([]string)...)
17
	sort.Strings(sortedActual)
18
	sortedExpected := append([]string{}, expected[0].([]string)...)
19
	sort.Strings(sortedExpected)
20
	return ShouldResemble(sortedActual, sortedExpected)
21
}
22

23
func TestTriggerStoring(t *testing.T) {
24
	logger := test_helpers.GetTestLogger()
25
	dataBase := NewDatabase(logger, config)
26
	dataBase.flush()
27
	defer dataBase.flush()
28

29
	Convey("Trigger manipulation", t, func() {
30
		Convey("Test save-get-remove", func() {
31
			trigger := &triggers[0]
32

33
			//Check for not existing not writen trigger
34
			actual, err := dataBase.GetTrigger(trigger.ID)
35
			So(err, ShouldResemble, database.ErrNil)
36
			So(actual, ShouldBeNil)
37

38
			err = dataBase.RemoveTrigger(trigger.ID)
39
			So(err, ShouldBeNil)
40

41
			//Now write it
42
			err = dataBase.SaveTrigger(trigger.ID, trigger)
43
			So(err, ShouldBeNil)
44

45
			//And check for existing by several pointers like id or tag
46
			actual, err = dataBase.GetTrigger(trigger.ID)
47
			So(err, ShouldBeNil)
48
			So(actual, ShouldResemble, trigger)
49

50
			ids, err := dataBase.GetTriggerIDs(false)
51
			So(err, ShouldBeNil)
52
			So(ids, ShouldResemble, []string{trigger.ID})
53

54
			ids, err = dataBase.GetTagTriggerIDs(trigger.Tags[0])
55
			So(err, ShouldBeNil)
56
			So(ids, ShouldResemble, []string{trigger.ID})
57

58
			ids, err = dataBase.GetPatternTriggerIDs(trigger.Patterns[0])
59
			So(err, ShouldBeNil)
60
			So(ids, ShouldResemble, []string{trigger.ID})
61

62
			actualTriggers, err := dataBase.GetTriggers(ids)
63
			So(err, ShouldBeNil)
64
			So(actualTriggers, ShouldResemble, []*moira.Trigger{trigger})
65

66
			//Also we write new patterns
67
			actualPatterns, err := dataBase.GetPatterns()
68
			So(err, ShouldBeNil)
69
			So(actualPatterns, ShouldResemble, trigger.Patterns)
70

71
			//And tags
72
			actualTags, err := dataBase.GetTagNames()
73
			So(err, ShouldBeNil)
74
			So(actualTags, ShouldResemble, trigger.Tags)
75

76
			//Now just add tag and pattern in trigger and save it
77
			trigger = nil
78
			changedTrigger := &triggers[1]
79
			err = dataBase.SaveTrigger(changedTrigger.ID, changedTrigger)
80
			So(err, ShouldBeNil)
81

82
			actual, err = dataBase.GetTrigger(changedTrigger.ID)
83
			So(err, ShouldBeNil)
84
			So(actual.Name, ShouldResemble, changedTrigger.Name)
85

86
			//Now we can get this trigger by two tags
87
			ids, err = dataBase.GetTagTriggerIDs(changedTrigger.Tags[0])
88
			So(err, ShouldBeNil)
89
			So(ids, StringSetShouldResemble, []string{changedTrigger.ID})
90

91
			ids, err = dataBase.GetTagTriggerIDs(changedTrigger.Tags[1])
92
			So(err, ShouldBeNil)
93
			So(ids, StringSetShouldResemble, []string{triggers[0].ID, changedTrigger.ID})
94

95
			//And we have new tag in tags list
96
			actualTags, err = dataBase.GetTagNames()
97
			So(err, ShouldBeNil)
98
			So(actualTags, ShouldHaveLength, 2)
99

100
			//Also we can get this trigger by new pattern
101
			ids, err = dataBase.GetPatternTriggerIDs(changedTrigger.Patterns[0])
102
			So(err, ShouldBeNil)
103
			So(ids, StringSetShouldResemble, []string{changedTrigger.ID})
104

105
			ids, err = dataBase.GetPatternTriggerIDs(changedTrigger.Patterns[1])
106
			So(err, ShouldBeNil)
107
			So(ids, StringSetShouldResemble, []string{triggers[0].ID, changedTrigger.ID})
108

109
			//And we have new pattern in patterns list
110
			actualPatterns, err = dataBase.GetPatterns()
111
			So(err, ShouldBeNil)
112
			So(actualPatterns, ShouldHaveLength, 2)
113

114
			//Now remove old tag and pattern in trigger and save it
115
			changedAgainTrigger := &triggers[2]
116
			err = dataBase.SaveTrigger(changedAgainTrigger.ID, changedAgainTrigger)
117
			So(err, ShouldBeNil)
118

119
			actual, err = dataBase.GetTrigger(changedAgainTrigger.ID)
120
			So(err, ShouldBeNil)
121
			So(actual.Name, ShouldResemble, changedAgainTrigger.Name)
122

123
			ids, err = dataBase.GetTagTriggerIDs(changedAgainTrigger.Tags[0])
124
			So(err, ShouldBeNil)
125
			So(ids, StringSetShouldResemble, []string{changedAgainTrigger.ID, changedTrigger.ID})
126

127
			ids, err = dataBase.GetTagTriggerIDs(changedAgainTrigger.Tags[1])
128
			So(err, ShouldBeNil)
129
			So(ids, StringSetShouldResemble, []string{changedAgainTrigger.ID})
130

131
			//But we still has this tag in tags list with new one
132
			actualTags, err = dataBase.GetTagNames()
133
			So(err, ShouldBeNil)
134
			So(actualTags, ShouldHaveLength, 3)
135

136
			ids, err = dataBase.GetPatternTriggerIDs(changedAgainTrigger.Patterns[0])
137
			So(err, ShouldBeNil)
138
			So(ids, StringSetShouldResemble, []string{changedAgainTrigger.ID})
139

140
			ids, err = dataBase.GetPatternTriggerIDs(changedAgainTrigger.Patterns[1])
141
			So(err, ShouldBeNil)
142
			So(ids, StringSetShouldResemble, []string{changedAgainTrigger.ID, changedTrigger.ID})
143

144
			//But this pattern no more in pattern list, it is not needed
145
			actualTags, err = dataBase.GetPatterns()
146
			So(err, ShouldBeNil)
147
			So(actualTags, ShouldHaveLength, 3)
148

149
			//Stop it!! Remove trigger and check for no existing it by pointers
150
			err = dataBase.RemoveTrigger(changedAgainTrigger.ID)
151
			So(err, ShouldBeNil)
152

153
			//And check for existing by several pointers like id or tag
154
			actual, err = dataBase.GetTrigger(changedAgainTrigger.ID)
155
			So(err, ShouldResemble, database.ErrNil)
156
			So(actual, ShouldBeNil)
157

158
			ids, err = dataBase.GetTagTriggerIDs(changedAgainTrigger.Tags[1])
159
			So(err, ShouldBeNil)
160
			So(ids, ShouldBeEmpty)
161

162
			ids, err = dataBase.GetPatternTriggerIDs(changedAgainTrigger.Patterns[0])
163
			So(err, ShouldBeNil)
164
			So(ids, ShouldBeEmpty)
165

166
			actualTriggers, err = dataBase.GetTriggers([]string{changedAgainTrigger.ID})
167
			So(err, ShouldBeNil)
168
			So(actualTriggers, ShouldResemble, []*moira.Trigger{nil})
169

170
			//But has all tags
171
			actualTags, err = dataBase.GetTagNames()
172
			So(err, ShouldBeNil)
173
			So(actualTags, ShouldHaveLength, 3)
174
		})
175

176
		Convey("Save trigger with lastCheck and throttling and GetTriggerChecks", func() {
177
			trigger := triggers[5]
178
			triggerCheck := &moira.TriggerCheck{
179
				Trigger: trigger,
180
			}
181

182
			err := dataBase.SaveTrigger(trigger.ID, &trigger)
183
			So(err, ShouldBeNil)
184

185
			actual, err := dataBase.GetTrigger(trigger.ID)
186
			So(err, ShouldBeNil)
187
			So(actual, ShouldResemble, &trigger)
188

189
			actualTriggerChecks, err := dataBase.GetTriggerChecks([]string{trigger.ID})
190
			So(err, ShouldBeNil)
191
			So(actualTriggerChecks, ShouldResemble, []*moira.TriggerCheck{triggerCheck})
192

193
			//Add check data
194
			err = dataBase.SetTriggerLastCheck(trigger.ID, lastCheckTest)
195
			So(err, ShouldBeNil)
196

197
			triggerCheck.LastCheck = lastCheckTest
198
			actualTriggerChecks, err = dataBase.GetTriggerChecks([]string{trigger.ID})
199
			So(err, ShouldBeNil)
200
			So(actualTriggerChecks, ShouldResemble, []*moira.TriggerCheck{triggerCheck})
201

202
			//And throttling
203
			err = dataBase.SetTriggerThrottling(trigger.ID, time.Now().Add(-time.Minute))
204
			So(err, ShouldBeNil)
205

206
			//But it is foul
207
			actualTriggerChecks, err = dataBase.GetTriggerChecks([]string{trigger.ID})
208
			So(err, ShouldBeNil)
209
			So(actualTriggerChecks, ShouldResemble, []*moira.TriggerCheck{triggerCheck})
210

211
			//Now good throttling
212
			th := time.Now().Add(time.Minute)
213
			err = dataBase.SetTriggerThrottling(trigger.ID, th)
214
			So(err, ShouldBeNil)
215

216
			triggerCheck.Throttling = th.Unix()
217
			actualTriggerChecks, err = dataBase.GetTriggerChecks([]string{trigger.ID})
218
			So(err, ShouldBeNil)
219
			So(actualTriggerChecks, ShouldResemble, []*moira.TriggerCheck{triggerCheck})
220

221
			//Remove throttling
222
			err = dataBase.DeleteTriggerThrottling(trigger.ID)
223
			So(err, ShouldBeNil)
224

225
			triggerCheck.Throttling = 0
226
			actualTriggerChecks, err = dataBase.GetTriggerChecks([]string{trigger.ID})
227
			So(err, ShouldBeNil)
228
			So(actualTriggerChecks, ShouldResemble, []*moira.TriggerCheck{triggerCheck})
229

230
			//Can not remove check data, but can remove trigger!
231
			err = dataBase.RemoveTrigger(trigger.ID)
232
			So(err, ShouldBeNil)
233

234
			actualTriggerChecks, err = dataBase.GetTriggerChecks([]string{trigger.ID})
235
			So(err, ShouldBeNil)
236
			So(actualTriggerChecks, ShouldResemble, []*moira.TriggerCheck{nil})
237
		})
238
	})
239
}
240

241
func TestTriggerErrorConnection(t *testing.T) {
242
	logger := test_helpers.GetTestLogger()
243
	dataBase := NewDatabase(logger, emptyConfig)
244
	dataBase.flush()
245
	defer dataBase.flush()
246
	Convey("Should throw error when no connection", t, func() {
247
		actual, err := dataBase.GetTriggerIDs(false)
248
		So(err, ShouldNotBeNil)
249
		So(actual, ShouldBeNil)
250

251
		actual1, err := dataBase.GetTrigger("")
252
		So(err, ShouldNotBeNil)
253
		So(actual1, ShouldBeNil)
254

255
		actual2, err := dataBase.GetTriggers([]string{})
256
		So(err, ShouldNotBeNil)
257
		So(actual2, ShouldBeNil)
258

259
		actual3, err := dataBase.GetTriggerChecks([]string{})
260
		So(err, ShouldNotBeNil)
261
		So(actual3, ShouldBeNil)
262

263
		err = dataBase.SaveTrigger("", &triggers[0])
264
		So(err, ShouldNotBeNil)
265

266
		err = dataBase.RemoveTrigger("")
267
		So(err, ShouldNotBeNil)
268

269
		actual4, err := dataBase.GetPatternTriggerIDs("")
270
		So(err, ShouldNotBeNil)
271
		So(actual4, ShouldBeNil)
272

273
		err = dataBase.RemovePatternTriggerIDs("")
274
		So(err, ShouldNotBeNil)
275
	})
276
}
277

278
var triggers = []moira.Trigger{
279
	{
280
		ID:       "triggerID-0000000000001",
281
		Name:     "test trigger 1 v1.0",
282
		Targets:  []string{"test.target.1"},
283
		Tags:     []string{"test-tag-1"},
284
		Patterns: []string{"test.pattern.1"},
285
	},
286
	{
287
		ID:       "triggerID-0000000000002",
288
		Name:     "test trigger 1 v2.0",
289
		Targets:  []string{"test.target.1", "test.target.2"},
290
		Tags:     []string{"test-tag-2", "test-tag-1"},
291
		Patterns: []string{"test.pattern.2", "test.pattern.1"},
292
	},
293
	{
294
		ID:       "triggerID-0000000000003",
295
		Name:     "test trigger 1 v3.0",
296
		Targets:  []string{"test.target.3"},
297
		Tags:     []string{"test-tag-2", "test-tag-3"},
298
		Patterns: []string{"test.pattern.3", "test.pattern.2"},
299
	},
300
	{
301
		ID:      "triggerID-0000000000004",
302
		Name:    "test trigger 4",
303
		Targets: []string{"test.target.4"},
304
		Tags:    []string{"test-tag-4"},
305
	},
306
	{
307
		ID:      "triggerID-0000000000005",
308
		Name:    "test trigger 5 (nobody is subscribed)",
309
		Targets: []string{"test.target.5"},
310
		Tags:    []string{"test-tag-nosub"},
311
	},
312
	{
313
		ID:      "triggerID-0000000000006",
314
		Name:    "test trigger 6 (throttling disabled)",
315
		Targets: []string{"test.target.6"},
316
		Tags:    []string{"test-tag-throttling-disabled"},
317
	},
318
	{
319
		ID:      "triggerID-0000000000007",
320
		Name:    "test trigger 7 (multiple subscribers)",
321
		Targets: []string{"test.target.7"},
322
		Tags:    []string{"test-tag-multiple-subs"},
323
	},
324
	{
325
		ID:      "triggerID-0000000000008",
326
		Name:    "test trigger 8 (duplicated contacts)",
327
		Targets: []string{"test.target.8"},
328
		Tags:    []string{"test-tag-dup-contacts"},
329
	},
330
	{
331
		ID:      "triggerID-0000000000009",
332
		Name:    "test trigger 9 (pseudo tag)",
333
		Targets: []string{"test.target.9"},
334
		Tags:    []string{"test-degradation"},
335
	},
336
}
337