/
avito.tech
/
moira
GigaCode
beta
ОбзорЦентр заботыВойти

moira

Форк
0
Ветки: 1Коммиты: 6Теги: 0
moira
/api
/controller
/
trigger_test.go 
569 строк · 22.1 Кб
1
package controller
2


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


8
	"github.com/golang/mock/gomock"
9
	"github.com/satori/go.uuid"
10
	. "github.com/smartystreets/goconvey/convey"
11


12
	"go.avito.ru/DO/moira"
13
	"go.avito.ru/DO/moira/api"
14
	"go.avito.ru/DO/moira/api/dto"
15
	"go.avito.ru/DO/moira/database"
16
	"go.avito.ru/DO/moira/mock/moira-alert"
17
)
18


19
func TestUpdateTrigger(t *testing.T) {
20
	mockCtrl := gomock.NewController(t)
21
	defer mockCtrl.Finish()
22


23
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
24


25
	Convey("Success update", t, func() {
26
		triggerModel := dto.TriggerModel{ID: uuid.NewV4().String()}
27
		trigger := triggerModel.ToMoiraTrigger()
28
		dataBase.EXPECT().GetTrigger(triggerModel.ID).Return(trigger, nil)
29
		dataBase.EXPECT().AcquireTriggerCheckLock(gomock.Any())
30
		dataBase.EXPECT().DeleteTriggerCheckLock(gomock.Any())
31
		dataBase.EXPECT().GetOrCreateTriggerLastCheck(gomock.Any()).Return(&moira.CheckData{
32
			Metrics: make(map[string]*moira.MetricState),
33
		}, nil)
34
		dataBase.EXPECT().SaveTrigger(gomock.Any(), trigger).Return(nil)
35
		dataBase.EXPECT().SetTriggerLastCheck(gomock.Any(), gomock.Any()).Return(nil)
36
		resp, err := UpdateTrigger(dataBase, nil, &triggerModel, triggerModel.ID, make(map[string]bool))
37
		So(err, ShouldBeNil)
38
		So(resp.Message, ShouldResemble, "trigger updated")
39
	})
40


41
	Convey("Trigger does not exists", t, func() {
42
		trigger := dto.TriggerModel{ID: uuid.NewV4().String()}
43
		dataBase.EXPECT().GetTrigger(trigger.ID).Return(nil, database.ErrNil)
44
		resp, err := UpdateTrigger(dataBase, nil, &trigger, trigger.ID, make(map[string]bool))
45
		So(err, ShouldResemble, api.ErrorNotFound(fmt.Sprintf("Trigger with ID = '%s' does not exists", trigger.ID)))
46
		So(resp, ShouldBeNil)
47
	})
48


49
	Convey("Get trigger error", t, func() {
50
		trigger := dto.TriggerModel{ID: uuid.NewV4().String()}
51
		expected := fmt.Errorf("Soo bad trigger")
52
		dataBase.EXPECT().GetTrigger(trigger.ID).Return(nil, expected)
53
		resp, err := UpdateTrigger(dataBase, nil, &trigger, trigger.ID, make(map[string]bool))
54
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
55
		So(resp, ShouldBeNil)
56
	})
57
}
58


59
func TestSaveTrigger(t *testing.T) {
60
	mockCtrl := gomock.NewController(t)
61
	defer mockCtrl.Finish()
62


63
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
64
	triggerID := uuid.NewV4().String()
65
	trigger := moira.Trigger{ID: triggerID}
66
	lastCheck := &moira.CheckData{
67
		Metrics: map[string]*moira.MetricState{
68
			"super.metric1": {},
69
			"super.metric2": {},
70
		},
71
	}
72
	emptyLastCheck := &moira.CheckData{
73
		Metrics: make(map[string]*moira.MetricState),
74
	}
75


76
	Convey("No timeSeries", t, func() {
77
		Convey("No last check", func() {
78
			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID)
79
			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
80
			dataBase.EXPECT().GetOrCreateTriggerLastCheck(triggerID).Return(&moira.CheckData{
81
				Metrics: make(map[string]*moira.MetricState),
82
			}, nil)
83
			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
84
			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any()).Return(nil)
85
			resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, make(map[string]bool))
86
			So(err, ShouldBeNil)
87
			So(resp, ShouldResemble, &dto.SaveTriggerResponse{ID: triggerID, Message: "trigger updated"})
88
		})
