fix: command - always return non-nil command when parsing (fix #27)

To avoid panic when calling pcmd.Error in handlers.parse.

internal/command/conn/echo.go

@@ -15,18 +15,18 @@ type Echo struct {
 	parts []string
 }
 
-func ParseEcho(b redis.BaseCmd) (*Echo, error) {
+func ParseEcho(b redis.BaseCmd) (Echo, error) {
-	cmd := &Echo{BaseCmd: b}
+	cmd := Echo{BaseCmd: b}
 	err := parser.New(
 		parser.Strings(&cmd.parts),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Echo{}, err
 	}
 	return cmd, nil
 }
 
-func (c *Echo) Run(w redis.Writer, _ redis.Redka) (any, error) {
+func (c Echo) Run(w redis.Writer, _ redis.Redka) (any, error) {
 	out := strings.Join(c.parts, " ")
 	w.WriteAny(out)
 	return out, nil

internal/command/conn/echo_test.go

@@ -37,6 +37,8 @@ func TestEchoParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.parts, test.want)
+			} else {
+				testx.AssertEqual(t, cmd, Echo{})
 			}
 		})
 	}

internal/command/conn/ping.go

@@ -16,18 +16,18 @@ type Ping struct {
 	message string
 }
 
-func ParsePing(b redis.BaseCmd) (*Ping, error) {
+func ParsePing(b redis.BaseCmd) (Ping, error) {
-	cmd := &Ping{BaseCmd: b}
+	cmd := Ping{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.message),
 	).Required(0).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Ping{}, err
 	}
 	return cmd, nil
 }
 
-func (c *Ping) Run(w redis.Writer, _ redis.Redka) (any, error) {
+func (c Ping) Run(w redis.Writer, _ redis.Redka) (any, error) {
 	if c.message == "" {
 		w.WriteAny(PONG)
 		return PONG, nil

internal/command/conn/ping_test.go

@@ -36,6 +36,8 @@ func TestPingParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.message, test.want)
+			} else {
+				testx.AssertEqual(t, cmd, Ping{})
 			}
 		})
 	}

internal/command/hash/hdel.go

@@ -15,19 +15,19 @@ type HDel struct {
 	fields []string
 }
 
-func ParseHDel(b redis.BaseCmd) (*HDel, error) {
+func ParseHDel(b redis.BaseCmd) (HDel, error) {
-	cmd := &HDel{BaseCmd: b}
+	cmd := HDel{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Strings(&cmd.fields),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return HDel{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *HDel) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HDel) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Hash().Delete(cmd.key, cmd.fields...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hdel_test.go

@@ -48,6 +48,8 @@ func TestHDelParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.fields, test.fields)
+			} else {
+				testx.AssertEqual(t, cmd, HDel{})
 			}
 		})
 	}

internal/command/hash/hexists.go

@@ -11,17 +11,17 @@ type HExists struct {
 	field string
 }
 
-func ParseHExists(b redis.BaseCmd) (*HExists, error) {
+func ParseHExists(b redis.BaseCmd) (HExists, error) {
-	cmd := &HExists{BaseCmd: b}
+	cmd := HExists{BaseCmd: b}
 	if len(cmd.Args()) != 2 {
-		return cmd, redis.ErrInvalidArgNum
+		return HExists{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	cmd.field = string(cmd.Args()[1])
 	return cmd, nil
 }
 
-func (cmd *HExists) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HExists) Run(w redis.Writer, red redis.Redka) (any, error) {
 	ok, err := red.Hash().Exists(cmd.key, cmd.field)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hexists_test.go

@@ -47,6 +47,8 @@ func TestHExistsParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.field, test.field)
+			} else {
+				testx.AssertEqual(t, cmd, HExists{})
 			}
 		})
 	}

internal/command/hash/hget.go

@@ -14,17 +14,17 @@ type HGet struct {
 	field string
 }
 
-func ParseHGet(b redis.BaseCmd) (*HGet, error) {
+func ParseHGet(b redis.BaseCmd) (HGet, error) {
-	cmd := &HGet{BaseCmd: b}
+	cmd := HGet{BaseCmd: b}
 	if len(cmd.Args()) != 2 {
-		return cmd, redis.ErrInvalidArgNum
+		return HGet{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	cmd.field = string(cmd.Args()[1])
 	return cmd, nil
 }
 
-func (cmd *HGet) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HGet) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.Hash().Get(cmd.key, cmd.field)
 	if err == core.ErrNotFound {
 		w.WriteNull()

internal/command/hash/hget_test.go

@@ -48,6 +48,8 @@ func TestHGetParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.field, test.field)
+			} else {
+				testx.AssertEqual(t, cmd, HGet{})
 			}
 		})
 	}

internal/command/hash/hgetall.go

@@ -10,16 +10,16 @@ type HGetAll struct {
 	key string
 }
 
-func ParseHGetAll(b redis.BaseCmd) (*HGetAll, error) {
+func ParseHGetAll(b redis.BaseCmd) (HGetAll, error) {
-	cmd := &HGetAll{BaseCmd: b}
+	cmd := HGetAll{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return HGetAll{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *HGetAll) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HGetAll) Run(w redis.Writer, red redis.Redka) (any, error) {
 	items, err := red.Hash().Items(cmd.key)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hgetall_test.go

@@ -37,6 +37,8 @@ func TestHGetAllParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, HGetAll{})
 			}
 		})
 	}

internal/command/hash/hincrby.go

@@ -16,20 +16,20 @@ type HIncrBy struct {
 	delta int
 }
 
-func ParseHIncrBy(b redis.BaseCmd) (*HIncrBy, error) {
+func ParseHIncrBy(b redis.BaseCmd) (HIncrBy, error) {
-	cmd := &HIncrBy{BaseCmd: b}
+	cmd := HIncrBy{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.String(&cmd.field),
 		parser.Int(&cmd.delta),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return HIncrBy{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *HIncrBy) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HIncrBy) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.Hash().Incr(cmd.key, cmd.field, cmd.delta)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hincrby_test.go

@@ -51,6 +51,8 @@ func TestHIncrByParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.field, test.field)
 				testx.AssertEqual(t, cmd.delta, test.delta)
+			} else {
+				testx.AssertEqual(t, cmd, HIncrBy{})
 			}
 		})
 	}

