From fe3ba79d54ddfbdfb2679236d869336e9023c3e9 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Ferdinand=20M=C3=BCtsch?= Date: Sun, 26 Dec 2021 18:09:05 +0100 Subject: [PATCH] chore: filter model tests --- models/filters.go | 2 +- models/filters_test.go | 160 +++++++++++++++++++++++++++++++++++++++++ 2 files changed, 161 insertions(+), 1 deletion(-) create mode 100644 models/filters_test.go diff --git a/models/filters.go b/models/filters.go index 7e5efaf..d8478ef 100644 --- a/models/filters.go +++ b/models/filters.go @@ -161,7 +161,7 @@ func (f *Filters) WithProjectLabels(resolve ProjectLabelReverseResolver) *Filter return f } for _, l := range f.Label { - f.Project = append(f.Project, resolve(l)...) + f.WithMultiple(SummaryProject, resolve(l)) } return f } diff --git a/models/filters_test.go b/models/filters_test.go new file mode 100644 index 0000000..a685cb8 --- /dev/null +++ b/models/filters_test.go @@ -0,0 +1,160 @@ +package models + +import ( + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/suite" + "testing" +) + +type FiltersTestSuite struct { + suite.Suite + TestAliases []*Alias + TestProjectLabels []*ProjectLabel + GetAliasReverseResolver func(indices []int) AliasReverseResolver + GetProjectLabelReverseResolver func(indices []int) ProjectLabelReverseResolver +} + +func (suite *FiltersTestSuite) SetupSuite() { + suite.TestAliases = []*Alias{ + { + Type: SummaryProject, + Key: "wakapi", + Value: "wakapi-mobile", + }, + { + Type: SummaryProject, + Key: "wakapi", + Value: "wakapi-desktop", + }, + { + Type: SummaryLanguage, + Key: "Python", + Value: "Python 3", + }, + } + + suite.TestProjectLabels = []*ProjectLabel{ + { + ProjectKey: "wakapi", + Label: "oss", + }, + { + ProjectKey: "anchr", + Label: "oss", + }, + { + ProjectKey: "business-application", + Label: "work", + }, + } + + suite.GetAliasReverseResolver = func(indices []int) AliasReverseResolver { + return func(t uint8, k string) []string { + aliases := make([]string, 0, len(indices)) + for _, j := range indices { + if a := suite.TestAliases[j]; a.Type == t && a.Key == k { + aliases = append(aliases, a.Value) + } + } + return aliases + } + } + + suite.GetProjectLabelReverseResolver = func(indices []int) ProjectLabelReverseResolver { + return func(k string) []string { + labels := make([]string, 0, len(indices)) + for _, j := range indices { + if l := suite.TestProjectLabels[j]; l.Label == k { + labels = append(labels, l.ProjectKey) + } + } + return labels + } + } +} + +func TestFiltersTestSuite(t *testing.T) { + suite.Run(t, new(FiltersTestSuite)) +} + +func (suite *FiltersTestSuite) TestFilters_IsEmpty() { + assert.False(suite.T(), NewFiltersWith(SummaryProject, "wakapi").IsEmpty()) + assert.True(suite.T(), (&Filters{}).IsEmpty()) +} + +func (suite *FiltersTestSuite) TestFilters_Match() { + heartbeats := []*Heartbeat{ + {Project: "wakapi", Language: "Go"}, + {Project: "anchr", Language: "Javascript"}, + } + + sut1 := NewFiltersWith(SummaryProject, "wakapi") + assert.True(suite.T(), sut1.Match(heartbeats[0])) + assert.False(suite.T(), sut1.Match(heartbeats[1])) + + sut2 := NewFiltersWith(SummaryProject, "Go").With(SummaryLanguage, "JavaScript") + assert.False(suite.T(), sut2.Match(heartbeats[0])) + assert.False(suite.T(), sut2.Match(heartbeats[1])) + + sut3 := NewFilterWithMultiple(SummaryProject, []string{"wakapi", "anchr"}) + assert.True(suite.T(), sut3.Match(heartbeats[0])) + assert.True(suite.T(), sut3.Match(heartbeats[1])) + + sut4 := &Filters{} + assert.True(suite.T(), sut4.Match(heartbeats[0])) + assert.True(suite.T(), sut4.Match(heartbeats[1])) +} + +func (suite *FiltersTestSuite) TestFilters_One() { + sut1 := NewFiltersWith(SummaryLanguage, "Java") + ok1, type1, filters1 := sut1.One() + assert.True(suite.T(), ok1) + assert.Equal(suite.T(), SummaryLanguage, type1) + assert.Equal(suite.T(), "Java", filters1[0]) + + sut2 := &Filters{} + ok2, type2, filters2 := sut2.One() + assert.False(suite.T(), ok2) + assert.Zero(suite.T(), type2) + assert.Empty(suite.T(), filters2) +} + +func (suite *FiltersTestSuite) TestFilters_WithAliases() { + sut1 := NewFiltersWith(SummaryProject, "wakapi") + sut1 = sut1.WithAliases(suite.GetAliasReverseResolver([]int{0, 1, 2})) + assert.Len(suite.T(), sut1.Project, 3) + assert.Len(suite.T(), sut1.Language, 0) + assert.Contains(suite.T(), sut1.Project, "wakapi") + assert.Contains(suite.T(), sut1.Project, "wakapi-desktop") + assert.Contains(suite.T(), sut1.Project, "wakapi-mobile") + + sut2 := NewFiltersWith(SummaryProject, "wakapi").With(SummaryLanguage, "Python") + sut2 = sut2.WithAliases(suite.GetAliasReverseResolver([]int{0, 1, 2})) + assert.Len(suite.T(), sut2.Project, 3) + assert.Len(suite.T(), sut2.Language, 2) + assert.Contains(suite.T(), sut2.Language, "Python") + assert.Contains(suite.T(), sut2.Language, "Python 3") + + sut3 := NewFiltersWith(SummaryProject, "foo") + sut3 = sut3.WithAliases(suite.GetAliasReverseResolver([]int{0, 1, 2})) + assert.Len(suite.T(), sut3.Project, 1) + assert.Len(suite.T(), sut3.Language, 0) + assert.Contains(suite.T(), sut3.Project, "foo") +} + +func (suite *FiltersTestSuite) TestFilters_WithProjectLabels() { + sut1 := NewFiltersWith(SummaryProject, "mailwhale").With(SummaryLabel, "oss") + sut1 = sut1.WithProjectLabels(suite.GetProjectLabelReverseResolver([]int{0, 1, 2})) + assert.Len(suite.T(), sut1.Project, 3) + assert.Contains(suite.T(), sut1.Project, "wakapi") + assert.Contains(suite.T(), sut1.Project, "anchr") + assert.Contains(suite.T(), sut1.Project, "mailwhale") + assert.Contains(suite.T(), sut1.Label, "oss") + + sut2 := NewFiltersWith(SummaryLabel, "oss") + sut2 = sut2.WithProjectLabels(suite.GetProjectLabelReverseResolver([]int{0, 1, 2})) + assert.Len(suite.T(), sut2.Project, 2) + assert.Contains(suite.T(), sut2.Project, "wakapi") + assert.Contains(suite.T(), sut2.Project, "anchr") + assert.Contains(suite.T(), sut2.Label, "oss") +}