89
		Convey("Has last check", func() {
90
			actualLastCheck := lastCheck
91
			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID)
92
			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
93
			dataBase.EXPECT().GetOrCreateTriggerLastCheck(triggerID).Return(actualLastCheck, nil)
94
			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
95
			dataBase.EXPECT().SetTriggerLastCheck(triggerID, actualLastCheck).Return(nil)
96
			resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, make(map[string]bool))
97
			So(err, ShouldBeNil)
98
			So(resp, ShouldResemble, &dto.SaveTriggerResponse{ID: triggerID, Message: "trigger updated"})
99
			So(actualLastCheck, ShouldResemble, emptyLastCheck)
100
		})
101
	})
102


103
	Convey("Has timeSeries", t, func() {
104
		actualLastCheck := lastCheck
105
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID)
106
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
107
		dataBase.EXPECT().GetOrCreateTriggerLastCheck(triggerID).Return(&moira.CheckData{
108
			Metrics: make(map[string]*moira.MetricState),
109
		}, nil)
110
		dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(nil)
111
		dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any()).Return(nil)
112
		resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, map[string]bool{"super.metric1": true, "super.metric2": true})
113
		So(err, ShouldBeNil)
114
		So(resp, ShouldResemble, &dto.SaveTriggerResponse{ID: triggerID, Message: "trigger updated"})
115
		So(actualLastCheck, ShouldResemble, lastCheck)
116
	})
117


118
	Convey("Errors", t, func() {
119
		Convey("AcquireTriggerCheckLock error", func() {
120
			expected := fmt.Errorf("AcquireTriggerCheckLock error")
121
			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(expected)
122
			resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, make(map[string]bool))
123
			So(err, ShouldResemble, api.ErrorInternalServer(expected))
124
			So(resp, ShouldBeNil)
125
		})
126


127
		Convey("GetTriggerLastCheck error", func() {
128
			expected := fmt.Errorf("GetTriggerLastCheck error")
129
			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID)
130
			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
131
			dataBase.EXPECT().GetOrCreateTriggerLastCheck(triggerID).Return(nil, expected)
132
			resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, make(map[string]bool))
133
			So(err, ShouldResemble, api.ErrorInternalServer(expected))
134
			So(resp, ShouldBeNil)
135
		})
136


137
		Convey("SetTriggerLastCheck error", func() {
138
			expected := fmt.Errorf("SetTriggerLastCheck error")
139
			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID)
140
			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
141
			dataBase.EXPECT().GetOrCreateTriggerLastCheck(triggerID).Return(&moira.CheckData{
142
				Metrics: make(map[string]*moira.MetricState),
143
			}, nil)
144
			dataBase.EXPECT().SaveTrigger(triggerID, &trigger)
145
			dataBase.EXPECT().SetTriggerLastCheck(triggerID, gomock.Any()).Return(expected)
146
			resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, make(map[string]bool))
147
			So(err, ShouldResemble, api.ErrorInternalServer(expected))
148
			So(resp, ShouldBeNil)
149
		})
150


151
		Convey("saveTrigger error", func() {
152
			expected := fmt.Errorf("saveTrigger error")
153
			dataBase.EXPECT().AcquireTriggerCheckLock(triggerID)
154
			dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
155
			dataBase.EXPECT().GetOrCreateTriggerLastCheck(triggerID).Return(&moira.CheckData{
156
				Metrics: make(map[string]*moira.MetricState),
157
			}, nil)
158
			dataBase.EXPECT().SaveTrigger(triggerID, &trigger).Return(expected)
159
			resp, err := saveTrigger(dataBase, nil, &trigger, triggerID, make(map[string]bool))
160
			So(err, ShouldResemble, api.ErrorInternalServer(expected))
161
			So(resp, ShouldBeNil)
162
		})
163
	})
164
}
165


