From 26274527df8cf427deff90254aab7ee493cda076 Mon Sep 17 00:00:00 2001 From: Levi Harrison Date: Sun, 30 May 2021 23:35:41 -0400 Subject: [PATCH] Updated/added tests Signed-off-by: Levi Harrison --- rules/alerting_test.go | 104 +++++++++++++++++++++++++++++++++++++++-- rules/manager_test.go | 38 +++++++-------- 2 files changed, 120 insertions(+), 22 deletions(-) diff --git a/rules/alerting_test.go b/rules/alerting_test.go index c759deb65..f97f5718e 100644 --- a/rules/alerting_test.go +++ b/rules/alerting_test.go @@ -32,7 +32,7 @@ import ( func TestAlertingRuleHTMLSnippet(t *testing.T) { expr, err := parser.ParseExpr(`foo{html="BOLD"}`) require.NoError(t, err) - rule := NewAlertingRule("testrule", expr, 0, labels.FromStrings("html", "BOLD"), labels.FromStrings("html", "BOLD"), nil, false, nil) + rule := NewAlertingRule("testrule", expr, 0, labels.FromStrings("html", "BOLD"), labels.FromStrings("html", "BOLD"), nil, "", false, nil) const want = template.HTML(`alert: testrule expr: foo{html="<b>BOLD<b>"} @@ -79,7 +79,7 @@ func TestAlertingRuleState(t *testing.T) { } for i, test := range tests { - rule := NewAlertingRule(test.name, nil, 0, nil, nil, nil, true, nil) + rule := NewAlertingRule(test.name, nil, 0, nil, nil, nil, "", true, nil) rule.active = test.active got := rule.State() require.Equal(t, test.want, got, "test case %d unexpected AlertState, want:%d got:%d", i, test.want, got) @@ -107,7 +107,7 @@ func TestAlertingRuleLabelsUpdate(t *testing.T) { // If an alert is going back and forth between two label values it will never fire. // Instead, you should write two alerts with constant labels. labels.FromStrings("severity", "{{ if lt $value 80.0 }}critical{{ else }}warning{{ end }}"), - nil, nil, true, nil, + nil, nil, "", true, nil, ) results := []promql.Vector{ @@ -208,6 +208,7 @@ func TestAlertingRuleExternalLabelsInTemplate(t *testing.T) { labels.FromStrings("templated_label", "There are {{ len $externalLabels }} external Labels, of which foo is {{ $externalLabels.foo }}."), nil, nil, + "", true, log.NewNopLogger(), ) ruleWithExternalLabels := NewAlertingRule( @@ -217,6 +218,7 @@ func TestAlertingRuleExternalLabelsInTemplate(t *testing.T) { labels.FromStrings("templated_label", "There are {{ len $externalLabels }} external Labels, of which foo is {{ $externalLabels.foo }}."), nil, labels.FromStrings("foo", "bar", "dings", "bums"), + "", true, log.NewNopLogger(), ) result := promql.Vector{ @@ -280,6 +282,100 @@ func TestAlertingRuleExternalLabelsInTemplate(t *testing.T) { require.Equal(t, result, filteredRes) } +func TestAlertingRuleExternalURLInTemplate(t *testing.T) { + suite, err := promql.NewTest(t, ` + load 1m + http_requests{job="app-server", instance="0"} 75 85 70 70 + `) + require.NoError(t, err) + defer suite.Close() + + require.NoError(t, suite.Run()) + + expr, err := parser.ParseExpr(`http_requests < 100`) + require.NoError(t, err) + + ruleWithoutExternalURL := NewAlertingRule( + "ExternalURLDoesNotExist", + expr, + time.Minute, + labels.FromStrings("templated_label", "The external URL is {{ $externalURL }}."), + nil, + nil, + "", + true, log.NewNopLogger(), + ) + ruleWithExternalURL := NewAlertingRule( + "ExternalURLExists", + expr, + time.Minute, + labels.FromStrings("templated_label", "The external URL is {{ $externalURL }}."), + nil, + nil, + "http://localhost:1234", + true, log.NewNopLogger(), + ) + result := promql.Vector{ + { + Metric: labels.FromStrings( + "__name__", "ALERTS", + "alertname", "ExternalURLDoesNotExist", + "alertstate", "pending", + "instance", "0", + "job", "app-server", + "templated_label", "The external URL is .", + ), + Point: promql.Point{V: 1}, + }, + { + Metric: labels.FromStrings( + "__name__", "ALERTS", + "alertname", "ExternalURLExists", + "alertstate", "pending", + "instance", "0", + "job", "app-server", + "templated_label", "The external URL is http://localhost:1234.", + ), + Point: promql.Point{V: 1}, + }, + } + + evalTime := time.Unix(0, 0) + result[0].Point.T = timestamp.FromTime(evalTime) + result[1].Point.T = timestamp.FromTime(evalTime) + + var filteredRes promql.Vector // After removing 'ALERTS_FOR_STATE' samples. + res, err := ruleWithoutExternalURL.Eval( + suite.Context(), evalTime, EngineQueryFunc(suite.QueryEngine(), suite.Storage()), nil, + ) + require.NoError(t, err) + for _, smpl := range res { + smplName := smpl.Metric.Get("__name__") + if smplName == "ALERTS" { + filteredRes = append(filteredRes, smpl) + } else { + // If not 'ALERTS', it has to be 'ALERTS_FOR_STATE'. + require.Equal(t, "ALERTS_FOR_STATE", smplName) + } + } + + res, err = ruleWithExternalURL.Eval( + suite.Context(), evalTime, EngineQueryFunc(suite.QueryEngine(), suite.Storage()), nil, + ) + require.NoError(t, err) + for _, smpl := range res { + smplName := smpl.Metric.Get("__name__") + if smplName == "ALERTS" { + filteredRes = append(filteredRes, smpl) + } else { + // If not 'ALERTS', it has to be 'ALERTS_FOR_STATE'. + require.Equal(t, "ALERTS_FOR_STATE", smplName) + } + } + + require.Equal(t, result, filteredRes) +} + func TestAlertingRuleEmptyLabelFromTemplate(t *testing.T) { suite, err := promql.NewTest(t, ` load 1m @@ -300,6 +396,7 @@ func TestAlertingRuleEmptyLabelFromTemplate(t *testing.T) { labels.FromStrings("empty_label", ""), nil, nil, + "", true, log.NewNopLogger(), ) result := promql.Vector{ @@ -360,6 +457,7 @@ func TestAlertingRuleDuplicate(t *testing.T) { labels.FromStrings("test", "test"), nil, nil, + "", true, log.NewNopLogger(), ) _, err := rule.Eval(ctx, now, EngineQueryFunc(engine, storage), nil) diff --git a/rules/manager_test.go b/rules/manager_test.go index a6af68361..ab92eda16 100644 --- a/rules/manager_test.go +++ b/rules/manager_test.go @@ -64,7 +64,7 @@ func TestAlertingRule(t *testing.T) { expr, time.Minute, labels.FromStrings("severity", "{{\"c\"}}ritical"), - nil, nil, true, nil, + nil, nil, "", true, nil, ) result := promql.Vector{ { @@ -205,7 +205,7 @@ func TestForStateAddSamples(t *testing.T) { expr, time.Minute, labels.FromStrings("severity", "{{\"c\"}}ritical"), - nil, nil, true, nil, + nil, nil, "", true, nil, ) result := promql.Vector{ { @@ -379,7 +379,7 @@ func TestForStateRestore(t *testing.T) { expr, alertForDuration, labels.FromStrings("severity", "critical"), - nil, nil, true, nil, + nil, nil, "", true, nil, ) group := NewGroup(GroupOptions{ @@ -445,7 +445,7 @@ func TestForStateRestore(t *testing.T) { expr, alertForDuration, labels.FromStrings("severity", "critical"), - nil, nil, false, nil, + nil, nil, "", false, nil, ) newGroup := NewGroup(GroupOptions{ Name: "default", @@ -609,13 +609,13 @@ func readSeriesSet(ss storage.SeriesSet) (map[string][]promql.Point, error) { func TestCopyState(t *testing.T) { oldGroup := &Group{ rules: []Rule{ - NewAlertingRule("alert", nil, 0, nil, nil, nil, true, nil), + NewAlertingRule("alert", nil, 0, nil, nil, nil, "", true, nil), NewRecordingRule("rule1", nil, nil), NewRecordingRule("rule2", nil, nil), NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v1"}}), NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v2"}}), NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v3"}}), - NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v1"}}, nil, nil, true, nil), + NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v1"}}, nil, nil, "", true, nil), }, seriesInPreviousEval: []map[string]labels.Labels{ {}, @@ -634,10 +634,10 @@ func TestCopyState(t *testing.T) { NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v0"}}), NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v1"}}), NewRecordingRule("rule3", nil, labels.Labels{{Name: "l1", Value: "v2"}}), - NewAlertingRule("alert", nil, 0, nil, nil, nil, true, nil), + NewAlertingRule("alert", nil, 0, nil, nil, nil, "", true, nil), NewRecordingRule("rule1", nil, nil), - NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v0"}}, nil, nil, true, nil), - NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v1"}}, nil, nil, true, nil), + NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v0"}}, nil, nil, "", true, nil), + NewAlertingRule("alert2", nil, 0, labels.Labels{{Name: "l2", Value: "v1"}}, nil, nil, "", true, nil), NewRecordingRule("rule4", nil, nil), }, seriesInPreviousEval: make([]map[string]labels.Labels, 8), @@ -725,7 +725,7 @@ func TestUpdate(t *testing.T) { ruleManager.start() defer ruleManager.Stop() - err := ruleManager.Update(10*time.Second, files, nil) + err := ruleManager.Update(10*time.Second, files, nil, "") require.NoError(t, err) require.Greater(t, len(ruleManager.groups), 0, "expected non-empty rule groups") ogs := map[string]*Group{} @@ -736,7 +736,7 @@ func TestUpdate(t *testing.T) { ogs[h] = g } - err = ruleManager.Update(10*time.Second, files, nil) + err = ruleManager.Update(10*time.Second, files, nil, "") require.NoError(t, err) for h, g := range ruleManager.groups { for _, actual := range g.seriesInPreviousEval { @@ -755,7 +755,7 @@ func TestUpdate(t *testing.T) { defer os.Remove(tmpFile.Name()) defer tmpFile.Close() - err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, nil) + err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, nil, "") require.NoError(t, err) for h, g := range ruleManager.groups { @@ -826,7 +826,7 @@ func reloadAndValidate(rgs *rulefmt.RuleGroups, t *testing.T, tmpFile *os.File, tmpFile.Seek(0, 0) _, err = tmpFile.Write(bs) require.NoError(t, err) - err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, nil) + err = ruleManager.Update(10*time.Second, []string{tmpFile.Name()}, nil, "") require.NoError(t, err) for h, g := range ruleManager.groups { if ogs[h] == g { @@ -862,7 +862,7 @@ func TestNotify(t *testing.T) { expr, err := parser.ParseExpr("a > 1") require.NoError(t, err) - rule := NewAlertingRule("aTooHigh", expr, 0, labels.Labels{}, labels.Labels{}, nil, true, log.NewNopLogger()) + rule := NewAlertingRule("aTooHigh", expr, 0, labels.Labels{}, labels.Labels{}, nil, "", true, log.NewNopLogger()) group := NewGroup(GroupOptions{ Name: "alert", Interval: time.Second, @@ -971,7 +971,7 @@ func TestMetricsUpdate(t *testing.T) { } for i, c := range cases { - err := ruleManager.Update(time.Second, c.files, nil) + err := ruleManager.Update(time.Second, c.files, nil, "") require.NoError(t, err) time.Sleep(2 * time.Second) require.Equal(t, c.metrics, countMetrics(), "test %d: invalid count of metrics", i) @@ -1045,7 +1045,7 @@ func TestGroupStalenessOnRemoval(t *testing.T) { var totalStaleNaN int for i, c := range cases { - err := ruleManager.Update(time.Second, c.files, nil) + err := ruleManager.Update(time.Second, c.files, nil, "") require.NoError(t, err) time.Sleep(3 * time.Second) totalStaleNaN += c.staleNaN @@ -1087,11 +1087,11 @@ func TestMetricsStalenessOnManagerShutdown(t *testing.T) { } }() - err := ruleManager.Update(2*time.Second, files, nil) + err := ruleManager.Update(2*time.Second, files, nil, "") time.Sleep(4 * time.Second) require.NoError(t, err) start := time.Now() - err = ruleManager.Update(3*time.Second, files[:0], nil) + err = ruleManager.Update(3*time.Second, files[:0], nil, "") require.NoError(t, err) ruleManager.Stop() stopped = true @@ -1134,7 +1134,7 @@ func TestGroupHasAlertingRules(t *testing.T) { group: &Group{ name: "HasAlertingRule", rules: []Rule{ - NewAlertingRule("alert", nil, 0, nil, nil, nil, true, nil), + NewAlertingRule("alert", nil, 0, nil, nil, nil, "", true, nil), NewRecordingRule("record", nil, nil), }, },