Making friends with gometalinter

rules/namespace_test.go

@@ -279,6 +279,7 @@ func TestNamespacesUnmarshal(t *testing.T) {
 	require.NoError(t, err)
 
 	data, err := json.Marshal(nss)
+	require.NoError(t, err)
 	var nss2 Namespaces
 	err = json.Unmarshal(data, &nss2)
 	require.NoError(t, err)
@@ -384,7 +385,7 @@ func TestNamespaceReviveLive(t *testing.T) {
 			&schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: false},
 		},
 	})
-
+	require.NoError(t, err)
 	err = ns.revive()
 	require.Error(t, err)
 }
@@ -396,7 +397,7 @@ func TestNamespaceMarkTombstoned(t *testing.T) {
 			&schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: false},
 		},
 	})
-
+	require.NoError(t, err)
 	err = ns.markTombstoned(4)
 	require.NoError(t, err)
 
@@ -412,7 +413,7 @@ func TestNamespaceTombstoneAlreadyDead(t *testing.T) {
 			&schema.NamespaceSnapshot{ForRulesetVersion: 1, Tombstoned: true},
 		},
 	})
-
+	require.NoError(t, err)
 	err = ns.markTombstoned(4)
 	require.Error(t, err)
 }
@@ -441,7 +442,7 @@ func TestNamespaceAdd(t *testing.T) {
 	require.NoError(t, err)
 	require.False(t, ns.Tombstoned())
 
-	ns, err = nss.Namespace("bar")
+	_, err = nss.Namespace("bar")
 	require.Error(t, err)
 }
 