166
func TestGetTrigger(t *testing.T) {
167
	mockCtrl := gomock.NewController(t)
168
	defer mockCtrl.Finish()
169
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
170
	triggerID := uuid.NewV4().String()
171
	triggerModel := dto.TriggerModel{ID: triggerID}
172
	trigger := triggerModel.ToMoiraTrigger()
173
	begging := time.Unix(0, 0)
174
	now := time.Now()
175
	tomorrow := now.Add(time.Hour * 24)
176
	yesterday := now.Add(-time.Hour * 24)
177


178
	Convey("Has trigger no throttling", t, func() {
179
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
180
		dataBase.EXPECT().GetTriggerThrottling(triggerID).Return(begging, begging)
181
		dataBase.EXPECT().TriggerHasPendingEscalations(triggerID, false).Return(false, nil)
182
		dataBase.EXPECT().GetTriggers(trigger.Parents).Return(nil, nil)
183
		actual, err := GetTrigger(dataBase, triggerID)
184
		So(err, ShouldBeNil)
185
		So(actual, ShouldResemble, &dto.Trigger{
186
			ParentTriggers: make([]*dto.Trigger, 0),
187
			TriggerModel:   triggerModel,
188
			Throttling:     0,
189
		})
190
	})
191


192
	Convey("Has trigger has throttling", t, func() {
193
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
194
		dataBase.EXPECT().GetTriggerThrottling(triggerID).Return(tomorrow, begging)
195
		dataBase.EXPECT().TriggerHasPendingEscalations(triggerID, false).Return(false, nil)
196
		dataBase.EXPECT().GetTriggers(trigger.Parents).Return(nil, nil)
197
		actual, err := GetTrigger(dataBase, triggerID)
198
		So(err, ShouldBeNil)
199
		So(actual, ShouldResemble, &dto.Trigger{
200
			ParentTriggers: make([]*dto.Trigger, 0),
201
			TriggerModel:   triggerModel,
202
			Throttling:     tomorrow.Unix(),
203
		})
204
	})
205


206
	Convey("Has trigger has old throttling", t, func() {
207
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
208
		dataBase.EXPECT().GetTriggerThrottling(triggerID).Return(yesterday, begging)
209
		dataBase.EXPECT().TriggerHasPendingEscalations(triggerID, false).Return(false, nil)
210
		dataBase.EXPECT().GetTriggers(trigger.Parents).Return(nil, nil)
211
		actual, err := GetTrigger(dataBase, triggerID)
212
		So(err, ShouldBeNil)
213
		So(actual, ShouldResemble, &dto.Trigger{
214
			ParentTriggers: make([]*dto.Trigger, 0),
215
			TriggerModel:   triggerModel,
216
			Throttling:     0,
217
		})
218
	})
219


220
	Convey("GetTrigger error", t, func() {
221
		expected := fmt.Errorf("GetTrigger error")
222
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{}, expected)
223
		actual, err := GetTrigger(dataBase, triggerID)
224
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
225
		So(actual, ShouldBeNil)
226
	})
227


228
	Convey("No trigger", t, func() {
229
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{}, database.ErrNil)
230
		actual, err := GetTrigger(dataBase, triggerID)
231
		So(err, ShouldResemble, api.ErrorNotFound("Trigger not found"))
232
		So(actual, ShouldBeNil)
233
	})
234
}
235


236
func TestRemoveTrigger(t *testing.T) {
237
	mockCtrl := gomock.NewController(t)
238
	defer mockCtrl.Finish()
239


240
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
241
	triggerID := uuid.NewV4().String()
242


243
	Convey("Success", t, func() {
244
		dataBase.EXPECT().GetTrigger(triggerID).Return(nil, nil)
245
		dataBase.EXPECT().RemoveTrigger(triggerID).Return(nil)
246
		dataBase.EXPECT().RemoveTriggerLastCheck(triggerID).Return(nil)
247
		err := RemoveTrigger(dataBase, triggerID)
248
		So(err, ShouldBeNil)
249
	})
250


251
	Convey("Error remove trigger", t, func() {
252
		expected := fmt.Errorf("Oooops! Error delete")
253
		dataBase.EXPECT().GetTrigger(triggerID).Return(nil, nil)
254
		dataBase.EXPECT().RemoveTrigger(triggerID).Return(expected)
255
		err := RemoveTrigger(dataBase, triggerID)
256
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
257
	})
258


259
	Convey("Error remove last check", t, func() {
260
		expected := fmt.Errorf("Oooops! Error delete")
261
		dataBase.EXPECT().GetTrigger(triggerID).Return(nil, nil)
262
		dataBase.EXPECT().RemoveTrigger(triggerID).Return(nil)
263
		dataBase.EXPECT().RemoveTriggerLastCheck(triggerID).Return(expected)
264
		err := RemoveTrigger(dataBase, triggerID)
265
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
266
	})
267
}
268