internal/command/hash/hincrbyfloat.go

@@ -16,20 +16,20 @@ type HIncrByFloat struct {
 	delta float64
 }
 
-func ParseHIncrByFloat(b redis.BaseCmd) (*HIncrByFloat, error) {
+func ParseHIncrByFloat(b redis.BaseCmd) (HIncrByFloat, error) {
-	cmd := &HIncrByFloat{BaseCmd: b}
+	cmd := HIncrByFloat{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.String(&cmd.field),
 		parser.Float(&cmd.delta),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return HIncrByFloat{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *HIncrByFloat) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HIncrByFloat) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.Hash().IncrFloat(cmd.key, cmd.field, cmd.delta)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hincrbyfloat_test.go

@@ -51,6 +51,8 @@ func TestHIncrByFloatParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.field, test.field)
 				testx.AssertEqual(t, cmd.delta, test.delta)
+			} else {
+				testx.AssertEqual(t, cmd, HIncrByFloat{})
 			}
 		})
 	}

internal/command/hash/hkeys.go

@@ -10,16 +10,16 @@ type HKeys struct {
 	key string
 }
 
-func ParseHKeys(b redis.BaseCmd) (*HKeys, error) {
+func ParseHKeys(b redis.BaseCmd) (HKeys, error) {
-	cmd := &HKeys{BaseCmd: b}
+	cmd := HKeys{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return HKeys{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *HKeys) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HKeys) Run(w redis.Writer, red redis.Redka) (any, error) {
 	fields, err := red.Hash().Fields(cmd.key)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hkeys_test.go

@@ -36,6 +36,8 @@ func TestHKeysParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, HKeys{})
 			}
 		})
 	}

internal/command/hash/hlen.go

@@ -10,16 +10,16 @@ type HLen struct {
 	key string
 }
 
-func ParseHLen(b redis.BaseCmd) (*HLen, error) {
+func ParseHLen(b redis.BaseCmd) (HLen, error) {
-	cmd := &HLen{BaseCmd: b}
+	cmd := HLen{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return HLen{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *HLen) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HLen) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Hash().Len(cmd.key)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hlen_test.go

@@ -36,6 +36,8 @@ func TestHLenParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, HLen{})
 			}
 		})
 	}

internal/command/hash/hmget.go

@@ -15,19 +15,19 @@ type HMGet struct {
 	fields []string
 }
 
-func ParseHMGet(b redis.BaseCmd) (*HMGet, error) {
+func ParseHMGet(b redis.BaseCmd) (HMGet, error) {
-	cmd := &HMGet{BaseCmd: b}
+	cmd := HMGet{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Strings(&cmd.fields),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return HMGet{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *HMGet) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HMGet) Run(w redis.Writer, red redis.Redka) (any, error) {
 	// Get the field-value map for requested fields.
 	items, err := red.Hash().GetMany(cmd.key, cmd.fields...)
 	if err != nil {

internal/command/hash/hmget_test.go

@@ -48,6 +48,8 @@ func TestHMGetParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.fields, test.fields)
+			} else {
+				testx.AssertEqual(t, cmd, HMGet{})
 			}
 		})
 	}

internal/command/hash/hmset.go

@@ -14,19 +14,19 @@ type HMSet struct {
 	items map[string]any
 }
 
-func ParseHMSet(b redis.BaseCmd) (*HMSet, error) {
+func ParseHMSet(b redis.BaseCmd) (HMSet, error) {
-	cmd := &HMSet{BaseCmd: b}
+	cmd := HMSet{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.AnyMap(&cmd.items),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return HMSet{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *HMSet) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HMSet) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Hash().SetMany(cmd.key, cmd.items)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hmset_test.go

@@ -55,6 +55,8 @@ func TestHMSetParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.items, test.want.items)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/hash/hscan.go

@@ -16,8 +16,8 @@ type HScan struct {
 	count  int
 }
 
-func ParseHScan(b redis.BaseCmd) (*HScan, error) {
+func ParseHScan(b redis.BaseCmd) (HScan, error) {
-	cmd := &HScan{BaseCmd: b}
+	cmd := HScan{BaseCmd: b}
 
 	err := parser.New(
 		parser.String(&cmd.key),
@@ -26,7 +26,7 @@ func ParseHScan(b redis.BaseCmd) (*HScan, error) {
 		parser.Named("count", parser.Int(&cmd.count)),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return HScan{}, err
 	}
 
 	// all keys by default
@@ -37,7 +37,7 @@ func ParseHScan(b redis.BaseCmd) (*HScan, error) {
 	return cmd, nil
 }
 
-func (cmd *HScan) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HScan) Run(w redis.Writer, red redis.Redka) (any, error) {
 	res, err := red.Hash().Scan(cmd.key, cmd.cursor, cmd.match, cmd.count)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hscan_test.go

@@ -109,6 +109,8 @@ func TestHScanParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.cursor, test.cursor)
 				testx.AssertEqual(t, cmd.match, test.match)
 				testx.AssertEqual(t, cmd.count, test.count)
+			} else {
+				testx.AssertEqual(t, cmd, HScan{})
 			}
 		})
 	}

internal/command/hash/hset.go

@@ -14,19 +14,19 @@ type HSet struct {
 	items map[string]any
 }
 
