zeromicro
/
go-zero
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

chore: add more tests (#3958)

Browse Source
master^2
Kevin Wan 9 months ago committed by GitHub
parent 9763c8b143
commit a5d2b971a1
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 140 additions and 100 deletions
Show Stats Download Patch File Download Diff File

95
core/stores/redis/redis.go
Unescape Escape View File

@ -483,13 +483,8 @@ func (s *Redis) ExistsManyCtx(ctx context.Context, keys ...string) (val int64, e
return err return err
} }
v, err := conn.Exists(ctx, keys...).Result() val, err = conn.Exists(ctx, keys...).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -543,13 +538,8 @@ func (s *Redis) GeoAddCtx(ctx context.Context, key string, geoLocation ...*GeoLo
return err return err
} }
v, err := conn.GeoAdd(ctx, key, geoLocation...).Result() val, err = conn.GeoAdd(ctx, key, geoLocation...).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -569,13 +559,8 @@ func (s *Redis) GeoDistCtx(ctx context.Context, key, member1, member2, unit stri
return err return err
} }
v, err := conn.GeoDist(ctx, key, member1, member2, unit).Result() val, err = conn.GeoDist(ctx, key, member1, member2, unit).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -595,13 +580,8 @@ func (s *Redis) GeoHashCtx(ctx context.Context, key string, members ...string) (
return err return err
} }
v, err := conn.GeoHash(ctx, key, members...).Result() val, err = conn.GeoHash(ctx, key, members...).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -622,13 +602,8 @@ func (s *Redis) GeoRadiusCtx(ctx context.Context, key string, longitude, latitud
return err return err
} }
v, err := conn.GeoRadius(ctx, key, longitude, latitude, query).Result() val, err = conn.GeoRadius(ctx, key, longitude, latitude, query).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -648,13 +623,8 @@ func (s *Redis) GeoRadiusByMemberCtx(ctx context.Context, key, member string,
return err return err
} }
v, err := conn.GeoRadiusByMember(ctx, key, member, query).Result() val, err = conn.GeoRadiusByMember(ctx, key, member, query).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -674,13 +644,8 @@ func (s *Redis) GeoPosCtx(ctx context.Context, key string, members ...string) (
return err return err
} }
v, err := conn.GeoPos(ctx, key, members...).Result() val, err = conn.GeoPos(ctx, key, members...).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -699,7 +664,7 @@ func (s *Redis) GetCtx(ctx context.Context, key string) (val string, err error)
return err return err
} }
if val, err = conn.Get(ctx, key).Result(); err == red.Nil { if val, err = conn.Get(ctx, key).Result(); errors.Is(err, red.Nil) {
return nil return nil
} else if err != nil { } else if err != nil {
return err return err
@ -749,7 +714,7 @@ func (s *Redis) GetSetCtx(ctx context.Context, key, value string) (val string, e
return err return err
} }
if val, err = conn.GetSet(ctx, key, value).Result(); err == red.Nil { if val, err = conn.GetSet(ctx, key, value).Result(); errors.Is(err, red.Nil) {
return nil return nil
} }
@ -875,17 +840,16 @@ func (s *Redis) HincrbyFloat(key, field string, increment float64) (float64, err
} }
// HincrbyFloatCtx is the implementation of redis hincrbyfloat command. // HincrbyFloatCtx is the implementation of redis hincrbyfloat command.
func (s *Redis) HincrbyFloatCtx(ctx context.Context, key, field string, increment float64) (val float64, err error) { func (s *Redis) HincrbyFloatCtx(ctx context.Context, key, field string, increment float64) (
val float64, err error) {
err = s.brk.DoWithAcceptable(func() error { err = s.brk.DoWithAcceptable(func() error {
conn, err := getRedis(s) conn, err := getRedis(s)
if err != nil { if err != nil {
return err return err
} }
val, err = conn.HIncrByFloat(ctx, key, field, increment).Result() val, err = conn.HIncrByFloat(ctx, key, field, increment).Result()
if err != nil { return err
return err
}
return nil
}, acceptable) }, acceptable)
return return
@ -1353,11 +1317,7 @@ func (s *Redis) MsetCtx(ctx context.Context, fieldsAndValues ...any) (val string
} }
val, err = conn.MSet(ctx, fieldsAndValues...).Result() val, err = conn.MSet(ctx, fieldsAndValues...).Result()
if err != nil { return err
return err
}
return nil
}, acceptable) }, acceptable)
return return
@ -2052,6 +2012,7 @@ func (s *Redis) TtlCtx(ctx context.Context, key string) (val int, err error) {
// -1 means key exists but has no expire // -1 means key exists but has no expire
val = int(duration) val = int(duration)
} }
return nil return nil
}, acceptable) }, acceptable)
@ -2157,13 +2118,8 @@ func (s *Redis) ZaddsCtx(ctx context.Context, key string, ps ...Pair) (val int64
zs = append(zs, z) zs = append(zs, z)
} }
v, err := conn.ZAdd(ctx, key, zs...).Result() val, err = conn.ZAdd(ctx, key, zs...).Result()
if err != nil { return err
return err
}
val = v
return nil
}, acceptable) }, acceptable)
return return
@ -2283,6 +2239,7 @@ func (s *Redis) ZscoreByFloatCtx(ctx context.Context, key, value string) (val fl
if err != nil { if err != nil {
return err return err
} }
val, err = conn.ZScore(ctx, key, value).Result() val, err = conn.ZScore(ctx, key, value).Result()
return err return err
}, acceptable) }, acceptable)
@ -2947,7 +2904,7 @@ func withHook(hook red.Hook) Option {
} }
func acceptable(err error) bool { func acceptable(err error) bool {
return err == nil || err == red.Nil || errors.Is(err, context.Canceled) return err == nil || errors.Is(err, red.Nil) || errors.Is(err, context.Canceled)
} }
func getRedis(r *Redis) (RedisNode, error) { func getRedis(r *Redis) (RedisNode, error) {

145
core/stores/redis/redis_test.go
Unescape Escape View File

@ -911,9 +911,11 @@ func TestRedis_Persist(t *testing.T) {
} }
func TestRedis_Ping(t *testing.T) { func TestRedis_Ping(t *testing.T) {
runOnRedis(t, func(client *Redis) { t.Run("ping", func(t *testing.T) {
ok := client.Ping() runOnRedis(t, func(client *Redis) {
assert.True(t, ok) ok := client.Ping()
assert.True(t, ok)
})
}) })
} }
@ -1070,24 +1072,40 @@ func TestRedis_Set(t *testing.T) {
} }
func TestRedis_GetSet(t *testing.T) { func TestRedis_GetSet(t *testing.T) {
runOnRedis(t, func(client *Redis) { t.Run("set_get", func(t *testing.T) {
_, err := newRedis(client.Addr, badType()).GetSet("hello", "world") runOnRedis(t, func(client *Redis) {
assert.NotNil(t, err) _, err := newRedis(client.Addr, badType()).GetSet("hello", "world")
val, err := client.GetSet("hello", "world") assert.NotNil(t, err)
assert.Nil(t, err) val, err := client.GetSet("hello", "world")
assert.Equal(t, "", val) assert.Nil(t, err)
val, err = client.Get("hello") assert.Equal(t, "", val)
assert.Nil(t, err) val, err = client.Get("hello")
assert.Equal(t, "world", val) assert.Nil(t, err)
val, err = client.GetSet("hello", "newworld") assert.Equal(t, "world", val)
assert.Nil(t, err) val, err = client.GetSet("hello", "newworld")
assert.Equal(t, "world", val) assert.Nil(t, err)
val, err = client.Get("hello") assert.Equal(t, "world", val)
assert.Nil(t, err) val, err = client.Get("hello")
assert.Equal(t, "newworld", val) assert.Nil(t, err)
ret, err := client.Del("hello") assert.Equal(t, "newworld", val)
assert.Nil(t, err) ret, err := client.Del("hello")
assert.Equal(t, 1, ret) assert.Nil(t, err)
assert.Equal(t, 1, ret)
})
})
t.Run("set_get with notexists", func(t *testing.T) {
runOnRedis(t, func(client *Redis) {
_, err := client.Get("hello")
assert.NoError(t, err)
})
})
t.Run("set_get with error", func(t *testing.T) {
runOnRedisWithError(t, func(client *Redis) {
_, err := client.Get("hello")
assert.Error(t, err)
})
}) })
} }
@ -1823,9 +1841,9 @@ func TestRedisBlpop(t *testing.T) {
client.Ping() client.Ping()
var node mockedNode var node mockedNode
_, err := client.Blpop(nil, "foo") _, err := client.Blpop(nil, "foo")
assert.NotNil(t, err) assert.Error(t, err)
_, err = client.Blpop(node, "foo") _, err = client.Blpop(node, "foo")
assert.NotNil(t, err) assert.NoError(t, err)
}) })
} }
@ -1837,19 +1855,60 @@ func TestRedisBlpopEx(t *testing.T) {
_, _, err := client.BlpopEx(nil, "foo") _, _, err := client.BlpopEx(nil, "foo")
assert.Error(t, err) assert.Error(t, err)
_, _, err = client.BlpopEx(node, "foo") _, _, err = client.BlpopEx(node, "foo")
assert.NoError(t, err)
})
})
t.Run("blpopex with expire", func(t *testing.T) {
runOnRedis(t, func(client *Redis) {
client.Ping()
node, err := getRedis(client)
assert.NoError(t, err)
assert.NoError(t, client.Set("foo", "bar"))
_, _, err = client.BlpopEx(node, "foo")
assert.Error(t, err)
})
})
t.Run("blpopex with bad return", func(t *testing.T) {
runOnRedis(t, func(client *Redis) {
client.Ping()
node := &mockedNode{args: []string{"bar"}}
_, _, err := client.BlpopEx(node, "foo")
assert.Error(t, err) assert.Error(t, err)
}) })
}) })
} }
func TestRedisBlpopWithTimeout(t *testing.T) { func TestRedisBlpopWithTimeout(t *testing.T) {
runOnRedis(t, func(client *Redis) { t.Run("blpop_withTimeout", func(t *testing.T) {
client.Ping() runOnRedis(t, func(client *Redis) {
var node mockedNode client.Ping()
_, err := client.BlpopWithTimeout(nil, 10*time.Second, "foo") var node mockedNode
assert.NotNil(t, err) _, err := client.BlpopWithTimeout(nil, 10*time.Second, "foo")
_, err = client.BlpopWithTimeout(node, 10*time.Second, "foo") assert.Error(t, err)
assert.NotNil(t, err) _, err = client.BlpopWithTimeout(node, 10*time.Second, "foo")
assert.NoError(t, err)
})
})
t.Run("blpop_withTimeout_error", func(t *testing.T) {
runOnRedis(t, func(client *Redis) {
client.Ping()
node, err := getRedis(client)
assert.NoError(t, err)
assert.NoError(t, client.Set("foo", "bar"))
_, err = client.BlpopWithTimeout(node, time.Millisecond, "foo")
assert.Error(t, err)
})
})
t.Run("blpop_with_bad_return", func(t *testing.T) {
runOnRedis(t, func(client *Redis) {
node := &mockedNode{args: []string{"foo"}}
_, err := client.Blpop(node, "foo")
assert.Error(t, err)
})
}) })
} }
@ -1944,6 +2003,22 @@ func TestRedis_WithPass(t *testing.T) {
}) })
} }
func TestRedis_checkConnection(t *testing.T) {
t.Run("checkConnection", func(t *testing.T) {
runOnRedis(t, func(client *Redis) {
client.Ping()
assert.NoError(t, client.checkConnection(time.Millisecond))
})
})
t.Run("checkConnection error", func(t *testing.T) {
runOnRedisWithError(t, func(client *Redis) {
assert.Error(t, newRedis(client.Addr, badType()).checkConnection(time.Millisecond))
assert.Error(t, client.checkConnection(time.Millisecond))
})
})
}
func runOnRedis(t *testing.T, fn func(client *Redis)) { func runOnRedis(t *testing.T, fn func(client *Redis)) {
logx.Disable() logx.Disable()
@ -1992,8 +2067,16 @@ func badType() Option {
type mockedNode struct { type mockedNode struct {
RedisNode RedisNode
args []string
} }
func (n mockedNode) BLPop(_ context.Context, _ time.Duration, _ ...string) *red.StringSliceCmd { func (n mockedNode) BLPop(_ context.Context, _ time.Duration, _ ...string) *red.StringSliceCmd {
return red.NewStringSliceCmd(context.Background(), "foo", "bar") cmd := red.NewStringSliceCmd(context.Background())
if len(n.args) == 0 {
cmd.SetVal([]string{"foo", "bar"})
} else {
cmd.SetVal(n.args)
}
return cmd
} }

Write Preview
Loading…
Cancel
Save