Merge pull request #1255 from git-hulk/master

Exported the setErr function as public

Author: vmihailenco

cluster.go

@@ -743,7 +743,7 @@ func (c *ClusterClient) ProcessContext(ctx context.Context, cmd Cmder) error {
 func (c *ClusterClient) process(ctx context.Context, cmd Cmder) error {
 	err := c._process(ctx, cmd)
 	if err != nil {
-		cmd.setErr(err)
+		cmd.SetErr(err)
 		return err
 	}
 	return nil

cluster_commands.go

@@ -14,7 +14,7 @@ func (c *ClusterClient) DBSize() *IntCmd {
 		return nil
 	})
 	if err != nil {
-		cmd.setErr(err)
+		cmd.SetErr(err)
 		return cmd
 	}
 	cmd.val = size

command.go

@@ -20,14 +20,14 @@ type Cmder interface {
 	readTimeout() *time.Duration
 	readReply(rd *proto.Reader) error
 
-	setErr(error)
+	SetErr(error)
 	Err() error
 }
 
 func setCmdsErr(cmds []Cmder, e error) {
 	for _, cmd := range cmds {
 		if cmd.Err() == nil {
-			cmd.setErr(e)
+			cmd.SetErr(e)
 		}
 	}
 }
@@ -119,7 +119,7 @@ func (cmd *baseCmd) stringArg(pos int) string {
 	return s
 }
 
-func (cmd *baseCmd) setErr(e error) {
+func (cmd *baseCmd) SetErr(e error) {
 	cmd.err = e
 }
 

command_test.go

@@ -1,9 +1,10 @@
 package redis_test
 
 import (
+	"errors"
 	"time"
 
-	"github.com/go-redis/redis/v7"
+	redis "github.com/go-redis/redis/v7"
 
 	. "github.com/onsi/ginkgo"
 	. "github.com/onsi/gomega"
@@ -84,4 +85,12 @@ var _ = Describe("Cmd", func() {
 		Expect(err).NotTo(HaveOccurred())
 		Expect(tm2).To(BeTemporally("==", tm))
 	})
+
+	It("allow to set custom error", func() {
+		e := errors.New("custom error")
+		cmd := redis.Cmd{}
+		cmd.SetErr(e)
+		_, err := cmd.Result()
+		Expect(err).To(Equal(e))
+	})
 })

commands.go

@@ -2537,7 +2537,7 @@ func (c cmdable) GeoAdd(key string, geoLocation ...*GeoLocation) *IntCmd {
 func (c cmdable) GeoRadius(key string, longitude, latitude float64, query *GeoRadiusQuery) *GeoLocationCmd {
 	cmd := NewGeoLocationCmd(query, "georadius_ro", key, longitude, latitude)
 	if query.Store != "" || query.StoreDist != "" {
-		cmd.setErr(errors.New("GeoRadius does not support Store or StoreDist"))
+		cmd.SetErr(errors.New("GeoRadius does not support Store or StoreDist"))
 		return cmd
 	}
 	_ = c(cmd)
@@ -2549,7 +2549,7 @@ func (c cmdable) GeoRadiusStore(key string, longitude, latitude float64, query *
 	args := geoLocationArgs(query, "georadius", key, longitude, latitude)
 	cmd := NewIntCmd(args...)
 	if query.Store == "" && query.StoreDist == "" {
-		cmd.setErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
+		cmd.SetErr(errors.New("GeoRadiusStore requires Store or StoreDist"))
 		return cmd
 	}
 	_ = c(cmd)
@@ -2560,7 +2560,7 @@ func (c cmdable) GeoRadiusStore(key string, longitude, latitude float64, query *
 func (c cmdable) GeoRadiusByMember(key, member string, query *GeoRadiusQuery) *GeoLocationCmd {
 	cmd := NewGeoLocationCmd(query, "georadiusbymember_ro", key, member)
 	if query.Store != "" || query.StoreDist != "" {
-		cmd.setErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
+		cmd.SetErr(errors.New("GeoRadiusByMember does not support Store or StoreDist"))
 		return cmd
 	}
 	_ = c(cmd)
@@ -2572,7 +2572,7 @@ func (c cmdable) GeoRadiusByMemberStore(key, member string, query *GeoRadiusQuer
 	args := geoLocationArgs(query, "georadiusbymember", key, member)
 	cmd := NewIntCmd(args...)
 	if query.Store == "" && query.StoreDist == "" {
-		cmd.setErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
+		cmd.SetErr(errors.New("GeoRadiusByMemberStore requires Store or StoreDist"))
 		return cmd
 	}
 	_ = c(cmd)

redis.go

@@ -51,14 +51,14 @@ func (hs hooks) process(
 ) error {
 	ctx, err := hs.beforeProcess(ctx, cmd)
 	if err != nil {
-		cmd.setErr(err)
+		cmd.SetErr(err)
 		return err
 	}
 
 	cmdErr := fn(ctx, cmd)
 
 	if err := hs.afterProcess(ctx, cmd); err != nil {
-		cmd.setErr(err)
+		cmd.SetErr(err)
 		return err
 	}
 
@@ -287,7 +287,7 @@ func (c *baseClient) withConn(
 func (c *baseClient) process(ctx context.Context, cmd Cmder) error {
 	err := c._process(ctx, cmd)
 	if err != nil {
-		cmd.setErr(err)
+		cmd.SetErr(err)
 		return err
 	}
 	return nil

result.go

@@ -6,111 +6,111 @@ import "time"
 func NewCmdResult(val interface{}, err error) *Cmd {
 	var cmd Cmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewSliceResult returns a SliceCmd initialised with val and err for testing
 func NewSliceResult(val []interface{}, err error) *SliceCmd {
 	var cmd SliceCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewStatusResult returns a StatusCmd initialised with val and err for testing
 func NewStatusResult(val string, err error) *StatusCmd {
 	var cmd StatusCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewIntResult returns an IntCmd initialised with val and err for testing
 func NewIntResult(val int64, err error) *IntCmd {
 	var cmd IntCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewDurationResult returns a DurationCmd initialised with val and err for testing
 func NewDurationResult(val time.Duration, err error) *DurationCmd {
 	var cmd DurationCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewBoolResult returns a BoolCmd initialised with val and err for testing
 func NewBoolResult(val bool, err error) *BoolCmd {
 	var cmd BoolCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewStringResult returns a StringCmd initialised with val and err for testing
 func NewStringResult(val string, err error) *StringCmd {
 	var cmd StringCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewFloatResult returns a FloatCmd initialised with val and err for testing
 func NewFloatResult(val float64, err error) *FloatCmd {
 	var cmd FloatCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewStringSliceResult returns a StringSliceCmd initialised with val and err for testing
 func NewStringSliceResult(val []string, err error) *StringSliceCmd {
 	var cmd StringSliceCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewBoolSliceResult returns a BoolSliceCmd initialised with val and err for testing
 func NewBoolSliceResult(val []bool, err error) *BoolSliceCmd {
 	var cmd BoolSliceCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewStringStringMapResult returns a StringStringMapCmd initialised with val and err for testing
 func NewStringStringMapResult(val map[string]string, err error) *StringStringMapCmd {
 	var cmd StringStringMapCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewStringIntMapCmdResult returns a StringIntMapCmd initialised with val and err for testing
 func NewStringIntMapCmdResult(val map[string]int64, err error) *StringIntMapCmd {
 	var cmd StringIntMapCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewZSliceCmdResult returns a ZSliceCmd initialised with val and err for testing
 func NewZSliceCmdResult(val []Z, err error) *ZSliceCmd {
 	var cmd ZSliceCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewZWithKeyCmdResult returns a NewZWithKeyCmd initialised with val and err for testing
 func NewZWithKeyCmdResult(val *ZWithKey, err error) *ZWithKeyCmd {
 	var cmd ZWithKeyCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
@@ -119,54 +119,54 @@ func NewScanCmdResult(keys []string, cursor uint64, err error) *ScanCmd {
 	var cmd ScanCmd
 	cmd.page = keys
 	cmd.cursor = cursor
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewClusterSlotsCmdResult returns a ClusterSlotsCmd initialised with val and err for testing
 func NewClusterSlotsCmdResult(val []ClusterSlot, err error) *ClusterSlotsCmd {
 	var cmd ClusterSlotsCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewGeoLocationCmdResult returns a GeoLocationCmd initialised with val and err for testing
 func NewGeoLocationCmdResult(val []GeoLocation, err error) *GeoLocationCmd {
 	var cmd GeoLocationCmd
 	cmd.locations = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewGeoPosCmdResult returns a GeoPosCmd initialised with val and err for testing
 func NewGeoPosCmdResult(val []*GeoPos, err error) *GeoPosCmd {
 	var cmd GeoPosCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewCommandsInfoCmdResult returns a CommandsInfoCmd initialised with val and err for testing
 func NewCommandsInfoCmdResult(val map[string]*CommandInfo, err error) *CommandsInfoCmd {
 	var cmd CommandsInfoCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewXMessageSliceCmdResult returns a XMessageSliceCmd initialised with val and err for testing
 func NewXMessageSliceCmdResult(val []XMessage, err error) *XMessageSliceCmd {
 	var cmd XMessageSliceCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }
 
 // NewXStreamSliceCmdResult returns a XStreamSliceCmd initialised with val and err for testing
 func NewXStreamSliceCmdResult(val []XStream, err error) *XStreamSliceCmd {
 	var cmd XStreamSliceCmd
 	cmd.val = val
-	cmd.setErr(err)
+	cmd.SetErr(err)
 	return &cmd
 }

ring.go

@@ -561,7 +561,7 @@ func (c *Ring) cmdShard(cmd Cmder) (*ringShard, error) {
 func (c *Ring) process(ctx context.Context, cmd Cmder) error {
 	err := c._process(ctx, cmd)
 	if err != nil {
-		cmd.setErr(err)
+		cmd.SetErr(err)
 		return err
 	}
 	return nil