moira

1
package moira
2

3
import (
4
	"testing"
5

6
	. "github.com/smartystreets/goconvey/convey"
7
)
8

9
func TestIsScheduleAllows(t *testing.T) {
10
	allDaysExcludedSchedule := ScheduleData{
11
		StartOffset: 0,
12
		EndOffset:   1439,
13
		Days: []ScheduleDataDay{
14
			{
15
				Name:    "Mon",
16
				Enabled: false,
17
			},
18
			{
19
				Name:    "Tue",
20
				Enabled: false,
21
			},
22
			{
23
				Name:    "Wed",
24
				Enabled: false,
25
			},
26
			{
27
				Name:    "Thu",
28
				Enabled: false,
29
			},
30
			{
31
				Name:    "Fri",
32
				Enabled: false,
33
			},
34
			{
35
				Name:    "Sat",
36
				Enabled: false,
37
			},
38
			{
39
				Name:    "Sun",
40
				Enabled: false,
41
			},
42
		},
43
	}
44

45
	// 367980 - 01/05/1970 6:13am (UTC) Mon
46
	// 454380 - 01/06/1970 6:13am (UTC) Tue
47

48
	Convey("No schedule", t, func() {
49
		var noSchedule *ScheduleData
50
		So(noSchedule.IsScheduleAllows(367980), ShouldBeTrue)
51
	})
52

53
	Convey("Full schedule", t, func() {
54
		schedule := getDefaultSchedule()
55
		So(schedule.IsScheduleAllows(367980), ShouldBeTrue)
56
	})
57

58
	Convey("Exclude monday", t, func() {
59
		schedule := getDefaultSchedule()
60
		schedule.Days[0].Enabled = false
61
		So(schedule.IsScheduleAllows(367980), ShouldBeFalse)
62
		So(schedule.IsScheduleAllows(367980+86400), ShouldBeTrue)
63
		So(schedule.IsScheduleAllows(367980+86400*2), ShouldBeTrue)
64
	})
65

66
	Convey("Exclude all days", t, func() {
67
		schedule := allDaysExcludedSchedule
68
		So(schedule.IsScheduleAllows(367980), ShouldBeFalse)
69
		So(schedule.IsScheduleAllows(367980+86400), ShouldBeFalse)
70
		So(schedule.IsScheduleAllows(367980+86400*5), ShouldBeFalse)
71
	})
72

73
	Convey("Include only morning", t, func() {
74
		schedule := getDefaultSchedule()
75
		schedule.StartOffset = 60
76
		schedule.EndOffset = 540
77
		So(schedule.IsScheduleAllows(86400+129*60), ShouldBeTrue)  // 2/01/1970 2:09
78
		So(schedule.IsScheduleAllows(86400+239*60), ShouldBeTrue)  // 1/01/1970 3:59
79
		So(schedule.IsScheduleAllows(86400-241*60), ShouldBeFalse) // 1/01/1970 19:58
80
		So(schedule.IsScheduleAllows(86400+541*60), ShouldBeFalse) // 2/01/1970 9:01
81
		So(schedule.IsScheduleAllows(86400-255*60), ShouldBeFalse) // 1/01/1970 19:45
82
	})
83
}
84