269
func TestGetTriggerThrottling(t *testing.T) {
270
	mockCtrl := gomock.NewController(t)
271
	defer mockCtrl.Finish()
272
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
273
	triggerID := uuid.NewV4().String()
274
	begging := time.Unix(0, 0)
275
	now := time.Now()
276
	tomorrow := now.Add(time.Hour * 24)
277
	yesterday := now.Add(-time.Hour * 24)
278


279
	Convey("no throttling", t, func() {
280
		dataBase.EXPECT().GetTriggerThrottling(triggerID).Return(begging, begging)
281
		actual, err := GetTriggerThrottling(dataBase, triggerID)
282
		So(err, ShouldBeNil)
283
		So(actual, ShouldResemble, &dto.ThrottlingResponse{Throttling: 0})
284
	})
285


286
	Convey("has throttling", t, func() {
287
		dataBase.EXPECT().GetTriggerThrottling(triggerID).Return(tomorrow, begging)
288
		actual, err := GetTriggerThrottling(dataBase, triggerID)
289
		So(err, ShouldBeNil)
290
		So(actual, ShouldResemble, &dto.ThrottlingResponse{Throttling: tomorrow.Unix()})
291
	})
292


293
	Convey("has old throttling", t, func() {
294
		dataBase.EXPECT().GetTriggerThrottling(triggerID).Return(yesterday, begging)
295
		actual, err := GetTriggerThrottling(dataBase, triggerID)
296
		So(err, ShouldBeNil)
297
		So(actual, ShouldResemble, &dto.ThrottlingResponse{Throttling: 0})
298
	})
299
}
300


301
func TestGetTriggerLastCheck(t *testing.T) {
302
	mockCtrl := gomock.NewController(t)
303
	defer mockCtrl.Finish()
304


305
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
306
	triggerID := uuid.NewV4().String()
307
	lastCheck := &moira.CheckData{}
308


309
	Convey("Success", t, func() {
310
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(lastCheck, nil)
311
		dataBase.EXPECT().GetMaintenanceTrigger(triggerID).Return(moira.NewMaintenance(), nil)
312


313
		check, err := GetTriggerLastCheck(dataBase, triggerID)
314
		So(err, ShouldBeNil)
315
		So(check, ShouldResemble, &dto.TriggerCheck{
316
			TriggerID: triggerID,
317
			CheckData: lastCheck,
318
		})
319
	})
320


321
	Convey("Error", t, func() {
322
		expected := fmt.Errorf("Oooops! Error get")
323
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(&moira.CheckData{}, expected)
324
		check, err := GetTriggerLastCheck(dataBase, triggerID)
325
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
326
		So(check, ShouldBeNil)
327
	})
328
}
329


330
func TestDeleteTriggerThrottling(t *testing.T) {
331
	mockCtrl := gomock.NewController(t)
332
	defer mockCtrl.Finish()
333
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
334
	triggerID := uuid.NewV4().String()
335


336
	Convey("Success", t, func() {
337
		dataBase.EXPECT().DeleteTriggerThrottling(triggerID).Return(nil)
338
		var total int64
339
		var to int64 = -1
340
		dataBase.EXPECT().GetNotifications(total, to).Return(make([]*moira.ScheduledNotification, 0), total, nil)
341
		dataBase.EXPECT().AddNotifications(make([]*moira.ScheduledNotification, 0), gomock.Any()).Return(nil)
342
		err := DeleteTriggerThrottling(dataBase, triggerID)
343
		So(err, ShouldBeNil)
344
	})
345


346
	Convey("Error", t, func() {
347
		expected := fmt.Errorf("Oooops! Error delete")
348
		dataBase.EXPECT().DeleteTriggerThrottling(triggerID).Return(expected)
349
		err := DeleteTriggerThrottling(dataBase, triggerID)
350
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
351
	})
352
}
353


