tests round 3

rules/namespace_test.go

@@ -415,3 +415,145 @@ 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)
+	nssClone, err := nss.Clone()
+	require.NoError(t, err)
+
+	err = nssClone.AddNamespace("bar")
+	require.NoError(t, err)
+
+	ns, err := nssClone.Namespace("bar")
+	require.NoError(t, err)
+	require.False(t, ns.Tombstoned())
+
+	ns, err = nss.Namespace("bar")
+	require.Error(t, err)
+}
+
+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)
+}

rules/rollup.go

@@ -354,13 +354,6 @@ func (rc *rollupRule) Tombstoned() bool {
 	return latest.tombstoned
 }
 
-func (rc rollupRule) targets() []RollupTarget {
-	if len(rc.snapshots) == 0 {
-		return nil
-	}
-	return rc.snapshots[len(rc.snapshots)-1].targets
-}
-
 func (rc *rollupRule) addSnapshot(
 	name string,
 	rawFilters map[string]string,

rules/ruleset.go

@@ -721,7 +721,7 @@ type MutableRuleSet interface {
 	DeleteRollupRule(DeleteData) error
 
 	// Tombstone tombstones this ruleset and all of its rules.
-	Delete(DeleteData) error
+	Delete(UpdateMetadata) error
 
 	// Revive removes the tombstone from this ruleset. It does not revive any rules.
 	Revive(UpdateMetadata) error
@@ -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,
@@ -1054,13 +1050,12 @@ func (rs *ruleSet) DeleteRollupRule(d DeleteData) error {
 	return nil
 }
 
-func (rs *ruleSet) Delete(d DeleteData) error {
+func (rs *ruleSet) Delete(meta UpdateMetadata) error {
 	if rs.tombstoned {
 		return fmt.Errorf("%s is already tombstoned", string(rs.namespace))
 	}
 
 	rs.tombstoned = true
-	meta := d.UpdateMetadata
 	rs.updateMetadata(meta)
 
 	// Make sure that all of the rules in the ruleset are tombstoned as well.