Skip to content

Commit f559312

Browse files
vmihailencovmihailenco
committed
Add ctx as first arg
1 parent 64bb0b7 commit f559312

36 files changed

+3159
-2929
lines changed

‎bench_test.go‎

Lines changed: 47 additions & 39 deletions
Original file line numberDiff line numberDiff line change
@@ -11,44 +11,46 @@ import (
1111
"github.com/go-redis/redis/v7"
1212
)
1313

14-
func benchmarkRedisClient(poolSize int) *redis.Client {
14+
func benchmarkRedisClient(ctx context.Context, poolSize int) *redis.Client {
1515
client := redis.NewClient(&redis.Options{
1616
Addr: ":6379",
1717
DialTimeout: time.Second,
1818
ReadTimeout: time.Second,
1919
WriteTimeout: time.Second,
2020
PoolSize: poolSize,
2121
})
22-
if err := client.FlushDB().Err(); err != nil {
22+
if err := client.FlushDB(ctx).Err(); err != nil {
2323
panic(err)
2424
}
2525
return client
2626
}
2727

2828
func BenchmarkRedisPing(b *testing.B) {
29-
client := benchmarkRedisClient(10)
29+
ctx := context.Background()
30+
client := benchmarkRedisClient(ctx, 10)
3031
defer client.Close()
3132

3233
b.ResetTimer()
3334

3435
b.RunParallel(func(pb *testing.PB) {
3536
for pb.Next() {
36-
if err := client.Ping().Err(); err != nil {
37+
if err := client.Ping(ctx).Err(); err != nil {
3738
b.Fatal(err)
3839
}
3940
}
4041
})
4142
}
4243

4344
func BenchmarkRedisGetNil(b *testing.B) {
44-
client := benchmarkRedisClient(10)
45+
ctx := context.Background()
46+
client := benchmarkRedisClient(ctx, 10)
4547
defer client.Close()
4648

4749
b.ResetTimer()
4850

4951
b.RunParallel(func(pb *testing.PB) {
5052
for pb.Next() {
51-
if err := client.Get("key").Err(); err != redis.Nil {
53+
if err := client.Get(ctx, "key").Err(); err != redis.Nil {
5254
b.Fatal(err)
5355
}
5456
}
@@ -80,7 +82,8 @@ func BenchmarkRedisSetString(b *testing.B) {
8082
}
8183
for _, bm := range benchmarks {
8284
b.Run(bm.String(), func(b *testing.B) {
83-
client := benchmarkRedisClient(bm.poolSize)
85+
ctx := context.Background()
86+
client := benchmarkRedisClient(ctx, bm.poolSize)
8487
defer client.Close()
8588

8689
value := strings.Repeat("1", bm.valueSize)
@@ -89,7 +92,7 @@ func BenchmarkRedisSetString(b *testing.B) {
8992

9093
b.RunParallel(func(pb *testing.PB) {
9194
for pb.Next() {
92-
err := client.Set("key", value, 0).Err()
95+
err := client.Set(ctx, "key", value, 0).Err()
9396
if err != nil {
9497
b.Fatal(err)
9598
}
@@ -100,7 +103,8 @@ func BenchmarkRedisSetString(b *testing.B) {
100103
}
101104

102105
func BenchmarkRedisSetGetBytes(b *testing.B) {
103-
client := benchmarkRedisClient(10)
106+
ctx := context.Background()
107+
client := benchmarkRedisClient(ctx, 10)
104108
defer client.Close()
105109

106110
value := bytes.Repeat([]byte{'1'}, 10000)
@@ -109,11 +113,11 @@ func BenchmarkRedisSetGetBytes(b *testing.B) {
109113

110114
b.RunParallel(func(pb *testing.PB) {
111115
for pb.Next() {
112-
if err := client.Set("key", value, 0).Err(); err != nil {
116+
if err := client.Set(ctx, "key", value, 0).Err(); err != nil {
113117
b.Fatal(err)
114118
}
115119

116-
got, err := client.Get("key").Bytes()
120+
got, err := client.Get(ctx, "key").Bytes()
117121
if err != nil {
118122
b.Fatal(err)
119123
}
@@ -125,53 +129,56 @@ func BenchmarkRedisSetGetBytes(b *testing.B) {
125129
}
126130

127131
func BenchmarkRedisMGet(b *testing.B) {
128-
client := benchmarkRedisClient(10)
132+
ctx := context.Background()
133+
client := benchmarkRedisClient(ctx, 10)
129134
defer client.Close()
130135

131-
if err := client.MSet("key1", "hello1", "key2", "hello2").Err(); err != nil {
136+
if err := client.MSet(ctx, "key1", "hello1", "key2", "hello2").Err(); err != nil {
132137
b.Fatal(err)
133138
}
134139

135140
b.ResetTimer()
136141

137142
b.RunParallel(func(pb *testing.PB) {
138143
for pb.Next() {
139-
if err := client.MGet("key1", "key2").Err(); err != nil {
144+
if err := client.MGet(ctx, "key1", "key2").Err(); err != nil {
140145
b.Fatal(err)
141146
}
142147
}
143148
})
144149
}
145150

146151
func BenchmarkSetExpire(b *testing.B) {
147-
client := benchmarkRedisClient(10)
152+
ctx := context.Background()
153+
client := benchmarkRedisClient(ctx, 10)
148154
defer client.Close()
149155

150156
b.ResetTimer()
151157

152158
b.RunParallel(func(pb *testing.PB) {
153159
for pb.Next() {
154-
if err := client.Set("key", "hello", 0).Err(); err != nil {
160+
if err := client.Set(ctx, "key", "hello", 0).Err(); err != nil {
155161
b.Fatal(err)
156162
}
157-
if err := client.Expire("key", time.Second).Err(); err != nil {
163+
if err := client.Expire(ctx, "key", time.Second).Err(); err != nil {
158164
b.Fatal(err)
159165
}
160166
}
161167
})
162168
}
163169

164170
func BenchmarkPipeline(b *testing.B) {
165-
client := benchmarkRedisClient(10)
171+
ctx := context.Background()
172+
client := benchmarkRedisClient(ctx, 10)
166173
defer client.Close()
167174

168175
b.ResetTimer()
169176

170177
b.RunParallel(func(pb *testing.PB) {
171178
for pb.Next() {
172-
_, err := client.Pipelined(func(pipe redis.Pipeliner) error {
173-
pipe.Set("key", "hello", 0)
174-
pipe.Expire("key", time.Second)
179+
_, err := client.Pipelined(ctx, func(pipe redis.Pipeliner) error {
180+
pipe.Set(ctx, "key", "hello", 0)
181+
pipe.Expire(ctx, "key", time.Second)
175182
return nil
176183
})
177184
if err != nil {
@@ -182,14 +189,15 @@ func BenchmarkPipeline(b *testing.B) {
182189
}
183190

184191
func BenchmarkZAdd(b *testing.B) {
185-
client := benchmarkRedisClient(10)
192+
ctx := context.Background()
193+
client := benchmarkRedisClient(ctx, 10)
186194
defer client.Close()
187195

188196
b.ResetTimer()
189197

190198
b.RunParallel(func(pb *testing.PB) {
191199
for pb.Next() {
192-
err := client.ZAdd("key", &redis.Z{
200+
err := client.ZAdd(ctx, "key", &redis.Z{
193201
Score: float64(1),
194202
Member: "hello",
195203
}).Err()
@@ -203,10 +211,9 @@ func BenchmarkZAdd(b *testing.B) {
203211
var clientSink *redis.Client
204212

205213
func BenchmarkWithContext(b *testing.B) {
206-
rdb := benchmarkRedisClient(10)
207-
defer rdb.Close()
208-
209214
ctx := context.Background()
215+
rdb := benchmarkRedisClient(ctx, 10)
216+
defer rdb.Close()
210217

211218
b.ResetTimer()
212219
b.ReportAllocs()
@@ -219,11 +226,10 @@ func BenchmarkWithContext(b *testing.B) {
219226
var ringSink *redis.Ring
220227

221228
func BenchmarkRingWithContext(b *testing.B) {
229+
ctx := context.Background()
222230
rdb := redis.NewRing(&redis.RingOptions{})
223231
defer rdb.Close()
224232

225-
ctx := context.Background()
226-
227233
b.ResetTimer()
228234
b.ReportAllocs()
229235

@@ -248,20 +254,21 @@ func BenchmarkClusterPing(b *testing.B) {
248254
b.Skip("skipping in short mode")
249255
}
250256

257+
ctx := context.Background()
251258
cluster := newClusterScenario()
252-
if err := startCluster(cluster); err != nil {
259+
if err := startCluster(ctx, cluster); err != nil {
253260
b.Fatal(err)
254261
}
255262
defer stopCluster(cluster)
256263

257-
client := cluster.newClusterClient(redisClusterOptions())
264+
client := cluster.newClusterClient(ctx, redisClusterOptions())
258265
defer client.Close()
259266

260267
b.ResetTimer()
261268

262269
b.RunParallel(func(pb *testing.PB) {
263270
for pb.Next() {
264-
err := client.Ping().Err()
271+
err := client.Ping(ctx).Err()
265272
if err != nil {
266273
b.Fatal(err)
267274
}
@@ -274,13 +281,14 @@ func BenchmarkClusterSetString(b *testing.B) {
274281
b.Skip("skipping in short mode")
275282
}
276283

284+
ctx := context.Background()
277285
cluster := newClusterScenario()
278-
if err := startCluster(cluster); err != nil {
286+
if err := startCluster(ctx, cluster); err != nil {
279287
b.Fatal(err)
280288
}
281289
defer stopCluster(cluster)
282290

283-
client := cluster.newClusterClient(redisClusterOptions())
291+
client := cluster.newClusterClient(ctx, redisClusterOptions())
284292
defer client.Close()
285293

286294
value := string(bytes.Repeat([]byte{'1'}, 10000))
@@ -289,7 +297,7 @@ func BenchmarkClusterSetString(b *testing.B) {
289297

290298
b.RunParallel(func(pb *testing.PB) {
291299
for pb.Next() {
292-
err := client.Set("key", value, 0).Err()
300+
err := client.Set(ctx, "key", value, 0).Err()
293301
if err != nil {
294302
b.Fatal(err)
295303
}
@@ -302,19 +310,20 @@ func BenchmarkClusterReloadState(b *testing.B) {
302310
b.Skip("skipping in short mode")
303311
}
304312

313+
ctx := context.Background()
305314
cluster := newClusterScenario()
306-
if err := startCluster(cluster); err != nil {
315+
if err := startCluster(ctx, cluster); err != nil {
307316
b.Fatal(err)
308317
}
309318
defer stopCluster(cluster)
310319

311-
client := cluster.newClusterClient(redisClusterOptions())
320+
client := cluster.newClusterClient(ctx, redisClusterOptions())
312321
defer client.Close()
313322

314323
b.ResetTimer()
315324

316325
for i := 0; i < b.N; i++ {
317-
err := client.ReloadState()
326+
err := client.ReloadState(ctx)
318327
if err != nil {
319328
b.Fatal(err)
320329
}
@@ -324,11 +333,10 @@ func BenchmarkClusterReloadState(b *testing.B) {
324333
var clusterSink *redis.ClusterClient
325334

326335
func BenchmarkClusterWithContext(b *testing.B) {
336+
ctx := context.Background()
327337
rdb := redis.NewClusterClient(&redis.ClusterOptions{})
328338
defer rdb.Close()
329339

330-
ctx := context.Background()
331-
332340
b.ResetTimer()
333341
b.ReportAllocs()
334342

0 commit comments

Comments
 (0)