354
func TestDeleteTriggerMetric(t *testing.T) {
355
	mockCtrl := gomock.NewController(t)
356
	defer mockCtrl.Finish()
357
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
358
	triggerID := uuid.NewV4().String()
359
	trigger := &moira.Trigger{ID: triggerID}
360
	lastCheck := moira.CheckData{
361
		Metrics: map[string]*moira.MetricState{
362
			"super.metric1": {},
363
		},
364
	}
365
	emptyLastCheck := &moira.CheckData{
366
		Metrics: make(map[string]*moira.MetricState),
367
	}
368


369
	Convey("Success delete from last check", t, func() {
370
		expectedLastCheck := &lastCheck
371
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
372
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(nil)
373
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
374
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
375
		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
376
		dataBase.EXPECT().SetTriggerLastCheck(triggerID, expectedLastCheck)
377
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
378
		So(err, ShouldBeNil)
379
		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
380
	})
381


382
	Convey("Success delete nothing to delete", t, func() {
383
		expectedLastCheck := emptyLastCheck
384
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
385
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(nil)
386
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
387
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(expectedLastCheck, nil)
388
		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
389
		dataBase.EXPECT().SetTriggerLastCheck(triggerID, expectedLastCheck)
390
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
391
		So(err, ShouldBeNil)
392
		So(expectedLastCheck, ShouldResemble, emptyLastCheck)
393
	})
394


395
	Convey("No trigger", t, func() {
396
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{}, database.ErrNil)
397
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
398
		So(err, ShouldResemble, api.ErrorInvalidRequest(fmt.Errorf("Trigger not found")))
399
	})
400


401
	Convey("No last check", t, func() {
402
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
403
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(nil)
404
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
405
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(&moira.CheckData{}, database.ErrNil)
406
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
407
		So(err, ShouldResemble, api.ErrorInvalidRequest(fmt.Errorf("Trigger check not found")))
408
	})
409


410
	Convey("Get trigger error", t, func() {
411
		expected := fmt.Errorf("Get trigger error")
412
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{}, expected)
413
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
414
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
415
	})
416


417
	Convey("AcquireTriggerCheckLock error", t, func() {
418
		expected := fmt.Errorf("Acquire error")
419
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
420
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(expected)
421
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
422
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
423
	})
424


425
	Convey("GetTriggerLastCheck error", t, func() {
426
		expected := fmt.Errorf("Last check error")
427
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
428
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(nil)
429
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
430
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(&moira.CheckData{}, expected)
431
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
432
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
433
	})
434


435
	Convey("RemovePatternsMetrics error", t, func() {
436
		expected := fmt.Errorf("RemovePatternsMetrics err")
437
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
438
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(nil)
439
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
440
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(&lastCheck, nil)
441
		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(expected)
442
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
443
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
444
	})
445


446
	Convey("SetTriggerLastCheck error", t, func() {
447
		expected := fmt.Errorf("RemovePatternsMetrics err")
448
		dataBase.EXPECT().GetTrigger(triggerID).Return(trigger, nil)
449
		dataBase.EXPECT().AcquireTriggerCheckLock(triggerID).Return(nil)
450
		dataBase.EXPECT().DeleteTriggerCheckLock(triggerID)
451
		dataBase.EXPECT().GetTriggerLastCheck(triggerID).Return(&lastCheck, nil)
452
		dataBase.EXPECT().RemovePatternsMetrics(trigger.Patterns).Return(nil)
453
		dataBase.EXPECT().SetTriggerLastCheck(triggerID, &lastCheck).Return(expected)
454
		err := DeleteTriggerMetric(dataBase, "super.metric1", triggerID)
455
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
456
	})
457
}
458


459
func TestSetMetricsMaintenance(t *testing.T) {
460
	mockCtrl := gomock.NewController(t)
461
	defer mockCtrl.Finish()
462


463
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
464
	triggerID := uuid.NewV4().String()
465


466
	maintenance := moira.NewMaintenance()
467
	update := make(map[string]int64)
468


469
	Convey("Success", t, func() {
470
		dataBase.EXPECT().AcquireTriggerMaintenanceLock(triggerID)
471
		dataBase.EXPECT().GetMaintenanceTrigger(triggerID).Return(maintenance, nil)
472
		dataBase.EXPECT().SetMaintenanceTrigger(triggerID, maintenance).Return(nil)
473
		dataBase.EXPECT().DeleteTriggerMaintenanceLock(triggerID)
474


475
		err := SetMetricsMaintenance(dataBase, triggerID, update)
476
		So(err, ShouldBeNil)
477
	})
478


479
	Convey("Error", t, func() {
480
		expected := fmt.Errorf("Oooops! Error set")
481
		dataBase.EXPECT().AcquireTriggerMaintenanceLock(triggerID)
482
		dataBase.EXPECT().GetMaintenanceTrigger(triggerID).Return(maintenance, nil)
483
		dataBase.EXPECT().SetMaintenanceTrigger(triggerID, maintenance).Return(expected)
484
		dataBase.EXPECT().DeleteTriggerMaintenanceLock(triggerID)
485


486
		err := SetMetricsMaintenance(dataBase, triggerID, update)
487
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
488
	})
489
}
490