-func ParseHSet(b redis.BaseCmd) (*HSet, error) {
+func ParseHSet(b redis.BaseCmd) (HSet, error) {
-	cmd := &HSet{BaseCmd: b}
+	cmd := HSet{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.AnyMap(&cmd.items),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return HSet{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *HSet) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HSet) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Hash().SetMany(cmd.key, cmd.items)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hset_test.go

@@ -55,6 +55,8 @@ func TestHSetParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.items, test.want.items)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/hash/hsetnx.go

@@ -12,10 +12,10 @@ type HSetNX struct {
 	value []byte
 }
 
-func ParseHSetNX(b redis.BaseCmd) (*HSetNX, error) {
+func ParseHSetNX(b redis.BaseCmd) (HSetNX, error) {
-	cmd := &HSetNX{BaseCmd: b}
+	cmd := HSetNX{BaseCmd: b}
 	if len(cmd.Args()) != 3 {
-		return cmd, redis.ErrInvalidArgNum
+		return HSetNX{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	cmd.field = string(cmd.Args()[1])
@@ -23,7 +23,7 @@ func ParseHSetNX(b redis.BaseCmd) (*HSetNX, error) {
 	return cmd, nil
 }
 
-func (cmd *HSetNX) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HSetNX) Run(w redis.Writer, red redis.Redka) (any, error) {
 	ok, err := red.Hash().SetNotExists(cmd.key, cmd.field, cmd.value)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hsetnx_test.go

@@ -47,6 +47,8 @@ func TestHSetNXParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.value, test.want.value)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/hash/hvals.go

@@ -10,16 +10,16 @@ type HVals struct {
 	key string
 }
 
-func ParseHVals(b redis.BaseCmd) (*HVals, error) {
+func ParseHVals(b redis.BaseCmd) (HVals, error) {
-	cmd := &HVals{BaseCmd: b}
+	cmd := HVals{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return HVals{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *HVals) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd HVals) Run(w redis.Writer, red redis.Redka) (any, error) {
 	vals, err := red.Hash().Values(cmd.key)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/hash/hvals_test.go

@@ -37,6 +37,8 @@ func TestHValsParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, HVals{})
 			}
 		})
 	}

internal/command/key/del.go

@@ -13,18 +13,18 @@ type Del struct {
 	keys []string
 }
 
-func ParseDel(b redis.BaseCmd) (*Del, error) {
+func ParseDel(b redis.BaseCmd) (Del, error) {
-	cmd := &Del{BaseCmd: b}
+	cmd := Del{BaseCmd: b}
 	err := parser.New(
 		parser.Strings(&cmd.keys),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Del{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *Del) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Del) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Key().Delete(cmd.keys...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/del_test.go

@@ -37,6 +37,8 @@ func TestDelParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.keys, test.want)
+			} else {
+				testx.AssertEqual(t, cmd, Del{})
 			}
 		})
 	}

internal/command/key/exists.go

@@ -13,18 +13,18 @@ type Exists struct {
 	keys []string
 }
 
-func ParseExists(b redis.BaseCmd) (*Exists, error) {
+func ParseExists(b redis.BaseCmd) (Exists, error) {
-	cmd := &Exists{BaseCmd: b}
+	cmd := Exists{BaseCmd: b}
 	err := parser.New(
 		parser.Strings(&cmd.keys),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Exists{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *Exists) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Exists) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Key().Count(cmd.keys...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/exists_test.go

@@ -36,6 +36,8 @@ func TestExistsParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.keys, test.want)
+			} else {
+				testx.AssertEqual(t, cmd, Exists{})
 			}
 		})
 	}

internal/command/key/expire.go

@@ -17,8 +17,8 @@ type Expire struct {
 	ttl time.Duration
 }
 