85
func TestIsScheduleAllows_Overlapped(t *testing.T) {
86
	Convey("Each day is allowed, 07:00 - 01:00", t, func() {
87
		scheduleData := ScheduleData{
88
			StartOffset: 420,
89
			EndOffset:   60,
90
			Days: []ScheduleDataDay{
91
				{
92
					Name:    "Mon",
93
					Enabled: true,
94
				},
95
				{
96
					Name:    "Tue",
97
					Enabled: true,
98
				},
99
				{
100
					Name:    "Wed",
101
					Enabled: true,
102
				},
103
				{
104
					Name:    "Thu",
105
					Enabled: true,
106
				},
107
				{
108
					Name:    "Fri",
109
					Enabled: true,
110
				},
111
				{
112
					Name:    "Sat",
113
					Enabled: true,
114
				},
115
				{
116
					Name:    "Sun",
117
					Enabled: true,
118
				},
119
			},
120
		}
121

122
		So(scheduleData.IsScheduleAllows(1590429223), ShouldBeTrue)  // 1590429223 - Mon, 25 May 2020, 20:53:43 MSK
123
		So(scheduleData.IsScheduleAllows(1590441515), ShouldBeTrue)  // 1590441515 - Tue, 26 May 2020, 00:18:35 MSK
124
		So(scheduleData.IsScheduleAllows(1590377447), ShouldBeFalse) // 1590377447 - Mon, 25 May 2020, 06:30:47 MSK
125
		So(scheduleData.IsScheduleAllows(1590444047), ShouldBeFalse) // 1590444047 - Tue, 26 May 2020, 01:00:47 MSK
126
	})
127

128
	Convey("Workdays are allowed, 14:00 - 03:00", t, func() {
129
		scheduleData := ScheduleData{
130
			StartOffset: 840,
131
			EndOffset:   180,
132
			Days: []ScheduleDataDay{
133
				{
134
					Name:    "Mon",
135
					Enabled: true,
136
				},
137
				{
138
					Name:    "Tue",
139
					Enabled: true,
140
				},
141
				{
142
					Name:    "Wed",
143
					Enabled: true,
144
				},
145
				{
146
					Name:    "Thu",
147
					Enabled: true,
148
				},
149
				{
150
					Name:    "Fri",
151
					Enabled: true,
152
				},
153
				{
154
					Name:    "Sat",
155
					Enabled: false,
156
				},
157
				{
158
					Name:    "Sun",
159
					Enabled: false,
160
				},
161
			},
162
		}
163

164
		So(scheduleData.IsScheduleAllows(1590144703), ShouldBeFalse) // 1590144703 - Fri, 22 May 2020, 13:51:43 MSK
165
		So(scheduleData.IsScheduleAllows(1590153259), ShouldBeTrue)  // 1590153259 - Fri, 22 May 2020, 16:14:19 MSK
166
		So(scheduleData.IsScheduleAllows(1590176483), ShouldBeTrue)  // 1590176483 - Fri, 22 May 2020, 22:41:23 MSK
167
		So(scheduleData.IsScheduleAllows(1590188282), ShouldBeTrue)  // 1590188282 - Sat, 23 May 2020, 01:58:02 MSK
168
		So(scheduleData.IsScheduleAllows(1590231720), ShouldBeFalse) // 1590231720 - Sat, 23 May 2020, 14:02:00 MSK
169
		So(scheduleData.IsScheduleAllows(1590257764), ShouldBeFalse) // 1590257764 - Sat, 23 May 2020, 21:16:04 MSK
170
		So(scheduleData.IsScheduleAllows(1590276974), ShouldBeFalse) // 1590276974 - Sun, 24 May 2020, 02:36:14 MSK
171
	})
172
}
173

174
func TestEventsData_GetSubjectState(t *testing.T) {
175
	Convey("Get ERROR state", t, func() {
176
		message := "mes1"
177
		var value float64 = 1
178
		states := NotificationEvents{{State: OK}, {State: ERROR, Message: &message, Value: &value}}
179
		So(states.GetSubjectState(), ShouldResemble, ERROR)
180
		So(states[0].String(), ShouldResemble, "TriggerId: , Metric: \nValue: 0, OldValue: 0\nState: OK, OldState: \nMessage: \nTimestamp: 0")
181
		So(states[1].String(), ShouldResemble, "TriggerId: , Metric: \nValue: 1, OldValue: 0\nState: ERROR, OldState: \nMessage: mes1\nTimestamp: 0")
182
	})
183
}
184

185
func TestTriggerData_GetTags(t *testing.T) {
186
	Convey("Test one tag", t, func() {
187
		triggerData := TriggerData{
188
			Tags: []string{"tag1"},
189
		}
190
		So(triggerData.GetTags(), ShouldResemble, "[tag1]")
191
	})
192
	Convey("Test many tags", t, func() {
193
		triggerData := TriggerData{
194
			Tags: []string{"tag1", "tag2", "tag...orNot"},
195
		}
196
		So(triggerData.GetTags(), ShouldResemble, "[tag1][tag2][tag...orNot]")
197
	})
198
	Convey("Test no tags", t, func() {
199
		triggerData := TriggerData{
200
			Tags: make([]string, 0),
201
		}
202
		So(triggerData.GetTags(), ShouldBeEmpty)
203
	})
204
}
205

206
func TestScheduledNotification_GetKey(t *testing.T) {
207
	Convey("Get key", t, func() {
208
		notification := ScheduledNotification{
209
			Contact:   ContactData{Type: "email", Value: "my@mail.com"},
210
			Event:     NotificationEvent{Value: nil, State: NODATA, Metric: "my.metric"},
211
			Timestamp: 123456789,
212
		}
213
		So(notification.GetKey(), ShouldResemble, "email:my@mail.com::my.metric:NODATA:0:0.000000:0:123456789")
214
	})
215
}
216

217
func TestCheckData_GetOrCreateMetricState(t *testing.T) {
218
	Convey("Test no metric", t, func() {
219
		checkData := CheckData{
220
			Metrics: make(map[string]*MetricState),
221
		}
222
		So(
223
			checkData.GetOrCreateMetricState("my.metric", 12343),
224
			ShouldResemble,
225
			&MetricState{State: NODATA, Timestamp: 12343, IsNoData: true},
226
		)
227
	})
228
	Convey("Test has metric", t, func() {
229
		metricState := &MetricState{Timestamp: 11211, IsNoData: true}
230
		checkData := CheckData{
231
			Metrics: map[string]*MetricState{
232
				"my.metric": metricState,
233
			},
234
		}
235
		So(checkData.GetOrCreateMetricState("my.metric", 12343), ShouldResemble, metricState)
236
	})
237
}
238

