From 44d4ba1bf6760eb4ee5716e15d6b7fa3d212123e Mon Sep 17 00:00:00 2001 From: Dmitriy Gromov Date: Wed, 16 Aug 2017 17:53:35 -0400 Subject: [PATCH] tests round 3 --- rules/namespace_test.go | 137 +++++++++++++++ rules/ruleset.go | 8 +- rules/ruleset_test.go | 369 ++++++++++++++++++++++++++++++++++++++++ 3 files changed, 508 insertions(+), 6 deletions(-) diff --git a/rules/namespace_test.go b/rules/namespace_test.go index b894513..57ec75c 100644 --- a/rules/namespace_test.go +++ b/rules/namespace_test.go @@ -415,3 +415,140 @@ func TestNamespaceTombstoneAlreadyDead(t *testing.T) { err = ns.markTombstoned(4) require.Error(t, err) } + +func TestNamespaceAdd(t *testing.T) { + testNss := &schema.Namespaces{ + Namespaces: []*schema.Namespace{ + &schema.Namespace{ + Name: "foo", + Snapshots: []*schema.NamespaceSnapshot{ + &schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: true}, + }, + }, + }, + } + + nss, err := NewNamespaces(1, testNss) + require.NoError(t, err) + + err = nss.AddNamespace("bar") + require.NoError(t, err) + + ns, err := nss.Namespace("bar") + require.NoError(t, err) + require.False(t, ns.Tombstoned()) +} + +func TestNamespaceAddDup(t *testing.T) { + testNss := &schema.Namespaces{ + Namespaces: []*schema.Namespace{ + &schema.Namespace{ + Name: "foo", + Snapshots: []*schema.NamespaceSnapshot{ + &schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: false}, + }, + }, + }, + } + + nss, err := NewNamespaces(1, testNss) + require.NoError(t, err) + + err = nss.AddNamespace("foo") + require.Error(t, err) +} + +func TestNamespaceRevive(t *testing.T) { + testNss := &schema.Namespaces{ + Namespaces: []*schema.Namespace{ + &schema.Namespace{ + Name: "foo", + Snapshots: []*schema.NamespaceSnapshot{ + &schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: false}, + }, + }, + }, + } + + nss, err := NewNamespaces(1, testNss) + require.NoError(t, err) + ns, err := nss.Namespace("foo") + require.NoError(t, err) + + err = nss.DeleteNamespace("foo", 4) + require.NoError(t, err) + + ns, err = nss.Namespace("foo") + require.True(t, ns.Tombstoned()) + + err = nss.AddNamespace("foo") + require.NoError(t, err) + + ns, err = nss.Namespace("foo") + require.NoError(t, err) + require.Equal(t, ns.snapshots[len(ns.snapshots)-1].forRuleSetVersion, 5) + require.Equal(t, len(ns.snapshots), 3) +} + +func TestNamespaceDelete(t *testing.T) { + testNss := &schema.Namespaces{ + Namespaces: []*schema.Namespace{ + &schema.Namespace{ + Name: "foo", + Snapshots: []*schema.NamespaceSnapshot{ + &schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: false}, + }, + }, + }, + } + + nss, err := NewNamespaces(1, testNss) + require.NoError(t, err) + ns, err := nss.Namespace("foo") + require.NoError(t, err) + + err = nss.DeleteNamespace("foo", 4) + require.NoError(t, err) + ns, err = nss.Namespace("foo") + require.NoError(t, err) + require.True(t, ns.Tombstoned()) + require.Equal(t, ns.snapshots[len(ns.snapshots)-1].forRuleSetVersion, 5) +} + +func TestNamespaceDeleteMissing(t *testing.T) { + testNss := &schema.Namespaces{ + Namespaces: []*schema.Namespace{ + &schema.Namespace{ + Name: "foo", + Snapshots: []*schema.NamespaceSnapshot{ + &schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: false}, + }, + }, + }, + } + + nss, err := NewNamespaces(1, testNss) + require.NoError(t, err) + + err = nss.DeleteNamespace("bar", 4) + require.Error(t, err) +} + +func TestNamespaceDeleteTombstoned(t *testing.T) { + testNss := &schema.Namespaces{ + Namespaces: []*schema.Namespace{ + &schema.Namespace{ + Name: "foo", + Snapshots: []*schema.NamespaceSnapshot{ + &schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: true}, + }, + }, + }, + } + + nss, err := NewNamespaces(1, testNss) + require.NoError(t, err) + + err = nss.DeleteNamespace("foo", 4) + require.Error(t, err) +} diff --git a/rules/ruleset.go b/rules/ruleset.go index b8202d7..82bd48c 100644 --- a/rules/ruleset.go +++ b/rules/ruleset.go @@ -870,8 +870,6 @@ type MappingRuleData struct { // MappingRuleUpdate contains a MappingRuleData along with an ID for a mapping rule. // The rule with that ID is meant to updated to the given config. type MappingRuleUpdate struct { - UpdateMetadata - Data MappingRuleData `json:"config" validate:"nonzero"` ID string `json:"id" validate:"nonzero"` } @@ -889,8 +887,6 @@ type RollupRuleData struct { // RollupRuleUpdate is a RollupRuleConfig along with an ID for a rollup rule. // The rule with that ID is meant to updated with a given config. type RollupRuleUpdate struct { - UpdateMetadata - Data RollupRuleData `json:"data" validate:"nonzero"` ID string `json:"id" validate:"nonzero"` } @@ -951,7 +947,7 @@ func (rs *ruleSet) UpdateMappingRule(mru MappingRuleUpdate) error { if err != nil { return fmt.Errorf(ruleActionErrorFmt, "update", mru.ID, err) } - meta := mru.UpdateMetadata + meta := mrd.UpdateMetadata if err := m.addSnapshot( mrd.Name, mrd.Filters, @@ -1028,7 +1024,7 @@ func (rs *ruleSet) UpdateRollupRule(rru RollupRuleUpdate) error { return fmt.Errorf(ruleActionErrorFmt, "update", rru.ID, err) } - meta := rru.UpdateMetadata + meta := rrd.UpdateMetadata if err = r.addSnapshot( rrd.Name, rrd.Filters, diff --git a/rules/ruleset_test.go b/rules/ruleset_test.go index 4008142..cbaf08f 100644 --- a/rules/ruleset_test.go +++ b/rules/ruleset_test.go @@ -2184,6 +2184,375 @@ func testTagsFilterOptions() filters.TagsFilterOptions { } } +func initMutableTest() (MutableRuleSet, *ruleSet, RuleSetUpdateHelper, error) { + version := 1 + + expectedRs := &schema.RuleSet{ + Uuid: "ruleset", + Namespace: "namespace", + CreatedAt: 1234, + LastUpdatedAt: 5678, + Tombstoned: false, + CutoverTime: 34923, + MappingRules: testMappingRulesConfig(), + RollupRules: testRollupRulesConfig(), + } + + mutable, err := NewMutableRuleSetFromSchema(version, expectedRs) + rs := mutable.(*ruleSet) + return mutable, rs, NewRuleSetUpdateHelper(10), err +} + +func TestAddMappingRule(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + _, err = rs.getMappingRuleByName("foo") + require.Error(t, err) + + newFilters := map[string]string{"tag1": "value", "tag2": "value"} + p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} + data := MappingRuleData{ + Name: "foo", + Filters: newFilters, + Policies: p, + UpdateMetadata: helper.GenUpdateMetadata(), + } + err = mutable.AddMappingRule(data) + require.NoError(t, err) + + _, err = rs.getMappingRuleByName("foo") + require.NoError(t, err) +} + +func TestAddMappingRuleDup(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + m, err := rs.getMappingRuleByName("mappingRule5.snapshot1") + require.NoError(t, err) + require.NotNil(t, m) + + newFilters := map[string]string{"tag1": "value", "tag2": "value"} + p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} + data := MappingRuleData{ + Name: "mappingRule5.snapshot1", + Filters: newFilters, + Policies: p, + UpdateMetadata: helper.GenUpdateMetadata(), + } + + err = mutable.AddMappingRule(data) + require.Error(t, err) +} + +func TestAddMappingRuleRevive(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + m, err := rs.getMappingRuleByName("mappingRule5.snapshot1") + require.NoError(t, err) + require.NotNil(t, m) + + dd := DeleteData{ID: "mappingRule5"} + err = mutable.DeleteMappingRule(dd) + require.NoError(t, err) + + newFilters := map[string]string{"test": "bar"} + p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} + data := MappingRuleData{ + Name: "mappingRule5.snapshot1", + Filters: newFilters, + Policies: p, + UpdateMetadata: helper.GenUpdateMetadata(), + } + err = rs.AddMappingRule(data) + require.NoError(t, err) + + mr, err := rs.getMappingRuleByID("mappingRule5") + require.NoError(t, err) + require.Equal(t, mr.snapshots[len(mr.snapshots)-1].rawFilters, newFilters) +} + +func TestUpdateMappingRule(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + _, err = rs.getMappingRuleByID("mappingRule5") + require.NoError(t, err) + + newFilters := map[string]string{"tag1": "value", "tag2": "value"} + p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} + data := MappingRuleData{ + Name: "foo", + Filters: newFilters, + Policies: p, + UpdateMetadata: helper.GenUpdateMetadata(), + } + + update := MappingRuleUpdate{ + Data: data, + ID: "mappingRule5", + } + + err = mutable.UpdateMappingRule(update) + require.NoError(t, err) + + res, err := rs.getMappingRuleByID("mappingRule5") + require.NoError(t, err) + n, err := res.Name() + require.NoError(t, err) + require.Equal(t, "foo", n) +} + +func TestDeleteMappingRule(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + m, err := rs.getMappingRuleByID("mappingRule5") + require.NoError(t, err) + require.NotNil(t, m) + + dd := DeleteData{ID: "mappingRule5", UpdateMetadata: helper.GenUpdateMetadata()} + err = mutable.DeleteMappingRule(dd) + require.NoError(t, err) + + m, err = rs.getMappingRuleByID("mappingRule5") + require.NoError(t, err) + require.True(t, m.Tombstoned()) +} + +func TestAddRollupRule(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + _, err = rs.getRollupRuleByID("foo") + require.Error(t, err) + + newFilters := map[string]string{"tag1": "value", "tag2": "value"} + p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} + + newTargets := []RollupTarget{ + RollupTarget{ + Name: b("blah"), + Tags: [][]byte{b("a")}, + Policies: p, + }, + } + data := RollupRuleData{ + Name: "foo", + Filters: newFilters, + Targets: newTargets, + UpdateMetadata: helper.GenUpdateMetadata(), + } + + err = mutable.AddRollupRule(data) + require.NoError(t, err) + + res, err := rs.getRollupRuleByName("foo") + require.NotEmpty(t, res.uuid) + require.NoError(t, err) +} + +func TestAddRollupRuleDup(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + r, err := rs.getRollupRuleByID("rollupRule5") + require.NoError(t, err) + require.NotNil(t, r) + + p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} + + newTargets := []RollupTarget{ + RollupTarget{ + Name: b("blah"), + Tags: [][]byte{b("a")}, + Policies: p, + }, + } + newFilters := map[string]string{"test": "bar"} + rrd := RollupRuleData{ + Name: "rollupRule5.snapshot1", + Filters: newFilters, + Targets: newTargets, + UpdateMetadata: helper.GenUpdateMetadata(), + } + err = mutable.AddRollupRule(rrd) + require.Error(t, err) +} + +func TestReviveRollupRule(t *testing.T) { + mutable, rs, helper, err := initMutableTest() + require.NoError(t, err) + + rr, err := rs.getRollupRuleByID("rollupRule5") + require.NoError(t, err) + updateMeta := helper.GenUpdateMetadata() + + dd := DeleteData{ID: "rollupRule5", UpdateMetadata: updateMeta} + err = mutable.DeleteRollupRule(dd) + require.NoError(t, err) + + rr, err = rs.getRollupRuleByID("rollupRule5") + require.NoError(t, err) + require.True(t, rr.Tombstoned()) + + snapshot := rr.snapshots[len(rr.snapshots)-1] + + rrd := RollupRuleData{ + Name: "rollupRule5.snapshot1", + Filters: snapshot.rawFilters, + Targets: snapshot.targets, + UpdateMetadata: updateMeta, + } + + err = mutable.AddRollupRule(rrd) + require.NoError(t, err) + + rr, err = rs.getRollupRuleByID("rollupRule5") + require.NoError(t, err) + require.Equal(t, rr.snapshots[len(rr.snapshots)-1].rawFilters, snapshot.rawFilters) +} + +// func TestUpdateRollupRule(t *testing.T) { +// opts := testRuleSetOptions() +// version := 1 + +// expectedRs := &schema.RuleSet{ +// Uuid: "ruleset", +// Namespace: "namespace", +// CreatedAt: 1234, +// LastUpdatedAt: 5678, +// Tombstoned: false, +// CutoverTime: 34923, +// MappingRules: testMappingRulesConfig(), +// RollupRules: testRollupRulesConfig(), +// } + +// rs, err := NewRuleSetFromSchema(version, expectedRs, opts) +// require.NoError(t, err) +// rsHandler := rs.Handler(NewHandlerOptions(10)) + +// _, err = rs.(*ruleSet).getRollupRuleByName("rollupRule5.snapshot1") +// require.NoError(t, err) + +// newFilters := map[string]string{"tag1": "value", "tag2": "value"} +// p := []policy.Policy{policy.NewPolicy(policy.NewStoragePolicy(time.Minute, xtime.Minute, time.Hour), policy.DefaultAggregationID)} +// newTargets := []RollupTarget{ +// RollupTarget{ +// Name: []byte("blah"), +// Tags: [][]byte{[]byte("a")}, +// Policies: p, +// }, +// } + +// cfg := RollupRuleConfig{Name: "foo", Filters: newFilters, Targets: newTargets} +// updateCfg := RollupRuleUpdate{Name: "rollupRule5.snapshot1", Config: cfg} +// err = rsHandler.UpdateRollupRule(updateCfg) +// require.NoError(t, err) + +// _, err = rsHandler.RuleSet().(*ruleSet).getRollupRuleByName("foo") +// require.NoError(t, err) +// } + +// func TestDeleteRollupRule(t *testing.T) { +// opts := testRuleSetOptions() +// version := 1 + +// expectedRs := &schema.RuleSet{ +// Uuid: "ruleset", +// Namespace: "namespace", +// CreatedAt: 1234, +// LastUpdatedAt: 5678, +// Tombstoned: false, +// CutoverTime: 34923, +// MappingRules: testMappingRulesConfig(), +// RollupRules: testRollupRulesConfig(), +// } + +// rs, err := NewRuleSetFromSchema(version, expectedRs, opts) +// require.NoError(t, err) +// rsHandler := rs.Handler(NewHandlerOptions(10)) + +// r, err := rsHandler.RuleSet().(*ruleSet).getRollupRuleByName("rollupRule5.snapshot1") +// require.NoError(t, err) +// require.NotNil(t, r) + +// err = rsHandler.DeleteRollupRule("rollupRule5.snapshot1") +// require.NoError(t, err) + +// r, err = rsHandler.RuleSet().(*ruleSet).getRollupRuleByName("rollupRule5.snapshot1") +// require.NoError(t, err) +// require.True(t, r.Tombstoned()) +// } + +// func TestDeleteRuleset(t *testing.T) { +// opts := testRuleSetOptions() +// version := 1 + +// expectedRs := &schema.RuleSet{ +// Uuid: "ruleset", +// Namespace: "namespace", +// CreatedAt: 1234, +// LastUpdatedAt: 5678, +// Tombstoned: false, +// CutoverTime: 34923, +// MappingRules: testMappingRulesConfig(), +// RollupRules: testRollupRulesConfig(), +// } + +// rs, err := NewRuleSetFromSchema(version, expectedRs, opts) +// rsHandler := rs.Handler(NewHandlerOptions(10)) +// require.NoError(t, err) + +// err = rsHandler.Delete() +// require.NoError(t, err) + +// require.True(t, rsHandler.RuleSet().Tombstoned()) +// for _, m := range rsHandler.RuleSet().(*ruleSet).mappingRules { +// require.True(t, m.Tombstoned()) +// } + +// for _, r := range rsHandler.RuleSet().(*ruleSet).rollupRules { +// require.True(t, r.Tombstoned()) +// } +// } + +// func TestReviveRuleSet(t *testing.T) { +// opts := testRuleSetOptions() +// version := 1 + +// expectedRs := &schema.RuleSet{ +// Uuid: "ruleset", +// Namespace: "namespace", +// CreatedAt: 1234, +// LastUpdatedAt: 5678, +// Tombstoned: false, +// CutoverTime: 34923, +// MappingRules: testMappingRulesConfig(), +// RollupRules: testRollupRulesConfig(), +// } + +// rs, err := NewRuleSetFromSchema(version, expectedRs, opts) +// rsHandler := rs.Handler(NewHandlerOptions(10)) +// require.NoError(t, err) + +// err = rsHandler.Delete() +// require.NoError(t, err) + +// err = rsHandler.Revive() +// require.NoError(t, err) + +// require.False(t, rs.Tombstoned()) +// for _, m := range rs.(*ruleSet).mappingRules { +// require.True(t, m.Tombstoned()) +// } + +// for _, r := range rs.(*ruleSet).rollupRules { +// require.True(t, r.Tombstoned()) +// } +// } + type testMappingsData struct { id string matchFrom int64