@@ -478,13 +479,14 @@ func TestNamespaceRevive(t *testing.T) {
 
 	nss, err := NewNamespaces(1, testNss)
 	require.NoError(t, err)
-	ns, err := nss.Namespace("foo")
+	_, err = nss.Namespace("foo")
 	require.NoError(t, err)
 
 	err = nss.DeleteNamespace("foo", 4)
 	require.NoError(t, err)
 
-	ns, err = nss.Namespace("foo")
+	ns, err := nss.Namespace("foo")
+	require.NoError(t, err)
 	require.True(t, ns.Tombstoned())
 
 	err = nss.AddNamespace("foo")
@@ -510,12 +512,12 @@ func TestNamespaceDelete(t *testing.T) {
 
 	nss, err := NewNamespaces(1, testNss)
 	require.NoError(t, err)
-	ns, err := nss.Namespace("foo")
+	_, err = nss.Namespace("foo")
 	require.NoError(t, err)
 
 	err = nss.DeleteNamespace("foo", 4)
 	require.NoError(t, err)
-	ns, err = nss.Namespace("foo")
+	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)

rules/ruleset.go

@@ -43,12 +43,9 @@ const (
 
 var (
 	errNilRuleSetSchema   = errors.New("nil rule set schema")
-	errRuleAlreadyExist   = errors.New("rule already exists")
 	errNoSuchRule         = errors.New("no such rule exists")
-	errTombstoned         = errors.New("rule is tombstoned")
 	errNotTombstoned      = errors.New("not tombstoned")
 	errNoRuleSnapshots    = errors.New("no snapshots")
-	errDuplicateTargets   = errors.New("duplicate targets")
 	ruleActionErrorFmt    = "cannot %s rule %s. %v"
 	ruleSetActionErrorFmt = "cannot %s ruleset %s. %v"
 )
@@ -685,7 +682,7 @@ func (a int64Asc) Len() int           { return len(a) }
 func (a int64Asc) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
 func (a int64Asc) Less(i, j int) bool { return a[i] < a[j] }
 
-// MutableRuleSet is an extention of a RuleSet that implements mutation functions.
+// MutableRuleSet is an extension of a RuleSet that implements mutation functions.
 type MutableRuleSet interface {
 	RuleSet
 
@@ -1074,13 +1071,13 @@ func (rs *ruleSet) Delete(meta UpdateMetadata) error {
 	// Make sure that all of the rules in the ruleset are tombstoned as well.
 	for _, m := range rs.mappingRules {
 		if t := m.Tombstoned(); !t {
-			m.markTombstoned(meta.cutoverNanos)
+			_ = m.markTombstoned(meta.cutoverNanos)
 		}
 	}
 
 	for _, r := range rs.rollupRules {
 		if t := r.Tombstoned(); !t {
-			r.markTombstoned(meta.cutoverNanos)
+			_ = r.markTombstoned(meta.cutoverNanos)
 		}
 	}
 

rules/ruleset_test.go

@@ -650,6 +650,7 @@ func TestRuleSetUnmarshalJSON(t *testing.T) {
 	require.NoError(t, err)
 
 	data, err := json.Marshal(newRuleSet)
+	require.NoError(t, err)
 	var rs ruleSet
 	err = json.Unmarshal(data, &rs)
 	require.NoError(t, err)

rules/store.go

@@ -114,10 +114,8 @@ func (s store) WriteRuleSet(rs MutableRuleSet) error {
 		return err
 	}
 	conditions, ops := []kv.Condition{rsCond}, []kv.Op{rsOp}
-	if _, err := s.kvStore.Commit(conditions, ops); err != nil {
-		return err
-	}
-	return nil
+	_, err = s.kvStore.Commit(conditions, ops)
+	return err
 }
 
 func (s store) WriteAll(nss *Namespaces, rs MutableRuleSet) error {
@@ -137,11 +135,8 @@ func (s store) WriteAll(nss *Namespaces, rs MutableRuleSet) error {
 	}
 	conditions = append(conditions, namespacesCond)
 	ops = append(ops, namespacesOp)
-
-	if _, err := s.kvStore.Commit(conditions, ops); err != nil {
-		return err
-	}
-	return nil
+	_, err = s.kvStore.Commit(conditions, ops)
+	return err
 }
 
 func (s store) ruleSetKey(ns string) string {

rules/store_test.go

@@ -69,12 +69,6 @@ var (
 		},
 	}
 
-	badNamespaces = &schema.Namespaces{
-		Namespaces: []*schema.Namespace{
-			&schema.Namespace{Name: "fooNs", Snapshots: nil},
-		},
-	}
-
 	testRuleSetKey = fmt.Sprintf(testRuleSetKeyFmt, testNamespace)
 	testRuleSet    = &schema.RuleSet{
 		Uuid:          "ruleset",
@@ -364,14 +358,6 @@ var (
 			},
 		},
 	}
-	testTombstonedRuleSet = &schema.RuleSet{
-		Uuid:          "ruleset",
-		Namespace:     "deadNs",
-		CreatedAt:     1234,
-		LastUpdatedAt: 5678,
-		Tombstoned:    true,
-		CutoverTime:   34923,
-	}
 )
 
 func testStore() Store {
@@ -397,31 +383,35 @@ func TestNewStore(t *testing.T) {
 
 func TestReadNamespaces(t *testing.T) {
 	s := testStore()
-	s.(store).kvStore.Set(testNamespaceKey, testNamespaces)
+	_, e := s.(store).kvStore.Set(testNamespaceKey, testNamespaces)
+	require.NoError(t, e)
 	nss, err := s.ReadNamespaces()
 	require.NoError(t, err)
 	require.NotNil(t, nss.Namespaces)
 }
 
 func TestNamespacesError(t *testing.T) {
 	s := testStore()
-	s.(store).kvStore.Set(testNamespaceKey, &schema.RollupRule{Uuid: "x"})
+	_, e := s.(store).kvStore.Set(testNamespaceKey, &schema.RollupRule{Uuid: "x"})
+	require.NoError(t, e)
 	nss, err := s.ReadNamespaces()
 	require.Error(t, err)
 	require.Nil(t, nss)
 }
 
 func TestReadRuleSet(t *testing.T) {
 	s := testStore()
-	s.(store).kvStore.Set(testRuleSetKey, testRuleSet)
+	_, e := s.(store).kvStore.Set(testRuleSetKey, testRuleSet)
+	require.NoError(t, e)
 	rs, err := s.ReadRuleSet(testNamespace)
 	require.NoError(t, err)
 	require.NotNil(t, rs)
 }
 
 func TestRuleSetError(t *testing.T) {
 	s := testStore()
-	s.(store).kvStore.Set(testRuleSetKey, &schema.Namespace{Name: "x"})
+	_, e := s.(store).kvStore.Set(testRuleSetKey, &schema.Namespace{Name: "x"})
+	require.NoError(t, e)
 	rs, err := s.ReadRuleSet("blah")
 	require.Error(t, err)
 	require.Nil(t, rs)
@@ -449,9 +439,11 @@ func TestWrite(t *testing.T) {
 	rs, err = s.ReadRuleSet(testNamespace)
 	require.NoError(t, err)
 	rsSchema, err := rs.Schema()
+	require.NoError(t, err)
 	require.Equal(t, rsSchema, testRuleSet)
 
 	nss, err = s.ReadNamespaces()
+	require.NoError(t, err)
 	nssSchema, err := nss.Schema()
 	require.NoError(t, err)
 	require.Equal(t, nssSchema, testNamespaces)
@@ -494,10 +486,10 @@ func TestWriteErrorAll(t *testing.T) {
 		require.Error(t, err)
 	}
 
-	rs, err = s.ReadRuleSet(testNamespace)
+	_, err = s.ReadRuleSet(testNamespace)
 	require.Error(t, err)
 
-	nss, err = s.ReadNamespaces()
+	_, err = s.ReadNamespaces()
 	require.Error(t, err)
 }
 
@@ -524,7 +516,7 @@ func TestWriteErrorRuleSet(t *testing.T) {
 	err = s.WriteRuleSet(nil)
 	require.Error(t, err)
 
-	rs, err = s.ReadRuleSet(testNamespace)
+	_, err = s.ReadRuleSet(testNamespace)
 	require.Error(t, err)
 }
 
@@ -551,18 +543,16 @@ func TestWriteNoNamespace(t *testing.T) {
 	rs, err = s.ReadRuleSet(testNamespace)
 	require.NoError(t, err)
 
-	nss, err = s.ReadNamespaces()
+	_, err = s.ReadNamespaces()
 	require.NoError(t, err)
 
 	err = s.WriteRuleSet(rs)
 	require.NoError(t, err)
 
-	nss, err = s.ReadNamespaces()
-	require.NoError(t, err)
-
 	rs, err = s.ReadRuleSet(testNamespace)
+	require.NoError(t, err)
 	nss, err = s.ReadNamespaces()
-
+	require.NoError(t, err)
 	require.Equal(t, nss.Version(), 1)
 	require.Equal(t, rs.Version(), 2)
 }