491
func TestGetTriggerMetrics(t *testing.T) {
492
	mockCtrl := gomock.NewController(t)
493
	defer mockCtrl.Finish()
494


495
	dataBase := mock_moira_alert.NewMockDatabase(mockCtrl)
496
	triggerID := uuid.NewV4().String()
497
	pattern := "super.puper.pattern"
498
	metric := "super.puper.metric"
499
	dataList := map[string][]*moira.MetricValue{
500
		metric: {
501
			{
502
				RetentionTimestamp: 20,
503
				Timestamp:          23,
504
				Value:              0,
505
			},
506
			{
507
				RetentionTimestamp: 30,
508
				Timestamp:          33,
509
				Value:              1,
510
			},
511
			{
512
				RetentionTimestamp: 40,
513
				Timestamp:          43,
514
				Value:              2,
515
			},
516
			{
517
				RetentionTimestamp: 50,
518
				Timestamp:          53,
519
				Value:              3,
520
			},
521
			{
522
				RetentionTimestamp: 60,
523
				Timestamp:          63,
524
				Value:              4,
525
			},
526
		},
527
	}
528


529
	var from int64 = 17
530
	var until int64 = 67
531
	var retention int64 = 10
532


533
	Convey("Has metrics", t, func() {
534
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{ID: triggerID, Targets: []string{pattern}}, nil)
535
		dataBase.EXPECT().GetPatternMetrics(pattern).Return([]string{metric}, nil)
536
		dataBase.EXPECT().GetMetricRetention(metric).Return(retention, nil)
537
		dataBase.EXPECT().GetMetricsValues([]string{metric}, from, until).Return(dataList, nil)
538
		triggerMetrics, err := GetTriggerMetrics(dataBase, from, until, triggerID)
539
		So(err, ShouldBeNil)
540
		So(triggerMetrics, ShouldResemble, dto.TriggerMetrics(map[string][]moira.MetricValue{metric: {{Value: 0, Timestamp: 17}, {Value: 1, Timestamp: 27}, {Value: 2, Timestamp: 37}, {Value: 3, Timestamp: 47}, {Value: 4, Timestamp: 57}}}))
541
	})
542


543
	Convey("GetTrigger error", t, func() {
544
		expected := fmt.Errorf("Get trigger error")
545
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{}, expected)
546
		triggerMetrics, err := GetTriggerMetrics(dataBase, from, until, triggerID)
547
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
548
		So(triggerMetrics, ShouldBeNil)
549
	})
550


551
	Convey("No trigger", t, func() {
552
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{}, database.ErrNil)
553
		triggerMetrics, err := GetTriggerMetrics(dataBase, from, until, triggerID)
554
		So(err, ShouldResemble, api.ErrorInvalidRequest(fmt.Errorf("Trigger not found")))
555
		So(triggerMetrics, ShouldBeNil)
556
	})
557


558
	Convey("GetMetricsValues error", t, func() {
559
		expected := fmt.Errorf("GetMetricsValues error")
560
		dataBase.EXPECT().GetTrigger(triggerID).Return(&moira.Trigger{ID: triggerID, Targets: []string{pattern}}, nil)
561
		dataBase.EXPECT().GetPatternMetrics(pattern).Return([]string{metric}, nil)
562
		dataBase.EXPECT().GetMetricRetention(metric).Return(retention, nil)
563
		dataBase.EXPECT().GetMetricsValues([]string{metric}, from, until).Return(nil, expected)
564
		triggerMetrics, err := GetTriggerMetrics(dataBase, from, until, triggerID)
565
		So(err, ShouldResemble, api.ErrorInternalServer(expected))
566
		So(triggerMetrics, ShouldBeNil)
567
	})
568


569
}
570

Использование cookies

Мы используем файлы cookie в соответствии с Политикой конфиденциальности и Политикой использования cookies.

Нажимая кнопку «Принимаю», Вы даете АО «СберТех» согласие на обработку Ваших персональных данных в целях совершенствования нашего веб-сайта и Сервиса GitVerse, а также повышения удобства их использования.

Запретить использование cookies Вы можете самостоятельно в настройках Вашего браузера.