refactor: apply staticchecks

Signed-off-by: Rueian <rueiancsie@gmail.com>

cache_test.go

@@ -44,7 +44,7 @@ func test(t *testing.T, storeFn func() CacheStore) {
 			t.Fatal("CachePXAT should return a desired pttl")
 		}
 
-		v2, e2 = store.Flight("key", "cmd", time.Millisecond*100, now)
+		v2, _ = store.Flight("key", "cmd", time.Millisecond*100, now)
 		if v2.typ != v.typ || v2.string != v.string {
 			t.Fatal("flights after Update should return updated RedisMessage")
 		}

cluster_test.go

@@ -2696,10 +2696,7 @@ func TestClusterClient_SendReadOperationToReplicaNodesWriteOperationToPrimaryNod
 		&ClientOption{
 			InitAddress: []string{"127.0.0.1:0"},
 			SendToReplicas: func(cmd Completed) bool {
-				if cmd.IsReadOnly() {
-					return true
-				}
-				return false
+				return cmd.IsReadOnly()
 			},
 		},
 		func(dst string, opt *ClientOption) conn {

mux_test.go

@@ -456,7 +456,7 @@ func TestMuxDelegation(t *testing.T) {
 					result := make([]RedisResult, len(multi))
 					for j, cmd := range multi {
 						if s := cmd.Cmd.Slot() & uint16(len(wires)-1); s != idx {
-							result[j] = newErrResult(errors.New(fmt.Sprintf("wrong slot %v %v", s, idx)))
+							result[j] = newErrResult(fmt.Errorf("wrong slot %v %v", s, idx))
 						} else {
 							result[j] = newResult(RedisMessage{typ: '+', string: cmd.Cmd.Commands()[1]}, nil)
 						}
@@ -497,7 +497,7 @@ func TestMuxDelegation(t *testing.T) {
 				DoMultiCacheFn: func(multi ...CacheableTTL) *redisresults {
 					for _, cmd := range multi {
 						if s := cmd.Cmd.Slot() & uint16(len(wires)-1); s != idx {
-							return &redisresults{s: []RedisResult{newErrResult(errors.New(fmt.Sprintf("wrong slot %v %v", s, idx)))}}
+							return &redisresults{s: []RedisResult{newErrResult(fmt.Errorf("wrong slot %v %v", s, idx))}}
 						}
 					}
 					return &redisresults{s: []RedisResult{newErrResult(context.DeadlineExceeded)}}
@@ -896,7 +896,6 @@ func (m *mockWire) CleanSubscriptions() {
 	if m.CleanSubscriptionsFn != nil {
 		m.CleanSubscriptionsFn()
 	}
-	return
 }
 
 func (m *mockWire) SetPubSubHooks(hooks PubSubHooks) <-chan error {
@@ -910,7 +909,6 @@ func (m *mockWire) SetOnCloseHook(fn func(error)) {
 	if m.SetOnCloseHookFn != nil {
 		m.SetOnCloseHookFn(fn)
 	}
-	return
 }
 
 func (m *mockWire) Info() map[string]RedisMessage {

pipe.go

@@ -1164,8 +1164,8 @@ func (p *pipe) syncDo(dl time.Time, dlOk bool, cmd Completed) (resp RedisResult)
 	}
 
 	var msg RedisMessage
-	err := writeCmd(p.w, cmd.Commands())
-	if err = p.w.Flush(); err == nil {
+	err := flushCmd(p.w, cmd.Commands())
+	if err == nil {
 		msg, err = syncRead(p.r)
 	}
 	if err != nil {
@@ -1225,7 +1225,6 @@ abort:
 	for i := 0; i < len(resp); i++ {
 		resp[i] = newErrResult(err)
 	}
-	return
 }
 
 func syncRead(r *bufio.Reader) (m RedisMessage, err error) {

pipe_test.go

@@ -110,7 +110,7 @@ func write(o io.Writer, m RedisMessage) (err error) {
 	_, err = o.Write([]byte{m.typ})
 	switch m.typ {
 	case '$':
-		_, err = o.Write(append([]byte(strconv.Itoa(len(m.string))), '\r', '\n'))
+		_, _ = o.Write(append([]byte(strconv.Itoa(len(m.string))), '\r', '\n'))
 		_, err = o.Write(append([]byte(m.string), '\r', '\n'))
 	case '+', '-', '_':
 		_, err = o.Write(append([]byte(m.string), '\r', '\n'))

resp.go

@@ -375,6 +375,11 @@ func writeCmd(o *bufio.Writer, cmd []string) (err error) {
 	return err
 }
 
+func flushCmd(o *bufio.Writer, cmd []string) (err error) {
+	_ = writeCmd(o, cmd)
+	return o.Flush()
+}
+
 const (
 	unexpectedNoCRLF   = "received unexpected simple string message ending without CRLF"
 	unexpectedNumByte  = "received unexpected number byte: "

resp_test.go

@@ -3,13 +3,13 @@ package rueidis
 import (
 	"bufio"
 	"bytes"
+	crand "crypto/rand"
 	"io"
 	"math/rand"
 	"reflect"
 	"strconv"
 	"strings"
 	"testing"
-	"time"
 )
 
 const iteration = 100
@@ -18,8 +18,6 @@ var generators = map[byte]func(i int64, f float64, str string) string{}
 
 //gocyclo:ignore
 func init() {
-	rand.Seed(time.Now().UnixNano())
-
 	generators['$'] = func(i int64, f float64, str string) string {
 		return strconv.Itoa(len(str)) + "\r\n" + str + "\r\n"
 	}
@@ -683,7 +681,7 @@ func source(str string) *bufio.Reader {
 func random(trim bool) string {
 retry:
 	bs := make([]byte, randN(5000))
-	if _, err := rand.Read(bs); err != nil {
+	if _, err := crand.Read(bs); err != nil {
 		panic(err)
 	}
 	if trim {

ring.go

@@ -27,7 +27,7 @@ func newRing(factor int) *ring {
 		m := &sync.Mutex{}
 		r.store[i].c1 = sync.NewCond(m)
 		r.store[i].c2 = sync.NewCond(m)
-		r.store[i].ch = make(chan RedisResult, 0) // this channel can't be buffered
+		r.store[i].ch = make(chan RedisResult) // this channel can't be buffered
 	}
 	return r
 }

ring_test.go

@@ -128,12 +128,12 @@ func TestRing(t *testing.T) {
 
 	t.Run("PutMulti Wakeup WaitForWrite", func(t *testing.T) {
 		ring := newRing(DefaultRingScale)
-		if _, multi, ch := ring.NextWriteCmd(); ch == nil {
+		if _, _, ch := ring.NextWriteCmd(); ch == nil {
 			go func() {
 				time.Sleep(time.Millisecond * 100)
 				ring.PutMulti([]Completed{cmds.PingCmd}, nil)
 			}()
-			if _, multi, ch = ring.WaitForWrite(); ch != nil && multi[0].Commands()[0] == cmds.PingCmd.Commands()[0] {
+			if _, multi, ch := ring.WaitForWrite(); ch != nil && multi[0].Commands()[0] == cmds.PingCmd.Commands()[0] {
 				return
 			}
 		}

rueidislock/lock_test.go

@@ -35,11 +35,11 @@ func newClient(t *testing.T) rueidis.Client {
 }
 
 func TestNewLocker(t *testing.T) {
-	l, err := NewLocker(LockerOption{ClientOption: rueidis.ClientOption{InitAddress: nil}})
+	_, err := NewLocker(LockerOption{ClientOption: rueidis.ClientOption{InitAddress: nil}})
 	if err == nil {
 		t.Fatal(err)
 	}
-	l, err = NewLocker(LockerOption{ClientOption: rueidis.ClientOption{InitAddress: address}})
+	l, err := NewLocker(LockerOption{ClientOption: rueidis.ClientOption{InitAddress: address}})
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -244,7 +244,7 @@ func TestLocker_WithContext_DeadContext(t *testing.T) {
 
 		ctx, cancel := context.WithCancel(context.Background())
 		cancel()
-		ctx, cancel, err := locker.WithContext(ctx, strconv.Itoa(rand.Int()))
+		_, _, err := locker.WithContext(ctx, strconv.Itoa(rand.Int()))
 		if !errors.Is(err, context.Canceled) {
 			t.Fatal(err)
 		}
@@ -589,7 +589,7 @@ func TestLocker_Flush(t *testing.T) {
 			t.Fatal(err)
 		}
 
-		ctx, cancel, err := locker.WithContext(context.Background(), strconv.Itoa(rand.Int()))
+		_, cancel, err := locker.WithContext(context.Background(), strconv.Itoa(rand.Int()))
 		if err != nil {
 			t.Fatal(err)
 		}

singleflight.go

@@ -48,7 +48,7 @@ func (c *call) LazyDo(threshold time.Duration, fn func() error) {
 	c.cn++
 	ts := c.ts
 	c.mu.Unlock()
-	time.Sleep(ts.Add(threshold).Sub(time.Now()))
+	time.Sleep(time.Until(ts.Add(threshold)))
 	go c.do(ch, fn)
 }