moira

1
package expression
2

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

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

10
type getExpressionValuesTest struct {
11
	values        TriggerExpression
12
	name          string
13
	expectedError error
14
	expectedValue interface{}
15
}
16

17
func TestExpression(t *testing.T) {
18
	Convey("Test Default", t, func() {
19
		warnValue := 60.0
20
		errorValue := 90.0
21
		result, err := (&TriggerExpression{MainTargetValue: 10.0, WarnValue: &warnValue, ErrorValue: &errorValue}).Evaluate()
22
		So(err, ShouldBeNil)
23
		So(result, ShouldResemble, "OK")
24

25
		result, err = (&TriggerExpression{MainTargetValue: 60.0, WarnValue: &warnValue, ErrorValue: &errorValue}).Evaluate()
26
		So(err, ShouldBeNil)
27
		So(result, ShouldResemble, "WARN")
28

29
		result, err = (&TriggerExpression{MainTargetValue: 90.0, WarnValue: &warnValue, ErrorValue: &errorValue}).Evaluate()
30
		So(err, ShouldBeNil)
31
		So(result, ShouldResemble, "ERROR")
32

33
		warnValue = 30.0
34
		errorValue = 10.0
35
		result, err = (&TriggerExpression{MainTargetValue: 40.0, WarnValue: &warnValue, ErrorValue: &errorValue}).Evaluate()
36
		So(err, ShouldBeNil)
37
		So(result, ShouldResemble, "OK")
38

39
		result, err = (&TriggerExpression{MainTargetValue: 20.0, WarnValue: &warnValue, ErrorValue: &errorValue}).Evaluate()
40
		So(err, ShouldBeNil)
41
		So(result, ShouldResemble, "WARN")
42

43
		result, err = (&TriggerExpression{MainTargetValue: 10.0, WarnValue: &warnValue, ErrorValue: &errorValue}).Evaluate()
44
		So(err, ShouldBeNil)
45
		So(result, ShouldResemble, "ERROR")
46

47
		result, err = (&TriggerExpression{MainTargetValue: 10.0, WarnValue: &warnValue}).Evaluate()
48
		So(err, ShouldResemble, ErrInvalidExpression{fmt.Errorf("Error value and Warning value can not be empty")})
49
		So(err.Error(), ShouldResemble, "Error value and Warning value can not be empty")
50
		So(result, ShouldBeEmpty)
51
	})
52

53
	Convey("Test Custom", t, func() {
54
		expression := "t1 > 10 && t2 > 3 ? ERROR : OK"
55
		result, err := (&TriggerExpression{Expression: &expression, MainTargetValue: 11.0, AdditionalTargetsValues: map[string]float64{"t2": 4.0}}).Evaluate()
56
		So(err, ShouldBeNil)
57
		So(result, ShouldResemble, "ERROR")
58

59
		expression = "min(t1, t2) > 10 ? ERROR : OK"
60
		result, err = (&TriggerExpression{Expression: &expression, MainTargetValue: 11.0, AdditionalTargetsValues: map[string]float64{"t2": 4.0}}).Evaluate()
61
		So(err, ShouldResemble, ErrInvalidExpression{fmt.Errorf("Functions is forbidden")})
62
		So(result, ShouldBeEmpty)
63
	})
64
}
65

66
func TestGetExpressionValue(t *testing.T) {
67
	floatVal := 10.0
68
	Convey("Test basic strings", t, func() {
69
		getExpressionValuesTests := []getExpressionValuesTest{
70
			{
71
				name:          "OK",
72
				expectedValue: "OK",
73
			},
74
			{
75
				name:          "WARN",
76
				expectedValue: "WARN",
77
			},
78
			{
79
				name:          "WARNING",
80
				expectedValue: "WARN",
81
			},
82
			{
83
				name:          "ERROR",
84
				expectedValue: "ERROR",
85
			},
86
			{
87
				name:          "NODATA",
88
				expectedValue: "NODATA",
89
			},
90
		}
91
		runGetExpressionValuesTest(getExpressionValuesTests)
92
	})
93

94
	Convey("Test no errors", t, func() {
95
		{
96
			getExpressionValuesTests := []getExpressionValuesTest{
97
				{
98
					values:        TriggerExpression{WarnValue: &floatVal},
99
					name:          "WARN_VALUE",
100
					expectedValue: floatVal,
101
				},
102
				{
103
					values:        TriggerExpression{ErrorValue: &floatVal},
104
					name:          "ERROR_VALUE",
105
					expectedValue: floatVal,
106
				},
107
				{
108
					values:        TriggerExpression{MainTargetValue: 11.0},
109
					name:          "t1",
110
					expectedValue: 11.0,
111
				},
112
				{
113
					values:        TriggerExpression{AdditionalTargetsValues: map[string]float64{"t2": 1.0}},
114
					name:          "t2",
115
					expectedValue: 1.0,
116
				},
117
				{
118
					values:        TriggerExpression{AdditionalTargetsValues: map[string]float64{"t3": 4.0, "t2": 6.0}},
119
					name:          "t3",
120
					expectedValue: 4.0,
121
				},
122
				{
123
					values:        TriggerExpression{PreviousState: "NODATA"},
124
					name:          "PREV_STATE",
125
					expectedValue: "NODATA",
126
				},
127
			}
128
			runGetExpressionValuesTest(getExpressionValuesTests)
129
		}
130
	})
131

132
	Convey("Test errors", t, func() {
133
		{
134
			getExpressionValuesTests := []getExpressionValuesTest{
135
				{
136
					name:          "WARN_VALUE",
137
					expectedValue: nil,
138
					expectedError: fmt.Errorf("No value with name WARN_VALUE"),
139
				},
140
				{
141
					name:          "ERROR_VALUE",
142
					expectedValue: nil,
143
					expectedError: fmt.Errorf("No value with name ERROR_VALUE"),
144
				},
145
				{
146
					values:        TriggerExpression{AdditionalTargetsValues: map[string]float64{"t3": 4.0, "t2": 6.0}},
147
					name:          "t4",
148
					expectedValue: nil,
149
					expectedError: fmt.Errorf("No value with name t4"),
150
				},
151
			}
152
			runGetExpressionValuesTest(getExpressionValuesTests)
153
		}
154
	})
155
}
156

157
func runGetExpressionValuesTest(getExpressionValuesTests []getExpressionValuesTest) {
158
	for _, getExpressionValuesTest := range getExpressionValuesTests {
159
		result, err := getExpressionValuesTest.values.Get(getExpressionValuesTest.name)
160
		So(err, ShouldResemble, getExpressionValuesTest.expectedError)
161
		So(result, ShouldResemble, getExpressionValuesTest.expectedValue)
162
	}
163
}
164