239
func TestMetricState_GetCheckPoint(t *testing.T) {
240
	Convey("Get check point", t, func() {
241
		metricState := MetricState{Timestamp: 800, EventTimestamp: 700}
242
		So(metricState.GetCheckPoint(120), ShouldEqual, 700)
243

244
		metricState = MetricState{Timestamp: 830, EventTimestamp: 700}
245
		So(metricState.GetCheckPoint(120), ShouldEqual, 710)
246

247
		metricState = MetricState{Timestamp: 699, EventTimestamp: 700}
248
		So(metricState.GetCheckPoint(1), ShouldEqual, 700)
249
	})
250
}
251

252
func TestMetricState_GetEventTimestamp(t *testing.T) {
253
	Convey("Get event timestamp", t, func() {
254
		metricState := MetricState{Timestamp: 800, EventTimestamp: 0}
255
		So(metricState.GetEventTimestamp(), ShouldEqual, 800)
256

257
		metricState = MetricState{Timestamp: 830, EventTimestamp: 700}
258
		So(metricState.GetEventTimestamp(), ShouldEqual, 700)
259
	})
260
}
261

262
func TestTrigger_IsSimple(t *testing.T) {
263
	Convey("Is Simple", t, func() {
264
		trigger := Trigger{
265
			Patterns: []string{"123"},
266
			Targets:  []string{"123"},
267
		}
268

269
		So(trigger.IsSimple(), ShouldBeTrue)
270
	})
271

272
	Convey("Not simple", t, func() {
273
		triggers := []Trigger{
274
			{Patterns: []string{"123", "1233"}},
275
			{Patterns: []string{"123", "1233"}, Targets: []string{"123", "1233"}},
276
			{Targets: []string{"123", "1233"}},
277
			{Patterns: []string{"123"}, Targets: []string{"123", "1233"}},
278
			{Patterns: []string{"123?"}, Targets: []string{"123"}},
279
			{Patterns: []string{"12*3"}, Targets: []string{"123"}},
280
			{Patterns: []string{"1{23"}, Targets: []string{"123"}},
281
			{Patterns: []string{"[123"}, Targets: []string{"123"}},
282
			{Patterns: []string{"[12*3"}, Targets: []string{"123"}},
283
		}
284

285
		for _, trigger := range triggers {
286
			So(trigger.IsSimple(), ShouldBeFalse)
287
		}
288
	})
289
}
290

291
func TestCheckData_GetEventTimestamp(t *testing.T) {
292
	Convey("Get event timestamp", t, func() {
293
		checkData := CheckData{Timestamp: 800, EventTimestamp: 0}
294
		So(checkData.GetEventTimestamp(), ShouldEqual, 800)
295

296
		checkData = CheckData{Timestamp: 830, EventTimestamp: 700}
297
		So(checkData.GetEventTimestamp(), ShouldEqual, 700)
298
	})
299
}
300

301
func TestCheckData_UpdateScore(t *testing.T) {
302
	Convey("Update score", t, func() {
303
		checkData := CheckData{State: ERROR}
304
		So(checkData.UpdateScore(), ShouldEqual, 100)
305
		So(checkData.Score, ShouldEqual, 100)
306

307
		checkData = CheckData{
308
			State: OK,
309
			Metrics: map[string]*MetricState{
310
				"123": {State: ERROR},
311
				"321": {State: OK},
312
				"345": {State: WARN},
313
			},
314
		}
315
		So(checkData.UpdateScore(), ShouldEqual, 101)
316
		So(checkData.Score, ShouldEqual, 101)
317

318
		checkData = CheckData{
319
			State: ERROR,
320
			Metrics: map[string]*MetricState{
321
				"123": {State: ERROR},
322
				"321": {State: OK},
323
				"345": {State: WARN},
324
			},
325
		}
326
		So(checkData.UpdateScore(), ShouldEqual, 201)
327
		So(checkData.Score, ShouldEqual, 201)
328
	})
329
}
330

331
func getDefaultSchedule() ScheduleData {
332
	return ScheduleData{
333
		StartOffset: 0,
334
		EndOffset:   1439,
335
		Days: []ScheduleDataDay{
336
			{
337
				Name:    "Mon",
338
				Enabled: true,
339
			},
340
			{
341
				Name:    "Tue",
342
				Enabled: true,
343
			},
344
			{
345
				Name:    "Wed",
346
				Enabled: true,
347
			},
348
			{
349
				Name:    "Thu",
350
				Enabled: true,
351
			},
352
			{
353
				Name:    "Fri",
354
				Enabled: true,
355
			},
356
			{
357
				Name:    "Sat",
358
				Enabled: true,
359
			},
360
			{
361
				Name:    "Sun",
362
				Enabled: true,
363
			},
364
		},
365
	}
366
}
367