From bc9b34d3db0cdf5ea1c070f30940e5338d7e8f91 Mon Sep 17 00:00:00 2001 From: Jose Donizetti Date: Tue, 7 Nov 2017 08:39:22 -0200 Subject: [PATCH] Add test to matchers (#1079) * Add Test to Matcher and Matchers * Move matchers string test to match_test.go --- types/match_test.go | 179 ++++++++++++++++++++++++++++++++++++++++++++ types/types_test.go | 37 --------- 2 files changed, 179 insertions(+), 37 deletions(-) create mode 100644 types/match_test.go diff --git a/types/match_test.go b/types/match_test.go new file mode 100644 index 00000000..a078598e --- /dev/null +++ b/types/match_test.go @@ -0,0 +1,179 @@ +package types + +import ( + "fmt" + "regexp" + "testing" + + "github.com/prometheus/common/model" + "github.com/stretchr/testify/require" +) + +func TestMatcherValidate(t *testing.T) { + + validLabelName := "valid_label_name" + validStringValue := "value" + validRegexValue := ".*" + + invalidLabelName := "123_invalid_name" + invalidStringValue := "" + invalidRegexValue := "]*.[" + + tests := []struct { + matcher Matcher + valid bool + errorMsg string + }{ + //valid tests + { + matcher: Matcher{Name: validLabelName, Value: validStringValue}, + valid: true, + }, + { + matcher: Matcher{Name: validLabelName, Value: validRegexValue, IsRegex: true}, + valid: true, + }, + // invalid tests + { + matcher: Matcher{Name: invalidLabelName, Value: validStringValue}, + valid: false, + errorMsg: fmt.Sprintf("invalid name %q", invalidLabelName), + }, + { + matcher: Matcher{Name: validLabelName, Value: invalidStringValue}, + valid: false, + errorMsg: fmt.Sprintf("invalid value %q", invalidStringValue), + }, + { + matcher: Matcher{Name: validLabelName, Value: invalidRegexValue, IsRegex: true}, + valid: false, + errorMsg: fmt.Sprintf("invalid regular expression %q", invalidRegexValue), + }, + } + + for _, test := range tests { + test.matcher.Init() + + if test.valid { + require.NoError(t, test.matcher.Validate()) + continue + } + + require.EqualError(t, test.matcher.Validate(), test.errorMsg) + } +} + +func TestMatcherInit(t *testing.T) { + m := Matcher{Name: "label", Value: ".*", IsRegex: true} + require.NoError(t, m.Init()) + require.EqualValues(t, "^(?:.*)$", m.regex.String()) + + m = Matcher{Name: "label", Value: "]*.[", IsRegex: true} + require.Error(t, m.Init()) +} + +func TestMatcherMatch(t *testing.T) { + tests := []struct { + matcher Matcher + expected bool + }{ + {matcher: Matcher{Name: "label", Value: "value"}, expected: true}, + {matcher: Matcher{Name: "label", Value: "val"}, expected: false}, + {matcher: Matcher{Name: "label", Value: "val.*", IsRegex: true}, expected: true}, + {matcher: Matcher{Name: "label", Value: "diffval.*", IsRegex: true}, expected: false}, + //unset label + {matcher: Matcher{Name: "difflabel", Value: "value"}, expected: false}, + } + + lset := model.LabelSet{"label": "value"} + for _, test := range tests { + test.matcher.Init() + + actual := test.matcher.Match(lset) + require.EqualValues(t, test.expected, actual) + } +} + +func TestMatcherString(t *testing.T) { + m := NewMatcher("foo", "bar") + + if m.String() != "foo=\"bar\"" { + t.Errorf("unexpected matcher string %#v", m.String()) + } + + re, err := regexp.Compile(".*") + if err != nil { + t.Errorf("unexpected error: %s", err) + } + + m = NewRegexMatcher("foo", re) + + if m.String() != "foo=~\".*\"" { + t.Errorf("unexpected matcher string %#v", m.String()) + } +} + +func TestMatchersString(t *testing.T) { + m1 := NewMatcher("foo", "bar") + + re, err := regexp.Compile(".*") + if err != nil { + t.Errorf("unexpected error: %s", err) + } + + m2 := NewRegexMatcher("bar", re) + + matchers := NewMatchers(m1, m2) + + if matchers.String() != "{bar=~\".*\",foo=\"bar\"}" { + t.Errorf("unexpected matcher string %#v", matchers.String()) + } +} + +func TestMatchersMatch(t *testing.T) { + + m1 := &Matcher{Name: "label1", Value: "value1"} + m1.Init() + m2 := &Matcher{Name: "label2", Value: "val.*", IsRegex: true} + m2.Init() + m3 := &Matcher{Name: "label3", Value: "value3"} + m3.Init() + + tests := []struct { + matchers Matchers + expected bool + }{ + {matchers: Matchers{m1, m2}, expected: true}, + {matchers: Matchers{m1, m3}, expected: false}, + } + + lset := model.LabelSet{"label1": "value1", "label2": "value2"} + for _, test := range tests { + actual := test.matchers.Match(lset) + require.EqualValues(t, test.expected, actual) + } +} + +func TestMatchersEqual(t *testing.T) { + + m1 := &Matcher{Name: "label1", Value: "value1"} + m1.Init() + m2 := &Matcher{Name: "label2", Value: "val.*", IsRegex: true} + m2.Init() + m3 := &Matcher{Name: "label3", Value: "value3"} + m3.Init() + + tests := []struct { + matchers1 Matchers + matchers2 Matchers + expected bool + }{ + {matchers1: Matchers{m1, m2}, matchers2: Matchers{m1, m2}, expected: true}, + {matchers1: Matchers{m1, m3}, matchers2: Matchers{m1, m2}, expected: false}, + } + + for _, test := range tests { + actual := test.matchers1.Equal(test.matchers2) + require.EqualValues(t, test.expected, actual) + } +} diff --git a/types/types_test.go b/types/types_test.go index 8f89d0ad..bffda4fd 100644 --- a/types/types_test.go +++ b/types/types_test.go @@ -15,49 +15,12 @@ package types import ( "reflect" - "regexp" "testing" "time" "github.com/prometheus/common/model" ) -func TestMatcher(t *testing.T) { - m := NewMatcher("foo", "bar") - - if m.String() != "foo=\"bar\"" { - t.Errorf("unexpected matcher string %#v", m.String()) - } - - re, err := regexp.Compile(".*") - if err != nil { - t.Errorf("unexpected error: %s", err) - } - - m = NewRegexMatcher("foo", re) - - if m.String() != "foo=~\".*\"" { - t.Errorf("unexpected matcher string %#v", m.String()) - } -} - -func TestMatchers(t *testing.T) { - m1 := NewMatcher("foo", "bar") - - re, err := regexp.Compile(".*") - if err != nil { - t.Errorf("unexpected error: %s", err) - } - - m2 := NewRegexMatcher("bar", re) - - matchers := NewMatchers(m1, m2) - - if matchers.String() != "{bar=~\".*\",foo=\"bar\"}" { - t.Errorf("unexpected matcher string %#v", matchers.String()) - } -} - func TestAlertMerge(t *testing.T) { now := time.Now()