more wip errors.Is in server module

Signed-off-by: redwrasse <mail@redwrasse.io>

server/auth/jwt_test.go

@@ -16,6 +16,7 @@ package auth
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -139,7 +140,7 @@ func testJWTInfo(t *testing.T, opts map[string]string) {
 			}
 
 			_, aerr := verify.assign(ctx, "abc", 123)
-			if aerr != ErrVerifyOnly {
+			if !errors.Is(aerr, ErrVerifyOnly) {
 				t.Fatalf("unexpected error when attempting to sign with public key: %v", aerr)
 			}
 

server/auth/store_test.go

@@ -165,13 +165,13 @@ func TestUserAdd(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrUserAlreadyExist, err)
 	}
-	if err != ErrUserAlreadyExist {
+	if !errors.Is(err, ErrUserAlreadyExist) {
 		t.Fatalf("expected %v, got %v", ErrUserAlreadyExist, err)
 	}
 
 	ua = &pb.AuthUserAddRequest{Name: "", Options: &authpb.UserAddOptions{NoPassword: false}}
 	_, err = as.UserAdd(ua) // add a user with empty name
-	if err != ErrUserEmpty {
+	if !errors.Is(err, ErrUserEmpty) {
 		t.Fatal(err)
 	}
 
@@ -227,7 +227,7 @@ func TestCheckPassword(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrAuthFailed, err)
 	}
-	if err != ErrAuthFailed {
+	if !errors.Is(err, ErrAuthFailed) {
 		t.Fatalf("expected %v, got %v", ErrAuthFailed, err)
 	}
 
@@ -242,7 +242,7 @@ func TestCheckPassword(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrAuthFailed, err)
 	}
-	if err != ErrAuthFailed {
+	if !errors.Is(err, ErrAuthFailed) {
 		t.Fatalf("expected %v, got %v", ErrAuthFailed, err)
 	}
 }
@@ -264,7 +264,7 @@ func TestUserDelete(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
-	if err != ErrUserNotFound {
+	if !errors.Is(err, ErrUserNotFound) {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
 
@@ -288,7 +288,7 @@ func TestUserDeleteAndPermCache(t *testing.T) {
 
 	// delete a non-existing user
 	_, err = as.UserDelete(ud)
-	if err != ErrUserNotFound {
+	if !errors.Is(err, ErrUserNotFound) {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
 
@@ -336,7 +336,7 @@ func TestUserChangePassword(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
-	if err != ErrUserNotFound {
+	if !errors.Is(err, ErrUserNotFound) {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
 
@@ -359,7 +359,7 @@ func TestRoleAdd(t *testing.T) {
 
 	// add a role with empty name
 	_, err = as.RoleAdd(&pb.AuthRoleAddRequest{Name: ""})
-	if err != ErrRoleEmpty {
+	if !errors.Is(err, ErrRoleEmpty) {
 		t.Fatal(err)
 	}
 }
@@ -379,7 +379,7 @@ func TestUserGrant(t *testing.T) {
 	if err == nil {
 		t.Errorf("expected %v, got %v", ErrUserNotFound, err)
 	}
-	if err != ErrUserNotFound {
+	if !errors.Is(err, ErrUserNotFound) {
 		t.Errorf("expected %v, got %v", ErrUserNotFound, err)
 	}
 }
@@ -455,7 +455,7 @@ func TestIsOpPermitted(t *testing.T) {
 	as.rangePermCacheMu.Lock()
 	delete(as.rangePermCache, "foo")
 	as.rangePermCacheMu.Unlock()
-	if err := as.isOpPermitted("foo", as.Revision(), perm.Key, perm.RangeEnd, perm.PermType); err != ErrPermissionDenied {
+	if err := as.isOpPermitted("foo", as.Revision(), perm.Key, perm.RangeEnd, perm.PermType); !errors.Is(err, ErrPermissionDenied) {
 		t.Fatal(err)
 	}
 
@@ -545,7 +545,7 @@ func TestRoleGrantPermission(t *testing.T) {
 		Name: "role-test-1",
 	})
 
-	if err != ErrPermissionNotGiven {
+	if !errors.Is(err, ErrPermissionNotGiven) {
 		t.Error(err)
 	}
 
@@ -887,13 +887,13 @@ func TestAuthInfoFromCtx(t *testing.T) {
 
 	ctx = metadata.NewIncomingContext(context.Background(), metadata.New(map[string]string{rpctypes.TokenFieldNameGRPC: "Invalid Token"}))
 	_, err = as.AuthInfoFromCtx(ctx)
-	if err != ErrInvalidAuthToken {
+	if !errors.Is(err, ErrInvalidAuthToken) {
 		t.Errorf("expected %v, got %v", ErrInvalidAuthToken, err)
 	}
 
 	ctx = metadata.NewIncomingContext(context.Background(), metadata.New(map[string]string{rpctypes.TokenFieldNameGRPC: "Invalid.Token"}))
 	_, err = as.AuthInfoFromCtx(ctx)
-	if err != ErrInvalidAuthToken {
+	if !errors.Is(err, ErrInvalidAuthToken) {
 		t.Errorf("expected %v, got %v", ErrInvalidAuthToken, err)
 	}
 
@@ -914,14 +914,14 @@ func TestAuthDisable(t *testing.T) {
 	as.AuthDisable()
 	ctx := context.WithValue(context.WithValue(context.TODO(), AuthenticateParamIndex{}, uint64(2)), AuthenticateParamSimpleTokenPrefix{}, "dummy")
 	_, err := as.Authenticate(ctx, "foo", "bar")
-	if err != ErrAuthNotEnabled {
+	if !errors.Is(err, ErrAuthNotEnabled) {
 		t.Errorf("expected %v, got %v", ErrAuthNotEnabled, err)
 	}
 
 	// Disabling disabled auth to make sure it can return safely if store is already disabled.
 	as.AuthDisable()
 	_, err = as.Authenticate(ctx, "foo", "bar")
-	if err != ErrAuthNotEnabled {
+	if !errors.Is(err, ErrAuthNotEnabled) {
 		t.Errorf("expected %v, got %v", ErrAuthNotEnabled, err)
 	}
 }
@@ -980,19 +980,19 @@ func TestIsAdminPermitted(t *testing.T) {
 
 	// invalid user
 	err = as.IsAdminPermitted(&AuthInfo{Username: "rooti", Revision: 1})
-	if err != ErrUserNotFound {
+	if !errors.Is(err, ErrUserNotFound) {
 		t.Errorf("expected %v, got %v", ErrUserNotFound, err)
 	}
 
 	// empty user
 	err = as.IsAdminPermitted(&AuthInfo{Username: "", Revision: 1})
-	if err != ErrUserEmpty {
+	if !errors.Is(err, ErrUserEmpty) {
 		t.Errorf("expected %v, got %v", ErrUserEmpty, err)
 	}
 
 	// non-admin user
 	err = as.IsAdminPermitted(&AuthInfo{Username: "foo", Revision: 1})
-	if err != ErrPermissionDenied {
+	if !errors.Is(err, ErrPermissionDenied) {
 		t.Errorf("expected %v, got %v", ErrPermissionDenied, err)
 	}
 
@@ -1013,13 +1013,13 @@ func TestRecoverFromSnapshot(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrUserAlreadyExist, err)
 	}
-	if err != ErrUserAlreadyExist {
+	if !errors.Is(err, ErrUserAlreadyExist) {
 		t.Fatalf("expected %v, got %v", ErrUserAlreadyExist, err)
 	}
 
 	ua = &pb.AuthUserAddRequest{Name: "", Options: &authpb.UserAddOptions{NoPassword: false}}
 	_, err = as.UserAdd(ua) // add a user with empty name
-	if err != ErrUserEmpty {
+	if !errors.Is(err, ErrUserEmpty) {
 		t.Fatal(err)
 	}
 
@@ -1195,7 +1195,7 @@ func TestUserNoPasswordAdd(t *testing.T) {
 
 	ctx := context.WithValue(context.WithValue(context.TODO(), AuthenticateParamIndex{}, uint64(1)), AuthenticateParamSimpleTokenPrefix{}, "dummy")
 	_, err = as.Authenticate(ctx, username, "")
-	if err != ErrAuthFailed {
+	if !errors.Is(err, ErrAuthFailed) {
 		t.Fatalf("expected %v, got %v", ErrAuthFailed, err)
 	}
 }
@@ -1237,7 +1237,7 @@ func TestUserChangePasswordWithOldLog(t *testing.T) {
 	if err == nil {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
-	if err != ErrUserNotFound {
+	if !errors.Is(err, ErrUserNotFound) {
 		t.Fatalf("expected %v, got %v", ErrUserNotFound, err)
 	}
 }

server/embed/etcd_test.go

@@ -15,6 +15,7 @@
 package embed
 
 import (
+	"errors"
 	"net/url"
 	"testing"
 
@@ -32,7 +33,7 @@ func TestEmptyClientTLSInfo_createMetricsListener(t *testing.T) {
 		Scheme: "https",
 		Host:   "localhost:8080",
 	}
-	if _, err := e.createMetricsListener(murl); err != ErrMissingClientTLSInfoForMetricsURL {
+	if _, err := e.createMetricsListener(murl); !errors.Is(err, ErrMissingClientTLSInfoForMetricsURL) {
 		t.Fatalf("expected error %v, got %v", ErrMissingClientTLSInfoForMetricsURL, err)
 	}
 }

server/embed/serve_test.go

@@ -15,6 +15,7 @@
 package embed
 
 import (
+	"errors"
 	"fmt"
 	"net/url"
 	"os"
@@ -43,7 +44,7 @@ func TestStartEtcdWrongToken(t *testing.T) {
 	cfg.Dir = tdir
 	cfg.AuthToken = "wrong-token"
 
-	if _, err := StartEtcd(cfg); err != auth.ErrInvalidAuthOpts {
+	if _, err := StartEtcd(cfg); !errors.Is(err, auth.ErrInvalidAuthOpts) {
 		t.Fatalf("expected %v, got %v", auth.ErrInvalidAuthOpts, err)
 	}
 }

server/etcdmain/config_test.go

@@ -15,6 +15,7 @@
 package etcdmain
 
 import (
+	"errors"
 	"flag"
 	"fmt"
 	"net/url"
@@ -224,7 +225,7 @@ func TestConfigParsingConflictClusteringFlags(t *testing.T) {
 
 	for i, tt := range conflictArgs {
 		cfg := newConfig()
-		if err := cfg.parse(tt); err != embed.ErrConflictBootstrapFlags {
+		if err := cfg.parse(tt); !errors.Is(err, embed.ErrConflictBootstrapFlags) {
 			t.Errorf("%d: err = %v, want %v", i, err, embed.ErrConflictBootstrapFlags)
 		}
 	}
@@ -267,7 +268,7 @@ func TestConfigFileConflictClusteringFlags(t *testing.T) {
 		args := []string{fmt.Sprintf("--config-file=%s", tmpfile.Name())}
 
 		cfg := newConfig()
-		if err := cfg.parse(args); err != embed.ErrConflictBootstrapFlags {
+		if err := cfg.parse(args); !errors.Is(err, embed.ErrConflictBootstrapFlags) {
 			t.Errorf("%d: err = %v, want %v", i, err, embed.ErrConflictBootstrapFlags)
 		}
 	}
@@ -310,7 +311,7 @@ func TestConfigParsingMissedAdvertiseClientURLsFlag(t *testing.T) {
 
 	for i, tt := range tests {
 		cfg := newConfig()
-		if err := cfg.parse(tt.args); err != tt.werr {
+		if err := cfg.parse(tt.args); !errors.Is(err, tt.werr) {
 			t.Errorf("%d: err = %v, want %v", i, err, tt.werr)
 		}
 	}

server/etcdserver/api/membership/cluster_test.go

@@ -16,6 +16,7 @@ package membership
 
 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"path"
 	"reflect"
@@ -458,7 +459,7 @@ func TestClusterValidateConfigurationChangeV2(t *testing.T) {
 	}
 	for i, tt := range tests {
 		err := cl.ValidateConfigurationChange(tt.cc)
-		if err != tt.werr {
+		if !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: validateConfigurationChange error = %v, want %v", i, err, tt.werr)
 		}
 	}

server/etcdserver/api/rafthttp/msg_codec_test.go

@@ -16,6 +16,7 @@ package rafthttp
 
 import (
 	"bytes"
+	"errors"
 	"reflect"
 	"testing"
 
@@ -77,13 +78,13 @@ func TestMessage(t *testing.T) {
 	for i, tt := range tests {
 		b := &bytes.Buffer{}
 		enc := &messageEncoder{w: b}
-		if err := enc.encode(&tt.msg); err != tt.encodeErr {
+		if err := enc.encode(&tt.msg); !errors.Is(err, tt.encodeErr) {
 			t.Errorf("#%d: encode message error expected %v, got %v", i, tt.encodeErr, err)
 			continue
 		}
 		dec := &messageDecoder{r: b}
 		m, err := dec.decode()
-		if err != tt.decodeErr {
+		if !errors.Is(err, tt.decodeErr) {
 			t.Errorf("#%d: decode message error expected %v, got %v", i, tt.decodeErr, err)
 			continue
 		}

server/etcdserver/api/rafthttp/stream.go

@@ -404,7 +404,7 @@ func (cr *streamReader) run() {
 	for {
 		rc, err := cr.dial(t)
 		if err != nil {
-			if err != errUnsupportedStreamType {
+			if !errors.Is(err, errUnsupportedStreamType) {
 				cr.status.deactivate(failureType{source: t.String(), action: "dial"}, err.Error())
 			}
 		} else {

server/etcdserver/api/rafthttp/stream_test.go

@@ -256,7 +256,7 @@ func TestStreamReaderDialDetectUnsupport(t *testing.T) {
 		}
 
 		_, err := sr.dial(typ)
-		if err != errUnsupportedStreamType {
+		if !errors.Is(err, errUnsupportedStreamType) {
 			t.Errorf("#%d: error = %v, want %v", i, err, errUnsupportedStreamType)
 		}
 	}

server/etcdserver/api/snap/snapshotter_test.go

@@ -15,6 +15,7 @@
 package snap
 
 import (
+	"errors"
 	"fmt"
 	"hash/crc32"
 	"os"
@@ -80,7 +81,7 @@ func TestBadCRC(t *testing.T) {
 	crcTable = crc32.MakeTable(crc32.Koopman)
 
 	_, err = Read(zaptest.NewLogger(t), filepath.Join(dir, fmt.Sprintf("%016x-%016x.snap", 1, 1)))
-	if err == nil || err != ErrCRCMismatch {
+	if err == nil || !errors.Is(err, ErrCRCMismatch) {
 		t.Errorf("err = %v, want %v", err, ErrCRCMismatch)
 	}
 }
@@ -221,7 +222,7 @@ func TestNoSnapshot(t *testing.T) {
 	defer os.RemoveAll(dir)
 	ss := New(zaptest.NewLogger(t), dir)
 	_, err = ss.Load()
-	if err != ErrNoSnapshot {
+	if !errors.Is(err, ErrNoSnapshot) {
 		t.Errorf("err = %v, want %v", err, ErrNoSnapshot)
 	}
 }
@@ -240,7 +241,7 @@ func TestEmptySnapshot(t *testing.T) {
 	}
 
 	_, err = Read(zaptest.NewLogger(t), filepath.Join(dir, "1.snap"))
-	if err != ErrEmptySnapshot {
+	if !errors.Is(err, ErrEmptySnapshot) {
 		t.Errorf("err = %v, want %v", err, ErrEmptySnapshot)
 	}
 }
@@ -262,7 +263,7 @@ func TestAllSnapshotBroken(t *testing.T) {
 
 	ss := New(zaptest.NewLogger(t), dir)
 	_, err = ss.Load()
-	if err != ErrNoSnapshot {
+	if !errors.Is(err, ErrNoSnapshot) {
 		t.Errorf("err = %v, want %v", err, ErrNoSnapshot)
 	}
 }

server/etcdserver/api/v2discovery/discovery_test.go

@@ -212,7 +212,7 @@ func TestCheckCluster(t *testing.T) {
 				}
 			}()
 			ns, size, index, err := d.checkCluster()
-			if err != tt.werr {
+			if !errors.Is(err, tt.werr) {
 				t.Errorf("#%d: err = %v, want %v", i, err, tt.werr)
 			}
 			if reflect.DeepEqual(ns, tt.nodes) {
@@ -336,7 +336,7 @@ func TestCreateSelf(t *testing.T) {
 
 	for i, tt := range tests {
 		d := newTestDiscovery(t, "1000", 1, tt.c)
-		if err := d.createSelf(""); err != tt.werr {
+		if err := d.createSelf(""); !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: err = %v, want %v", i, err, nil)
 		}
 	}
@@ -383,7 +383,7 @@ func TestNodesToCluster(t *testing.T) {
 
 	for i, tt := range tests {
 		cluster, err := nodesToCluster(tt.nodes, tt.size)
-		if err != tt.werr {
+		if !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: err = %v, want %v", i, err, tt.werr)
 		}
 		if !reflect.DeepEqual(cluster, tt.wcluster) {
@@ -435,7 +435,7 @@ func TestRetryFailure(t *testing.T) {
 			fc.Advance(time.Second * (0x1 << i))
 		}
 	}()
-	if _, _, _, err := d.checkCluster(); err != ErrTooManyRetries {
+	if _, _, _, err := d.checkCluster(); !errors.Is(err, ErrTooManyRetries) {
 		t.Errorf("err = %v, want %v", err, ErrTooManyRetries)
 	}
 }

server/etcdserver/api/v3compactor/revision.go

@@ -16,6 +16,7 @@ package v3compactor
 
 import (
 	"context"
+	"errors"
 	"sync"
 	"time"
 
@@ -89,7 +90,7 @@ func (rc *Revision) Run() {
 				zap.Int64("revision-compaction-retention", rc.retention),
 			)
 			_, err := rc.c.Compact(rc.ctx, &pb.CompactionRequest{Revision: rev})
-			if err == nil || err == mvcc.ErrCompacted {
+			if err == nil || errors.Is(err, mvcc.ErrCompacted) {
 				prev = rev
 				rc.lg.Info(
 					"completed auto revision compaction",

server/etcdserver/api/v3discovery/discovery_test.go

@@ -91,7 +91,7 @@ func TestGetClusterSize(t *testing.T) {
 				clusterToken: "fakeToken",
 			}
 
-			if cs, err := d.getClusterSize(); err != tc.expectedErr {
+			if cs, err := d.getClusterSize(); !errors.Is(err, tc.expectedErr) {
 				t.Errorf("Unexpected error, expected: %v got: %v", tc.expectedErr, err)
 			} else {
 				if err == nil && cs != tc.expectedSize {
@@ -387,7 +387,7 @@ func TestCheckCluster(t *testing.T) {
 			}
 
 			clsInfo, _, _, err := d.checkCluster()
-			if err != tc.expectedError {
+			if !errors.Is(err, tc.expectedError) {
 				t.Errorf("Unexpected error, expected: %v, got: %v", tc.expectedError, err)
 			}
 
@@ -724,7 +724,7 @@ func TestGetInitClusterStr(t *testing.T) {
 			}
 
 			retStr, err := clsInfo.getInitClusterStr(tc.clusterSize)
-			if err != tc.expectedError {
+			if !errors.Is(err, tc.expectedError) {
 				t.Errorf("Unexpected error, expected: %v, got: %v", tc.expectedError, err)
 			}
 

server/etcdserver/api/v3rpc/util_test.go

@@ -38,7 +38,7 @@ func TestGRPCError(t *testing.T) {
 		{err: errors.New("foo"), exp: status.Error(codes.Unknown, "foo")},
 	}
 	for i := range tt {
-		if err := togRPCError(tt[i].err); err != tt[i].exp {
+		if err := togRPCError(tt[i].err); !errors.Is(err, tt[i].exp) {
 			if _, ok := status.FromError(err); ok {
 				if err.Error() == tt[i].exp.Error() {
 					continue

server/etcdserver/api/v3rpc/watch.go

@@ -281,7 +281,7 @@ func (sws *serverWatchStream) recvLoop() error {
 				case auth.ErrUserEmpty:
 					cancelReason = rpctypes.ErrGRPCUserEmpty.Error()
 				default:
-					if err != auth.ErrPermissionDenied {
+					if !errors.Is(err, auth.ErrPermissionDenied) {
 						sws.lg.Error("unexpected error code", zap.Error(err))
 					}
 					cancelReason = rpctypes.ErrGRPCPermissionDenied.Error()

server/etcdserver/api/v3rpc/watch_test.go

@@ -16,6 +16,7 @@ package v3rpc
 
 import (
 	"bytes"
+	"errors"
 	"math"
 	"testing"
 
@@ -69,7 +70,7 @@ func TestSendFragment(t *testing.T) {
 			return nil
 		}
 		err := sendFragments(tt[i].wr, tt[i].maxRequestBytes, testSend)
-		if err != tt[i].werr {
+		if !errors.Is(err, tt[i].werr) {
 			t.Errorf("#%d: expected error %v, got %v", i, tt[i].werr, err)
 		}
 		got := len(fragmentedResp)

server/etcdserver/server_test.go

@@ -17,6 +17,7 @@ package etcdserver
 import (
 	"context"
 	"encoding/json"
+	errorspkg "errors"
 	"fmt"
 	"math"
 	"net/http"
@@ -388,7 +389,7 @@ func TestApplyConfChangeError(t *testing.T) {
 			cluster: cl,
 		}
 		_, err := srv.applyConfChange(tt.cc, nil, true)
-		if err != tt.werr {
+		if !errorspkg.Is(err, tt.werr) {
 			t.Errorf("#%d: applyConfChange error = %v, want %v", i, err, tt.werr)
 		}
 		cc := raftpb.ConfChange{Type: tt.cc.Type, NodeID: raft.None, Context: tt.cc.Context}
@@ -1533,7 +1534,7 @@ func TestWaitAppliedIndex(t *testing.T) {
 
 			err := s.waitAppliedIndex()
 
-			if err != tc.ExpectedError {
+			if !errorspkg.Is(err, tc.ExpectedError) {
 				t.Errorf("Unexpected error, want (%v), got (%v)", tc.ExpectedError, err)
 			}
 		})

server/lease/lessor_test.go

@@ -16,6 +16,7 @@ package lease
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"path/filepath"
@@ -454,7 +455,7 @@ func TestLessorExpire(t *testing.T) {
 	donec := make(chan struct{}, 1)
 	go func() {
 		// expired lease cannot be renewed
-		if _, err := le.Renew(l.ID); err != ErrLeaseNotFound {
+		if _, err := le.Renew(l.ID); !errors.Is(err, ErrLeaseNotFound) {
 			t.Errorf("unexpected renew")
 		}
 		donec <- struct{}{}
@@ -507,7 +508,7 @@ func TestLessorExpireAndDemote(t *testing.T) {
 	donec := make(chan struct{}, 1)
 	go func() {
 		// expired lease cannot be renewed
-		if _, err := le.Renew(l.ID); err != ErrNotPrimary {
+		if _, err := le.Renew(l.ID); !errors.Is(err, ErrNotPrimary) {
 			t.Errorf("unexpected renew: %v", err)
 		}
 		donec <- struct{}{}
@@ -539,7 +540,7 @@ func TestLessorMaxTTL(t *testing.T) {
 	defer le.Stop()
 
 	_, err := le.Grant(1, MaxLeaseTTL+1)
-	if err != ErrLeaseTTLTooLarge {
+	if !errors.Is(err, ErrLeaseTTLTooLarge) {
 		t.Fatalf("grant unexpectedly succeeded")
 	}
 }

server/storage/mvcc/index_test.go

@@ -15,6 +15,7 @@
 package mvcc
 
 import (
+	"errors"
 	"reflect"
 	"testing"
 
@@ -46,7 +47,7 @@ func TestIndexGet(t *testing.T) {
 	}
 	for i, tt := range tests {
 		rev, created, ver, err := ti.Get([]byte("foo"), tt.rev)
-		if err != tt.werr {
+		if !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: err = %v, want %v", i, err, tt.werr)
 		}
 		if rev != tt.wrev {
@@ -130,11 +131,11 @@ func TestIndexTombstone(t *testing.T) {
 	}
 
 	_, _, _, err = ti.Get([]byte("foo"), 2)
-	if err != ErrRevisionNotFound {
+	if !errors.Is(err, ErrRevisionNotFound) {
 		t.Errorf("get error = %v, want ErrRevisionNotFound", err)
 	}
 	err = ti.Tombstone([]byte("foo"), Revision{Main: 3})
-	if err != ErrRevisionNotFound {
+	if !errors.Is(err, ErrRevisionNotFound) {
 		t.Errorf("tombstone error = %v, want %v", err, ErrRevisionNotFound)
 	}
 }

server/storage/mvcc/key_index_test.go

@@ -15,6 +15,7 @@
 package mvcc
 
 import (
+	"errors"
 	"reflect"
 	"testing"
 
@@ -73,7 +74,7 @@ func TestKeyIndexGet(t *testing.T) {
 
 	for i, tt := range tests {
 		mod, creat, ver, err := ki.get(zaptest.NewLogger(t), tt.rev)
-		if err != tt.werr {
+		if !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: err = %v, want %v", i, err, tt.werr)
 		}
 		if mod != tt.wmod {
@@ -213,7 +214,7 @@ func TestKeyIndexTombstone(t *testing.T) {
 	}
 
 	err = ki.tombstone(zaptest.NewLogger(t), 16, 0)
-	if err != ErrRevisionNotFound {
+	if !errors.Is(err, ErrRevisionNotFound) {
 		t.Errorf("tombstone error = %v, want %v", err, ErrRevisionNotFound)
 	}
 }

server/storage/mvcc/kv_test.go

@@ -16,6 +16,7 @@ package mvcc
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"reflect"
@@ -203,7 +204,7 @@ func testKVRangeBadRev(t *testing.T, f rangeFunc) {
 	}
 	for i, tt := range tests {
 		_, err := f(s, []byte("foo"), []byte("foo3"), RangeOptions{Rev: tt.rev})
-		if err != tt.werr {
+		if !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: error = %v, want %v", i, err, tt.werr)
 		}
 	}
@@ -626,7 +627,7 @@ func TestKVCompactBad(t *testing.T) {
 	}
 	for i, tt := range tests {
 		_, err := s.Compact(traceutil.TODO(), tt.rev)
-		if err != tt.werr {
+		if !errors.Is(err, tt.werr) {
 			t.Errorf("#%d: compact error = %v, want %v", i, err, tt.werr)
 		}
 	}

server/storage/mvcc/kvstore_test.go

@@ -19,6 +19,7 @@ import (
 	"context"
 	"crypto/rand"
 	"encoding/binary"
+	"errors"
 	"fmt"
 	"math"
 	mrand "math/rand"
@@ -518,7 +519,7 @@ func TestRestoreContinueUnfinishedCompaction(t *testing.T) {
 			// wait for scheduled compaction to be finished
 			time.Sleep(100 * time.Millisecond)
 
-			if _, err := s.Range(context.TODO(), []byte("foo"), nil, RangeOptions{Rev: 1}); err != ErrCompacted {
+			if _, err := s.Range(context.TODO(), []byte("foo"), nil, RangeOptions{Rev: 1}); !errors.Is(err, ErrCompacted) {
 				t.Errorf("range on compacted rev error = %v, want %v", err, ErrCompacted)
 			}
 			// check the key in backend is deleted

server/storage/mvcc/watcher_test.go

@@ -16,6 +16,7 @@ package mvcc
 
 import (
 	"bytes"
+	"errors"
 	"fmt"
 	"os"
 	"reflect"
@@ -108,7 +109,7 @@ func TestWatcherRequestsCustomID(t *testing.T) {
 	for i, tcase := range tt {
 		id, err := w.Watch(tcase.givenID, []byte("foo"), nil, 0)
 		if tcase.expectedErr != nil || err != nil {
-			if err != tcase.expectedErr {
+			if !errors.Is(err, tcase.expectedErr) {
 				t.Errorf("expected get error %q in test case %q, got %q", tcase.expectedErr, i, err)
 			}
 		} else if tcase.expectedID != id {
@@ -201,10 +202,10 @@ func TestWatcherWatchWrongRange(t *testing.T) {
 	w := s.NewWatchStream()
 	defer w.Close()
 
-	if _, err := w.Watch(0, []byte("foa"), []byte("foa"), 1); err != ErrEmptyWatcherRange {
+	if _, err := w.Watch(0, []byte("foa"), []byte("foa"), 1); !errors.Is(err, ErrEmptyWatcherRange) {
 		t.Fatalf("key == end range given; expected ErrEmptyWatcherRange, got %+v", err)
 	}
-	if _, err := w.Watch(0, []byte("fob"), []byte("foa"), 1); err != ErrEmptyWatcherRange {
+	if _, err := w.Watch(0, []byte("fob"), []byte("foa"), 1); !errors.Is(err, ErrEmptyWatcherRange) {
 		t.Fatalf("key > end range given; expected ErrEmptyWatcherRange, got %+v", err)
 	}
 	// watch request with 'WithFromKey' has empty-byte range end
@@ -278,7 +279,7 @@ func TestWatchStreamCancelWatcherByID(t *testing.T) {
 	for i, tt := range tests {
 		gerr := w.Cancel(tt.cancelID)
 
-		if gerr != tt.werr {
+		if !errors.Is(gerr, tt.werr) {
 			t.Errorf("#%d: err = %v, want %v", i, gerr, tt.werr)
 		}
 	}

server/storage/schema/actions_test.go

@@ -15,6 +15,7 @@
 package schema
 
 import (
+	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -135,7 +136,7 @@ func TestActionListRevert(t *testing.T) {
 
 			UnsafeCreateMetaBucket(tx)
 			err := tc.actions.unsafeExecute(lg, tx)
-			if err != tc.expectError {
+			if !errors.Is(err, tc.expectError) {
 				t.Errorf("Unexpected error or lack thereof, expected: %v, got: %v", tc.expectError, err)
 			}
 			assertBucketState(t, tx, Meta, tc.expectState)

server/storage/schema/migration_test.go

@@ -15,6 +15,7 @@
 package schema
 
 import (
+	"errors"
 	"fmt"
 	"testing"
 	"time"
@@ -178,7 +179,7 @@ func TestMigrationStepExecute(t *testing.T) {
 
 			step := newMigrationStep(tc.currentVersion, tc.isUpgrade, tc.changes)
 			err := step.unsafeExecute(lg, tx)
-			if err != tc.expectError {
+			if !errors.Is(err, tc.expectError) {
 				t.Errorf("Unexpected error or lack thereof, expected: %v, got: %v", tc.expectError, err)
 			}
 			v := UnsafeReadStorageVersion(tx)

server/storage/wal/decoder.go

@@ -90,7 +90,7 @@ func (d *decoder) decodeRecord(rec *walpb.Record) error {
 
 	fileBufReader := d.brs[0]
 	l, err := readInt64(fileBufReader)
-	if err == io.EOF || (err == nil && l == 0) {
+	if errors.Is(err, io.EOF) || (err == nil && l == 0) {
 		// hit end of file or preallocated space
 		d.brs = d.brs[1:]
 		if len(d.brs) == 0 {

server/storage/wal/repair_test.go

@@ -15,6 +15,7 @@
 package wal
 
 import (
+	"errors"
 	"fmt"
 	"io"
 	"os"
@@ -202,7 +203,7 @@ func TestRepairFailDeleteDir(t *testing.T) {
 		t.Fatal(err)
 	}
 	_, _, _, err = w.ReadAll()
-	if err != io.ErrUnexpectedEOF {
+	if !errors.Is(err, io.ErrUnexpectedEOF) {
 		t.Fatalf("err = %v, want error %v", err, io.ErrUnexpectedEOF)
 	}
 	w.Close()

server/storage/wal/wal_test.go

@@ -170,7 +170,7 @@ func TestCreateFailFromPollutedDir(t *testing.T) {
 	os.WriteFile(filepath.Join(p, "test.wal"), []byte("data"), os.ModeTemporary)
 
 	_, err := Create(zaptest.NewLogger(t), p, []byte("data"))
-	if err != os.ErrExist {
+	if !errors.Is(err, os.ErrExist) {
 		t.Fatalf("expected %v, got %v", os.ErrExist, err)
 	}
 }
@@ -221,7 +221,7 @@ func TestNewForInitedDir(t *testing.T) {
 	p := t.TempDir()
 
 	os.Create(filepath.Join(p, walName(0, 0)))
-	if _, err := Create(zaptest.NewLogger(t), p, nil); err == nil || err != os.ErrExist {
+	if _, err := Create(zaptest.NewLogger(t), p, nil); err == nil || !errors.Is(err, os.ErrExist) {
 		t.Errorf("err = %v, want %v", err, os.ErrExist)
 	}
 }
@@ -732,7 +732,7 @@ func TestOpenWithMaxIndex(t *testing.T) {
 	defer w2.Close()
 
 	_, _, _, err = w2.ReadAll()
-	if err != ErrSliceOutOfRange {
+	if !errors.Is(err, ErrSliceOutOfRange) {
 		t.Fatalf("err = %v, want ErrSliceOutOfRange", err)
 	}
 }
@@ -1033,7 +1033,7 @@ func TestReadAllFail(t *testing.T) {
 	f.Close()
 	// try to read without opening the WAL
 	_, _, _, err = f.ReadAll()
-	if err == nil || err != ErrDecoderNotFound {
+	if err == nil || !errors.Is(err, ErrDecoderNotFound) {
 		t.Fatalf("err = %v, want ErrDecoderNotFound", err)
 	}
 }