-func ParseExpire(b redis.BaseCmd, multi int) (*Expire, error) {
+func ParseExpire(b redis.BaseCmd, multi int) (Expire, error) {
-	cmd := &Expire{BaseCmd: b}
+	cmd := Expire{BaseCmd: b}
 
 	var ttl int
 	err := parser.New(
@@ -26,14 +26,14 @@ func ParseExpire(b redis.BaseCmd, multi int) (*Expire, error) {
 		parser.Int(&ttl),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Expire{}, err
 	}
 
 	cmd.ttl = time.Duration(multi*ttl) * time.Millisecond
 	return cmd, nil
 }
 
-func (cmd *Expire) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Expire) Run(w redis.Writer, red redis.Redka) (any, error) {
 	err := red.Key().Expire(cmd.key, cmd.ttl)
 	if err != nil && err != core.ErrNotFound {
 		w.WriteError(cmd.Error(err))

internal/command/key/expire_test.go

@@ -47,7 +47,7 @@ func TestExpireParse(t *testing.T) {
 		},
 	}
 
-	parse := func(b redis.BaseCmd) (*Expire, error) {
+	parse := func(b redis.BaseCmd) (Expire, error) {
 		return ParseExpire(b, 1000)
 	}
 
@@ -58,13 +58,15 @@ func TestExpireParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.ttl, test.ttl)
+			} else {
+				testx.AssertEqual(t, cmd, Expire{})
 			}
 		})
 	}
 }
 
 func TestExpireExec(t *testing.T) {
-	parse := func(b redis.BaseCmd) (*Expire, error) {
+	parse := func(b redis.BaseCmd) (Expire, error) {
 		return ParseExpire(b, 1000)
 	}
 	t.Run("create expire", func(t *testing.T) {

internal/command/key/expireat.go

@@ -17,8 +17,8 @@ type ExpireAt struct {
 	at  time.Time
 }
 
-func ParseExpireAt(b redis.BaseCmd, multi int) (*ExpireAt, error) {
+func ParseExpireAt(b redis.BaseCmd, multi int) (ExpireAt, error) {
-	cmd := &ExpireAt{BaseCmd: b}
+	cmd := ExpireAt{BaseCmd: b}
 
 	var at int
 	err := parser.New(
@@ -26,14 +26,14 @@ func ParseExpireAt(b redis.BaseCmd, multi int) (*ExpireAt, error) {
 		parser.Int(&at),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return ExpireAt{}, err
 	}
 
 	cmd.at = time.UnixMilli(int64(multi * at))
 	return cmd, nil
 }
 
-func (cmd *ExpireAt) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd ExpireAt) Run(w redis.Writer, red redis.Redka) (any, error) {
 	err := red.Key().ExpireAt(cmd.key, cmd.at)
 	if err != nil && err != core.ErrNotFound {
 		w.WriteError(cmd.Error(err))

internal/command/key/expireat_test.go

@@ -48,7 +48,7 @@ func TestExpireAtParse(t *testing.T) {
 		},
 	}
 
-	parse := func(b redis.BaseCmd) (*ExpireAt, error) {
+	parse := func(b redis.BaseCmd) (ExpireAt, error) {
 		return ParseExpireAt(b, 1000)
 	}
 
@@ -59,13 +59,15 @@ func TestExpireAtParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.at.Unix(), test.at.Unix())
+			} else {
+				testx.AssertEqual(t, cmd, ExpireAt{})
 			}
 		})
 	}
 }
 
 func TestExpireAtExec(t *testing.T) {
-	parse := func(b redis.BaseCmd) (*ExpireAt, error) {
+	parse := func(b redis.BaseCmd) (ExpireAt, error) {
 		return ParseExpireAt(b, 1000)
 	}
 	t.Run("create expireat", func(t *testing.T) {

internal/command/key/flushdb.go

@@ -9,15 +9,15 @@ type FlushDB struct {
 	redis.BaseCmd
 }
 
-func ParseFlushDB(b redis.BaseCmd) (*FlushDB, error) {
+func ParseFlushDB(b redis.BaseCmd) (FlushDB, error) {
-	cmd := &FlushDB{BaseCmd: b}
+	cmd := FlushDB{BaseCmd: b}
 	if len(cmd.Args()) != 0 {
-		return cmd, redis.ErrSyntaxError
+		return FlushDB{}, redis.ErrSyntaxError
 	}
 	return cmd, nil
 }
 
-func (cmd *FlushDB) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd FlushDB) Run(w redis.Writer, red redis.Redka) (any, error) {
 	err := red.Key().DeleteAll()
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/flushdb_test.go

@@ -28,8 +28,11 @@ func TestFlushDBParse(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.cmd, func(t *testing.T) {
-			_, err := redis.Parse(ParseFlushDB, test.cmd)
+			cmd, err := redis.Parse(ParseFlushDB, test.cmd)
 			testx.AssertEqual(t, err, test.err)
+			if err != nil {
+				testx.AssertEqual(t, cmd, FlushDB{})
+			}
 		})
 	}
 }

internal/command/key/keys.go

@@ -10,16 +10,16 @@ type Keys struct {
 	pattern string
 }
 
-func ParseKeys(b redis.BaseCmd) (*Keys, error) {
+func ParseKeys(b redis.BaseCmd) (Keys, error) {
-	cmd := &Keys{BaseCmd: b}
+	cmd := Keys{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return Keys{}, redis.ErrInvalidArgNum
 	}
 	cmd.pattern = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *Keys) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Keys) Run(w redis.Writer, red redis.Redka) (any, error) {
 	keys, err := red.Key().Keys(cmd.pattern)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/keys_test.go

@@ -42,6 +42,8 @@ func TestKeysParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.pattern, test.want)
+			} else {
+				testx.AssertEqual(t, cmd, Keys{})
 			}
 		})
 	}

internal/command/key/persist.go

@@ -13,16 +13,16 @@ type Persist struct {
 	key string
 }
 
-func ParsePersist(b redis.BaseCmd) (*Persist, error) {
+func ParsePersist(b redis.BaseCmd) (Persist, error) {
-	cmd := &Persist{BaseCmd: b}
+	cmd := Persist{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return Persist{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *Persist) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Persist) Run(w redis.Writer, red redis.Redka) (any, error) {
 	err := red.Key().Persist(cmd.key)
 	if err != nil && err != core.ErrNotFound {
 		w.WriteError(cmd.Error(err))

internal/command/key/persist_test.go

@@ -37,6 +37,8 @@ func TestPersistParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, Persist{})
 			}
 		})
 	}

internal/command/key/pexpire_test.go

@@ -47,7 +47,7 @@ func TestPExpireParse(t *testing.T) {
 		},
 	}
 
-	parse := func(b redis.BaseCmd) (*Expire, error) {
+	parse := func(b redis.BaseCmd) (Expire, error) {
 		return ParseExpire(b, 1)
 	}
 
@@ -58,13 +58,15 @@ func TestPExpireParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.ttl, test.ttl)
+			} else {
+				testx.AssertEqual(t, cmd, Expire{})
 			}
 		})
 	}
 }
 
 func TestPExpireExec(t *testing.T) {
-	parse := func(b redis.BaseCmd) (*Expire, error) {
+	parse := func(b redis.BaseCmd) (Expire, error) {
 		return ParseExpire(b, 1)
 	}
 

internal/command/key/randomkey.go

@@ -12,15 +12,15 @@ type RandomKey struct {
 	redis.BaseCmd
 }
 
-func ParseRandomKey(b redis.BaseCmd) (*RandomKey, error) {
+func ParseRandomKey(b redis.BaseCmd) (RandomKey, error) {
-	cmd := &RandomKey{BaseCmd: b}
+	cmd := RandomKey{BaseCmd: b}
 	if len(cmd.Args()) != 0 {
-		return cmd, redis.ErrInvalidArgNum
+		return RandomKey{}, redis.ErrInvalidArgNum
 	}
 	return cmd, nil
 }
 
-func (cmd *RandomKey) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd RandomKey) Run(w redis.Writer, red redis.Redka) (any, error) {
 	key, err := red.Key().Random()
 	if err == core.ErrNotFound {
 		w.WriteNull()

internal/command/key/randomkey_test.go

@@ -30,8 +30,11 @@ func TestRandomKeyParse(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.cmd, func(t *testing.T) {
-			_, err := redis.Parse(ParseRandomKey, test.cmd)
+			cmd, err := redis.Parse(ParseRandomKey, test.cmd)
 			testx.AssertEqual(t, err, test.err)
+			if err != nil {
+				testx.AssertEqual(t, cmd, RandomKey{})
+			}
 		})
 	}
 }

internal/command/key/rename.go

@@ -11,17 +11,17 @@ type Rename struct {
 	newKey string
 }
 
-func ParseRename(b redis.BaseCmd) (*Rename, error) {
+func ParseRename(b redis.BaseCmd) (Rename, error) {
-	cmd := &Rename{BaseCmd: b}
+	cmd := Rename{BaseCmd: b}
 	if len(cmd.Args()) != 2 {
-		return cmd, redis.ErrInvalidArgNum
+		return Rename{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	cmd.newKey = string(cmd.Args()[1])
 	return cmd, nil
 }
 
-func (cmd *Rename) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Rename) Run(w redis.Writer, red redis.Redka) (any, error) {
 	err := red.Key().Rename(cmd.key, cmd.newKey)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/rename_test.go

@@ -42,6 +42,8 @@ func TestRenameParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.newKey, test.newKey)
+			} else {
+				testx.AssertEqual(t, cmd, Rename{})
 			}
 		})
 	}

