moira

1
package redis
2

3
import (
4
	"testing"
5

6
	"github.com/satori/go.uuid"
7
	. "github.com/smartystreets/goconvey/convey"
8

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

14
func TestLastCheck(t *testing.T) {
15
	logger := test_helpers.GetTestLogger()
16
	dataBase := NewDatabase(logger, config)
17
	dataBase.flush()
18
	defer dataBase.flush()
19

20
	var (
21
		err error
22
	)
23

24
	Convey("LastCheck manipulation", t, func() {
25
		Convey("Test read write delete", func() {
26
			trigger := &triggers[0]
27
			triggerID := trigger.ID
28

29
			err = dataBase.SaveTrigger(trigger.ID, trigger)
30
			So(err, ShouldBeNil)
31

32
			err = dataBase.SetTriggerLastCheck(triggerID, lastCheckTest)
33
			So(err, ShouldBeNil)
34

35
			actual, err := dataBase.GetTriggerLastCheck(triggerID)
36
			So(err, ShouldBeNil)
37
			So(actual, ShouldResemble, lastCheckTest)
38

39
			err = dataBase.RemoveTriggerLastCheck(triggerID)
40
			So(err, ShouldBeNil)
41

42
			actual, err = dataBase.GetTriggerLastCheck(triggerID)
43
			So(err, ShouldResemble, database.ErrNil)
44
			So(actual, ShouldBeNil)
45
		})
46

47
		Convey("Test no lastcheck", func() {
48
			triggerID := uuid.NewV4().String()
49
			actual, err := dataBase.GetTriggerLastCheck(triggerID)
50
			So(err, ShouldBeError)
51
			So(err, ShouldResemble, database.ErrNil)
52
			So(actual, ShouldBeNil)
53
		})
54

55
		Convey("Test set trigger check maintenance", func() {
56
			Convey("While no metrics", func() {
57
				trigger := &triggers[1]
58
				triggerID := trigger.ID
59

60
				err = dataBase.SaveTrigger(trigger.ID, trigger)
61
				So(err, ShouldBeNil)
62

63
				err = dataBase.SetTriggerLastCheck(triggerID, lastCheckWithNoMetrics)
64
				So(err, ShouldBeNil)
65

66
				actual, err := dataBase.GetTriggerLastCheck(triggerID)
67
				So(err, ShouldBeNil)
68
				So(actual, ShouldResemble, lastCheckWithNoMetrics)
69
			})
70

71
			Convey("While no metrics to change", func() {
72
				trigger := &triggers[1]
73
				triggerID := trigger.ID
74

75
				err = dataBase.SaveTrigger(trigger.ID, trigger)
76
				So(err, ShouldBeNil)
77

78
				err = dataBase.SetTriggerLastCheck(triggerID, lastCheckTest)
79
				So(err, ShouldBeNil)
80

81
				actual, err := dataBase.GetTriggerLastCheck(triggerID)
82
				So(err, ShouldBeNil)
83
				So(actual, ShouldResemble, lastCheckTest)
84
			})
85
		})
86

87
		Convey("Test get trigger check ids", func() {
88
			dataBase.flush()
89

90
			okTrigger := &triggers[1]
91
			okTriggerID := okTrigger.ID
92
			err = dataBase.SaveTrigger(okTriggerID, okTrigger)
93
			So(err, ShouldBeNil)
94

95
			badTrigger := &triggers[2]
96
			badTriggerID := badTrigger.ID
97
			err = dataBase.SaveTrigger(badTriggerID, badTrigger)
98
			So(err, ShouldBeNil)
99

100
			err = dataBase.SetTriggerLastCheck(okTriggerID, lastCheckWithNoMetrics)
101
			So(err, ShouldBeNil)
102
			err = dataBase.SetTriggerLastCheck(badTriggerID, lastCheckTest)
103
			So(err, ShouldBeNil)
104

105
			actual, err := dataBase.GetTriggerCheckIDs(make([]string, 0), true)
106
			So(err, ShouldBeNil)
107
			So(actual, ShouldResemble, []string{badTriggerID})
108

109
			actual, err = dataBase.GetTriggerCheckIDs(make([]string, 0), false)
110
			So(err, ShouldBeNil)
111
			So(actual, ShouldResemble, []string{badTriggerID, okTriggerID})
112
		})
113
	})
114
}
115

116
func TestLastCheckErrorConnection(t *testing.T) {
117
	logger := test_helpers.GetTestLogger()
118
	dataBase := NewDatabase(logger, emptyConfig)
119
	dataBase.flush()
120
	defer dataBase.flush()
121

122
	Convey("Should throw error when no connection", t, func() {
123
		actual1, err := dataBase.GetTriggerLastCheck("123")
124
		So(actual1, ShouldBeNil)
125
		So(err, ShouldNotBeNil)
126

127
		err = dataBase.SetTriggerLastCheck("123", lastCheckTest)
128
		So(err, ShouldNotBeNil)
129

130
		err = dataBase.RemoveTriggerLastCheck("123")
131
		So(err, ShouldNotBeNil)
132

133
		actual2, err := dataBase.GetTriggerCheckIDs(make([]string, 0), true)
134
		So(actual2, ShouldResemble, []string(nil))
135
		So(err, ShouldNotBeNil)
136
	})
137
}
138

139
var lastCheckTest = &moira.CheckData{
140
	Score:     6000,
141
	State:     moira.OK,
142
	Timestamp: 1504509981,
143
	Metrics: map[string]*moira.MetricState{
144
		"metric1": {
145
			EventTimestamp: 1504449789,
146
			State:          moira.NODATA,
147
			Suppressed:     false,
148
			Timestamp:      1504509380,
149
		},
150
		"metric2": {
151
			EventTimestamp: 1504449789,
152
			State:          moira.NODATA,
153
			Suppressed:     false,
154
			Timestamp:      1504509380,
155
		},
156
		"metric3": {
157
			EventTimestamp: 1504449789,
158
			State:          moira.NODATA,
159
			Suppressed:     false,
160
			Timestamp:      1504509380,
161
		},
162
		"metric4": {
163
			EventTimestamp: 1504463770,
164
			State:          moira.NODATA,
165
			Suppressed:     false,
166
			Timestamp:      1504509380,
167
		},
168
		"metric5": {
169
			EventTimestamp: 1504463770,
170
			State:          moira.NODATA,
171
			Suppressed:     false,
172
			Timestamp:      1504509380,
173
		},
174
		"metric6": {
175
			EventTimestamp: 1504463770,
176
			State:          moira.OK,
177
			Suppressed:     false,
178
			Timestamp:      1504509380,
179
		},
180
	},
181
}
182

183
var lastCheckWithNoMetrics = &moira.CheckData{
184
	Score:     0,
185
	State:     moira.OK,
186
	Timestamp: 1504509981,
187
	Metrics:   make(map[string]*moira.MetricState),
188
}
189