internal/command/key/renamenx.go

@@ -11,17 +11,17 @@ type RenameNX struct {
 	newKey string
 }
 
-func ParseRenameNX(b redis.BaseCmd) (*RenameNX, error) {
+func ParseRenameNX(b redis.BaseCmd) (RenameNX, error) {
-	cmd := &RenameNX{BaseCmd: b}
+	cmd := RenameNX{BaseCmd: b}
 	if len(cmd.Args()) != 2 {
-		return cmd, redis.ErrInvalidArgNum
+		return RenameNX{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	cmd.newKey = string(cmd.Args()[1])
 	return cmd, nil
 }
 
-func (cmd *RenameNX) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd RenameNX) Run(w redis.Writer, red redis.Redka) (any, error) {
 	ok, err := red.Key().RenameNotExists(cmd.key, cmd.newKey)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/renamenx_test.go

@@ -42,6 +42,8 @@ func TestRenameNXParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
 				testx.AssertEqual(t, cmd.newKey, test.newKey)
+			} else {
+				testx.AssertEqual(t, cmd, RenameNX{})
 			}
 		})
 	}

internal/command/key/scan.go

@@ -25,8 +25,8 @@ type Scan struct {
 	ktype  string
 }
 
-func ParseScan(b redis.BaseCmd) (*Scan, error) {
+func ParseScan(b redis.BaseCmd) (Scan, error) {
-	cmd := &Scan{BaseCmd: b}
+	cmd := Scan{BaseCmd: b}
 
 	err := parser.New(
 		parser.Int(&cmd.cursor),
@@ -36,7 +36,7 @@ func ParseScan(b redis.BaseCmd) (*Scan, error) {
 			TypeHash, TypeList, TypeSet, TypeString, TypeZSet)),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Scan{}, err
 	}
 
 	// all keys by default
@@ -47,7 +47,7 @@ func ParseScan(b redis.BaseCmd) (*Scan, error) {
 	return cmd, nil
 }
 
-func (cmd *Scan) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Scan) Run(w redis.Writer, red redis.Redka) (any, error) {
 	res, err := red.Key().Scan(cmd.cursor, cmd.match, toTypeID(cmd.ktype), cmd.count)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/key/scan_test.go

@@ -114,6 +114,8 @@ func TestScanParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.match, test.match)
 				testx.AssertEqual(t, cmd.ktype, test.ktype)
 				testx.AssertEqual(t, cmd.count, test.count)
+			} else {
+				testx.AssertEqual(t, cmd, Scan{})
 			}
 		})
 	}

internal/command/key/ttl.go

@@ -15,16 +15,16 @@ type TTL struct {
 	key string
 }
 
-func ParseTTL(b redis.BaseCmd) (*TTL, error) {
+func ParseTTL(b redis.BaseCmd) (TTL, error) {
-	cmd := &TTL{BaseCmd: b}
+	cmd := TTL{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return TTL{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *TTL) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd TTL) Run(w redis.Writer, red redis.Redka) (any, error) {
 	k, err := red.Key().Get(cmd.key)
 	if err == core.ErrNotFound {
 		w.WriteInt(-2)

internal/command/key/ttl_test.go

@@ -37,6 +37,8 @@ func TestTTLParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, TTL{})
 			}
 		})
 	}

internal/command/key/type.go

@@ -13,16 +13,16 @@ type Type struct {
 	key string
 }
 
-func ParseType(b redis.BaseCmd) (*Type, error) {
+func ParseType(b redis.BaseCmd) (Type, error) {
-	cmd := &Type{BaseCmd: b}
+	cmd := Type{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return Type{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *Type) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd Type) Run(w redis.Writer, red redis.Redka) (any, error) {
 	k, err := red.Key().Get(cmd.key)
 	if err == core.ErrNotFound {
 		w.WriteString("none")

internal/command/key/type_test.go

@@ -36,6 +36,8 @@ func TestTypeParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.key)
+			} else {
+				testx.AssertEqual(t, cmd, Type{})
 			}
 		})
 	}

internal/command/list/lindex.go

@@ -15,19 +15,19 @@ type LIndex struct {
 	index int
 }
 
-func ParseLIndex(b redis.BaseCmd) (*LIndex, error) {
+func ParseLIndex(b redis.BaseCmd) (LIndex, error) {
-	cmd := &LIndex{BaseCmd: b}
+	cmd := LIndex{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Int(&cmd.index),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LIndex{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LIndex) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LIndex) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.List().Get(cmd.key, cmd.index)
 	if err == core.ErrNotFound {
 		w.WriteNull()

internal/command/list/lindex_test.go

@@ -43,6 +43,8 @@ func TestLIndexParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.index, test.want.index)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/linsert.go

@@ -22,8 +22,8 @@ type LInsert struct {
 	elem  []byte
 }
 
-func ParseLInsert(b redis.BaseCmd) (*LInsert, error) {
+func ParseLInsert(b redis.BaseCmd) (LInsert, error) {
-	cmd := &LInsert{BaseCmd: b}
+	cmd := LInsert{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Enum(&cmd.where, Before, After),
@@ -31,12 +31,12 @@ func ParseLInsert(b redis.BaseCmd) (*LInsert, error) {
 		parser.Bytes(&cmd.elem),
 	).Required(4).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LInsert{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LInsert) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LInsert) Run(w redis.Writer, red redis.Redka) (any, error) {
 	var n int
 	var err error
 	if cmd.where == Before {

internal/command/list/linsert_test.go

@@ -61,6 +61,8 @@ func TestLInsertParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.where, test.want.where)
 				testx.AssertEqual(t, cmd.pivot, test.want.pivot)
 				testx.AssertEqual(t, cmd.elem, test.want.elem)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/llen.go

@@ -13,18 +13,18 @@ type LLen struct {
 	key string
 }
 
-func ParseLLen(b redis.BaseCmd) (*LLen, error) {
+func ParseLLen(b redis.BaseCmd) (LLen, error) {
-	cmd := &LLen{BaseCmd: b}
+	cmd := LLen{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LLen{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LLen) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LLen) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.List().Len(cmd.key)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/list/llen_test.go

@@ -36,6 +36,8 @@ func TestLLenParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/lpop.go

@@ -14,18 +14,18 @@ type LPop struct {
 	key string
 }
 
-func ParseLPop(b redis.BaseCmd) (*LPop, error) {
+func ParseLPop(b redis.BaseCmd) (LPop, error) {
-	cmd := &LPop{BaseCmd: b}
+	cmd := LPop{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LPop{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LPop) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LPop) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.List().PopFront(cmd.key)
 	if err == core.ErrNotFound {
 		w.WriteNull()

internal/command/list/lpop_test.go

@@ -37,6 +37,8 @@ func TestLPopParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/lpush.go

@@ -15,19 +15,19 @@ type LPush struct {
 	elem []byte
 }
 
-func ParseLPush(b redis.BaseCmd) (*LPush, error) {
+func ParseLPush(b redis.BaseCmd) (LPush, error) {
-	cmd := &LPush{BaseCmd: b}
+	cmd := LPush{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Bytes(&cmd.elem),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LPush{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LPush) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LPush) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.List().PushFront(cmd.key, cmd.elem)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/list/lrange.go

@@ -15,20 +15,20 @@ type LRange struct {
 	stop  int
 }
 
-func ParseLRange(b redis.BaseCmd) (*LRange, error) {
+func ParseLRange(b redis.BaseCmd) (LRange, error) {
-	cmd := &LRange{BaseCmd: b}
+	cmd := LRange{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Int(&cmd.start),
 		parser.Int(&cmd.stop),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LRange{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LRange) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LRange) Run(w redis.Writer, red redis.Redka) (any, error) {
 	vals, err := red.List().Range(cmd.key, cmd.start, cmd.stop)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/list/lrange_test.go

@@ -44,6 +44,8 @@ func TestLRangeParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.start, test.want.start)
 				testx.AssertEqual(t, cmd.stop, test.want.stop)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/lrem.go

@@ -15,20 +15,20 @@ type LRem struct {
 	elem  []byte
 }
 
-func ParseLRem(b redis.BaseCmd) (*LRem, error) {
+func ParseLRem(b redis.BaseCmd) (LRem, error) {
-	cmd := &LRem{BaseCmd: b}
+	cmd := LRem{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Int(&cmd.count),
 		parser.Bytes(&cmd.elem),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LRem{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LRem) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LRem) Run(w redis.Writer, red redis.Redka) (any, error) {
 	var n int
 	var err error
 	switch {

internal/command/list/lrem_test.go

@@ -48,6 +48,8 @@ func TestLRemParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.count, test.want.count)
 				testx.AssertEqual(t, cmd.elem, test.want.elem)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/lset.go

@@ -16,20 +16,20 @@ type LSet struct {
 	elem  []byte
 }
 
-func ParseLSet(b redis.BaseCmd) (*LSet, error) {
+func ParseLSet(b redis.BaseCmd) (LSet, error) {
-	cmd := &LSet{BaseCmd: b}
+	cmd := LSet{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Int(&cmd.index),
 		parser.Bytes(&cmd.elem),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LSet{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LSet) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LSet) Run(w redis.Writer, red redis.Redka) (any, error) {
 	err := red.List().Set(cmd.key, cmd.index, cmd.elem)
 	if err == core.ErrNotFound {
 		w.WriteError(cmd.Error(redis.ErrOutOfRange))

internal/command/list/lset_test.go

@@ -49,6 +49,8 @@ func TestLSetParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.index, test.want.index)
 				testx.AssertEqual(t, cmd.elem, test.want.elem)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/ltrim.go

@@ -15,20 +15,20 @@ type LTrim struct {
 	stop  int
 }
 
-func ParseLTrim(b redis.BaseCmd) (*LTrim, error) {
+func ParseLTrim(b redis.BaseCmd) (LTrim, error) {
-	cmd := &LTrim{BaseCmd: b}
+	cmd := LTrim{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Int(&cmd.start),
 		parser.Int(&cmd.stop),
 	).Required(3).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return LTrim{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *LTrim) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd LTrim) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.List().Trim(cmd.key, cmd.start, cmd.stop)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/list/ltrim_test.go

@@ -38,6 +38,8 @@ func TestLTrimParse(t *testing.T) {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.start, test.want.start)
 				testx.AssertEqual(t, cmd.stop, test.want.stop)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/rpop.go

@@ -14,18 +14,18 @@ type RPop struct {
 	key string
 }
 
-func ParseRPop(b redis.BaseCmd) (*RPop, error) {
+func ParseRPop(b redis.BaseCmd) (RPop, error) {
-	cmd := &RPop{BaseCmd: b}
+	cmd := RPop{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return RPop{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *RPop) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd RPop) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.List().PopBack(cmd.key)
 	if err == core.ErrNotFound {
 		w.WriteNull()

internal/command/list/rpop_test.go

@@ -37,6 +37,8 @@ func TestRPopParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/rpoplpush.go

@@ -16,19 +16,19 @@ type RPopLPush struct {
 	dst string
 }
 
-func ParseRPopLPush(b redis.BaseCmd) (*RPopLPush, error) {
+func ParseRPopLPush(b redis.BaseCmd) (RPopLPush, error) {
-	cmd := &RPopLPush{BaseCmd: b}
+	cmd := RPopLPush{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.src),
 		parser.String(&cmd.dst),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return RPopLPush{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *RPopLPush) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd RPopLPush) Run(w redis.Writer, red redis.Redka) (any, error) {
 	val, err := red.List().PopBackPushFront(cmd.src, cmd.dst)
 	if err == core.ErrNotFound {
 		w.WriteNull()

internal/command/list/rpoplpush_test.go

@@ -38,6 +38,8 @@ func TestRPopLPushParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.src, test.want.src)
 				testx.AssertEqual(t, cmd.dst, test.want.dst)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/list/rpush.go

@@ -15,19 +15,19 @@ type RPush struct {
 	elem []byte
 }
 
-func ParseRPush(b redis.BaseCmd) (*RPush, error) {
+func ParseRPush(b redis.BaseCmd) (RPush, error) {
-	cmd := &RPush{BaseCmd: b}
+	cmd := RPush{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Bytes(&cmd.elem),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return RPush{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *RPush) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd RPush) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.List().PushBack(cmd.key, cmd.elem)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/list/rpush_test.go

@@ -43,6 +43,8 @@ func TestRPushParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.elem, test.want.elem)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/server/dbsize.go

@@ -9,15 +9,15 @@ type DBSize struct {
 	redis.BaseCmd
 }
 
-func ParseDBSize(b redis.BaseCmd) (*DBSize, error) {
+func ParseDBSize(b redis.BaseCmd) (DBSize, error) {
-	cmd := &DBSize{BaseCmd: b}
+	cmd := DBSize{BaseCmd: b}
 	if len(cmd.Args()) != 0 {
-		return cmd, redis.ErrInvalidArgNum
+		return DBSize{}, redis.ErrInvalidArgNum
 	}
 	return cmd, nil
 }
 
-func (cmd *DBSize) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd DBSize) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.Key().Len()
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/server/dbsize_test.go

@@ -24,8 +24,11 @@ func TestDBSizeParse(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.cmd, func(t *testing.T) {
-			_, err := redis.Parse(ParseDBSize, test.cmd)
+			cmd, err := redis.Parse(ParseDBSize, test.cmd)
 			testx.AssertEqual(t, err, test.err)
+			if err != nil {
+				testx.AssertEqual(t, cmd, DBSize{})
+			}
 		})
 	}
 }

internal/command/server/lolwut.go

@@ -41,18 +41,18 @@ type Lolwut struct {
 	parts []string
 }
 
-func ParseLolwut(b redis.BaseCmd) (*Lolwut, error) {
+func ParseLolwut(b redis.BaseCmd) (Lolwut, error) {
-	cmd := &Lolwut{BaseCmd: b}
+	cmd := Lolwut{BaseCmd: b}
 	err := parser.New(
 		parser.Strings(&cmd.parts),
 	).Required(0).Run(cmd.Args())
 	if err != nil {
-		return cmd, err
+		return Lolwut{}, err
 	}
 	return cmd, nil
 }
 
-func (c *Lolwut) Run(w redis.Writer, _ redis.Redka) (any, error) {
+func (c Lolwut) Run(w redis.Writer, _ redis.Redka) (any, error) {
 	var answer string
 	if len(c.parts) != 0 {
 		answer = lolwutAnswers[rand.Intn(len(lolwutAnswers))]

internal/command/server/lolwut_test.go

@@ -29,8 +29,11 @@ func TestLolwutParse(t *testing.T) {
 
 	for _, test := range tests {
 		t.Run(test.cmd, func(t *testing.T) {
-			_, err := redis.Parse(ParseLolwut, test.cmd)
+			cmd, err := redis.Parse(ParseLolwut, test.cmd)
 			testx.AssertEqual(t, err, test.err)
+			if err != nil {
+				testx.AssertEqual(t, cmd, Lolwut{})
+			}
 		})
 	}
 }

internal/command/server/ok.go

@@ -7,11 +7,11 @@ type OK struct {
 	redis.BaseCmd
 }
 
-func ParseOK(b redis.BaseCmd) (*OK, error) {
+func ParseOK(b redis.BaseCmd) (OK, error) {
-	return &OK{BaseCmd: b}, nil
+	return OK{BaseCmd: b}, nil
 }
 
-func (c *OK) Run(w redis.Writer, _ redis.Redka) (any, error) {
+func (c OK) Run(w redis.Writer, _ redis.Redka) (any, error) {
 	w.WriteString("OK")
 	return true, nil
 }

internal/command/server/unknown.go

@@ -8,11 +8,11 @@ type Unknown struct {
 	redis.BaseCmd
 }
 
-func ParseUnknown(b redis.BaseCmd) (*Unknown, error) {
+func ParseUnknown(b redis.BaseCmd) (Unknown, error) {
-	return &Unknown{BaseCmd: b}, nil
+	return Unknown{BaseCmd: b}, nil
 }
 
-func (cmd *Unknown) Run(w redis.Writer, _ redis.Redka) (any, error) {
+func (cmd Unknown) Run(w redis.Writer, _ redis.Redka) (any, error) {
 	err := redis.ErrUnknownCmd
 	w.WriteError(cmd.Error(err))
 	return nil, err

internal/command/set/sadd.go

@@ -15,19 +15,19 @@ type SAdd struct {
 	members []any
 }
 
-func ParseSAdd(b redis.BaseCmd) (*SAdd, error) {
+func ParseSAdd(b redis.BaseCmd) (SAdd, error) {
-	cmd := &SAdd{BaseCmd: b}
+	cmd := SAdd{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Anys(&cmd.members),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return SAdd{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *SAdd) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SAdd) Run(w redis.Writer, red redis.Redka) (any, error) {
 	count, err := red.Set().Add(cmd.key, cmd.members...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/set/sadd_test.go

@@ -48,6 +48,8 @@ func TestSAddParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
 				testx.AssertEqual(t, cmd.members, test.want.members)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/set/scard.go

@@ -10,16 +10,16 @@ type SCard struct {
 	key string
 }
 
-func ParseSCard(b redis.BaseCmd) (*SCard, error) {
+func ParseSCard(b redis.BaseCmd) (SCard, error) {
-	cmd := &SCard{BaseCmd: b}
+	cmd := SCard{BaseCmd: b}
 	if len(cmd.Args()) != 1 {
-		return cmd, redis.ErrInvalidArgNum
+		return SCard{}, redis.ErrInvalidArgNum
 	}
 	cmd.key = string(cmd.Args()[0])
 	return cmd, nil
 }
 
-func (cmd *SCard) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SCard) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.Set().Len(cmd.key)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/set/scard_test.go

@@ -36,6 +36,8 @@ func TestSCardParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.key, test.want.key)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/set/sdiff.go

@@ -13,18 +13,18 @@ type SDiff struct {
 	keys []string
 }
 
-func ParseSDiff(b redis.BaseCmd) (*SDiff, error) {
+func ParseSDiff(b redis.BaseCmd) (SDiff, error) {
-	cmd := &SDiff{BaseCmd: b}
+	cmd := SDiff{BaseCmd: b}
 	err := parser.New(
 		parser.Strings(&cmd.keys),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return SDiff{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *SDiff) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SDiff) Run(w redis.Writer, red redis.Redka) (any, error) {
 	elems, err := red.Set().Diff(cmd.keys...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/set/sdiff_test.go

@@ -37,6 +37,8 @@ func TestSDiffParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.keys, test.want.keys)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/set/sdiffstore.go

@@ -14,19 +14,19 @@ type SDiffStore struct {
 	keys []string
 }
 
-func ParseSDiffStore(b redis.BaseCmd) (*SDiffStore, error) {
+func ParseSDiffStore(b redis.BaseCmd) (SDiffStore, error) {
-	cmd := &SDiffStore{BaseCmd: b}
+	cmd := SDiffStore{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.dest),
 		parser.Strings(&cmd.keys),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return SDiffStore{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *SDiffStore) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SDiffStore) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.Set().DiffStore(cmd.dest, cmd.keys...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/set/sdiffstore_test.go

@@ -43,6 +43,8 @@ func TestSDiffStoreParse(t *testing.T) {
 			if err == nil {
 				testx.AssertEqual(t, cmd.dest, test.want.dest)
 				testx.AssertEqual(t, cmd.keys, test.want.keys)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/set/sinter.go

@@ -13,18 +13,18 @@ type SInter struct {
 	keys []string
 }
 
-func ParseSInter(b redis.BaseCmd) (*SInter, error) {
+func ParseSInter(b redis.BaseCmd) (SInter, error) {
-	cmd := &SInter{BaseCmd: b}
+	cmd := SInter{BaseCmd: b}
 	err := parser.New(
 		parser.Strings(&cmd.keys),
 	).Required(1).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return SInter{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *SInter) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SInter) Run(w redis.Writer, red redis.Redka) (any, error) {
 	elems, err := red.Set().Inter(cmd.keys...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/set/sinter_test.go

@@ -37,6 +37,8 @@ func TestSInterParse(t *testing.T) {
 			testx.AssertEqual(t, err, test.err)
 			if err == nil {
 				testx.AssertEqual(t, cmd.keys, test.want.keys)
+			} else {
+				testx.AssertEqual(t, cmd, test.want)
 			}
 		})
 	}

internal/command/set/sinterstore.go

@@ -14,19 +14,19 @@ type SInterStore struct {
 	keys []string
 }
 
-func ParseSInterStore(b redis.BaseCmd) (*SInterStore, error) {
+func ParseSInterStore(b redis.BaseCmd) (SInterStore, error) {
-	cmd := &SInterStore{BaseCmd: b}
+	cmd := SInterStore{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.dest),
 		parser.Strings(&cmd.keys),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return SInterStore{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *SInterStore) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SInterStore) Run(w redis.Writer, red redis.Redka) (any, error) {
 	n, err := red.Set().InterStore(cmd.dest, cmd.keys...)
 	if err != nil {
 		w.WriteError(cmd.Error(err))

internal/command/set/sismember.go

@@ -14,19 +14,19 @@ type SIsMember struct {
 	member []byte
 }
 
-func ParseSIsMember(b redis.BaseCmd) (*SIsMember, error) {
+func ParseSIsMember(b redis.BaseCmd) (SIsMember, error) {
-	cmd := &SIsMember{BaseCmd: b}
+	cmd := SIsMember{BaseCmd: b}
 	err := parser.New(
 		parser.String(&cmd.key),
 		parser.Bytes(&cmd.member),
 	).Required(2).Run(cmd.Args())
 	if err != nil {
-		return nil, err
+		return SIsMember{}, err
 	}
 	return cmd, nil
 }
 
-func (cmd *SIsMember) Run(w redis.Writer, red redis.Redka) (any, error) {
+func (cmd SIsMember) Run(w redis.Writer, red redis.Redka) (any, error) {
 	ok, err := red.Set().Exists(cmd.key, cmd.member)
 	if err != nil {
 		w.WriteError(cmd.Error(err))