redis/go-redis
1
0
Fork 0
mirror of https://github.com/redis/go-redis.git synced 2025-11-04 02:33:24 +03:00
Code Activity
Files
ae5434ce660f0275440ab78a6a706b9691a98a25
go-redis/doctests/list_tutorial_test.go
Nedyalko Dyakov ebe11d06ca feat: Enable CI for Redis CE 8.0 (#3274) 
* chore: extract benchmark tests

* wip

* enable pubsub tests

* enable ring tests

* stop tests with build redis from source

* start all tests

* mix of makefile and action

* add sentinel configs

* fix example test

* stop debug on re

* wip

* enable gears for redis 7.2

* wip

* enable sentinel, they are expected to fail

* fix: linter configuration

* chore: update re versions

* return older redis enterprise version

* add basic codeql

* wip: increase timeout, focus only sentinel tests

* sentinels with docker network host

* enable all tests

* fix flanky test

* enable example tests

* tidy docker compose

* add debug output

* stop shutingdown masters

* don't test sentinel for re

* skip unsuported addscores

* Update README

bump go version in CI

* Update README.md

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Update CONTRIBUTING.md

add information about new test setup

---------

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
2025-02-28 12:49:00 +02:00

789 lines
13 KiB
Go
Raw Blame History

// EXAMPLE: list_tutorial
// HIDE_START
package example_commands_test
import (
"context"
"fmt"
"github.com/redis/go-redis/v9"
)
// HIDE_END
func ExampleClient_queue() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// make sure we are working with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START queue
res1, err := rdb.LPush(ctx, "bikes:repairs", "bike:1").Result()
if err != nil {
panic(err)
}
fmt.Println(res1) // >>> 1
res2, err := rdb.LPush(ctx, "bikes:repairs", "bike:2").Result()
if err != nil {
panic(err)
}
fmt.Println(res2) // >>> 2
res3, err := rdb.RPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res3) // >>> bike:1
res4, err := rdb.RPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res4) // >>> bike:2
// STEP_END
// Output:
// 1
// 2
// bike:1
// bike:2
}
func ExampleClient_stack() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START stack
res5, err := rdb.LPush(ctx, "bikes:repairs", "bike:1").Result()
if err != nil {
panic(err)
}
fmt.Println(res5) // >>> 1
res6, err := rdb.LPush(ctx, "bikes:repairs", "bike:2").Result()
if err != nil {
panic(err)
}
fmt.Println(res6) // >>> 2
res7, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res7) // >>> bike:2
res8, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res8) // >>> bike:1
// STEP_END
// Output:
// 1
// 2
// bike:2
// bike:1
}
func ExampleClient_llen() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START llen
res9, err := rdb.LLen(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res9) // >>> 0
// STEP_END
// Output:
// 0
}
func ExampleClient_lmove_lrange() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
rdb.Del(ctx, "bikes:finished")
// REMOVE_END
// STEP_START lmove_lrange
res10, err := rdb.LPush(ctx, "bikes:repairs", "bike:1").Result()
if err != nil {
panic(err)
}
fmt.Println(res10) // >>> 1
res11, err := rdb.LPush(ctx, "bikes:repairs", "bike:2").Result()
if err != nil {
panic(err)
}
fmt.Println(res11) // >>> 2
res12, err := rdb.LMove(ctx, "bikes:repairs", "bikes:finished", "LEFT", "LEFT").Result()
if err != nil {
panic(err)
}
fmt.Println(res12) // >>> bike:2
res13, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res13) // >>> [bike:1]
res14, err := rdb.LRange(ctx, "bikes:finished", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res14) // >>> [bike:2]
// STEP_END
// Output:
// 1
// 2
// bike:2
// [bike:1]
// [bike:2]
}
func ExampleClient_lpush_rpush() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START lpush_rpush
res15, err := rdb.RPush(ctx, "bikes:repairs", "bike:1").Result()
if err != nil {
panic(err)
}
fmt.Println(res15) // >>> 1
res16, err := rdb.RPush(ctx, "bikes:repairs", "bike:2").Result()
if err != nil {
panic(err)
}
fmt.Println(res16) // >>> 2
res17, err := rdb.LPush(ctx, "bikes:repairs", "bike:important_bike").Result()
if err != nil {
panic(err)
}
fmt.Println(res17) // >>> 3
res18, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res18) // >>> [bike:important_bike bike:1 bike:2]
// STEP_END
// Output:
// 1
// 2
// 3
// [bike:important_bike bike:1 bike:2]
}
func ExampleClient_variadic() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START variadic
res19, err := rdb.RPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3").Result()
if err != nil {
panic(err)
}
fmt.Println(res19) // >>> 3
res20, err := rdb.LPush(ctx, "bikes:repairs", "bike:important_bike", "bike:very_important_bike").Result()
if err != nil {
panic(err)
}
fmt.Println(res20) // >>> 5
res21, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res21) // >>> [bike:very_important_bike bike:important_bike bike:1 bike:2 bike:3]
// STEP_END
// Output:
// 3
// 5
// [bike:very_important_bike bike:important_bike bike:1 bike:2 bike:3]
}
func ExampleClient_lpop_rpop() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START lpop_rpop
res22, err := rdb.RPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3").Result()
if err != nil {
panic(err)
}
fmt.Println(res22) // >>> 3
res23, err := rdb.RPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res23) // >>> bike:3
res24, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res24) // >>> bike:1
res25, err := rdb.RPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res25) // >>> bike:2
res26, err := rdb.RPop(ctx, "bikes:repairs").Result()
if err != nil {
fmt.Println(err) // >>> redis: nil
}
fmt.Println(res26) // >>> <empty string>
// STEP_END
// Output:
// 3
// bike:3
// bike:1
// bike:2
// redis: nil
//
}
func ExampleClient_ltrim() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START ltrim
res27, err := rdb.RPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5").Result()
if err != nil {
panic(err)
}
fmt.Println(res27) // >>> 5
res28, err := rdb.LTrim(ctx, "bikes:repairs", 0, 2).Result()
if err != nil {
panic(err)
}
fmt.Println(res28) // >>> OK
res29, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res29) // >>> [bike:1 bike:2 bike:3]
// STEP_END
// Output:
// 5
// OK
// [bike:1 bike:2 bike:3]
}
func ExampleClient_ltrim_end_of_list() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START ltrim_end_of_list
res30, err := rdb.RPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5").Result()
if err != nil {
panic(err)
}
fmt.Println(res30) // >>> 5
res31, err := rdb.LTrim(ctx, "bikes:repairs", -3, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res31) // >>> OK
res32, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res32) // >>> [bike:3 bike:4 bike:5]
// STEP_END
// Output:
// 5
// OK
// [bike:3 bike:4 bike:5]
}
func ExampleClient_brpop() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START brpop
res33, err := rdb.RPush(ctx, "bikes:repairs", "bike:1", "bike:2").Result()
if err != nil {
panic(err)
}
fmt.Println(res33) // >>> 2
res34, err := rdb.BRPop(ctx, 1, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res34) // >>> [bikes:repairs bike:2]
res35, err := rdb.BRPop(ctx, 1, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res35) // >>> [bikes:repairs bike:1]
res36, err := rdb.BRPop(ctx, 1, "bikes:repairs").Result()
if err != nil {
fmt.Println(err) // >>> redis: nil
}
fmt.Println(res36) // >>> []
// STEP_END
// Output:
// 2
// [bikes:repairs bike:2]
// [bikes:repairs bike:1]
// redis: nil
// []
}
func ExampleClient_rule1() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
// start with fresh database
rdb.FlushDB(ctx)
rdb.Del(ctx, "new_bikes")
// REMOVE_END
// STEP_START rule_1
res37, err := rdb.Del(ctx, "new_bikes").Result()
if err != nil {
panic(err)
}
fmt.Println(res37) // >>> 0
res38, err := rdb.LPush(ctx, "new_bikes", "bike:1", "bike:2", "bike:3").Result()
if err != nil {
panic(err)
}
fmt.Println(res38) // >>> 3
// STEP_END
// Output:
// 0
// 3
}
func ExampleClient_rule11() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
rdb.Del(ctx, "new_bikes")
// REMOVE_END
// STEP_START rule_1.1
res39, err := rdb.Set(ctx, "new_bikes", "bike:1", 0).Result()
if err != nil {
panic(err)
}
fmt.Println(res39) // >>> OK
res40, err := rdb.Type(ctx, "new_bikes").Result()
if err != nil {
panic(err)
}
fmt.Println(res40) // >>> string
res41, err := rdb.LPush(ctx, "new_bikes", "bike:2", "bike:3").Result()
if err != nil {
fmt.Println(err)
// >>> WRONGTYPE Operation against a key holding the wrong kind of value
}
fmt.Println(res41)
// STEP_END
// Output:
// OK
// string
// WRONGTYPE Operation against a key holding the wrong kind of value
// 0
}
func ExampleClient_rule2() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START rule_2
res42, err := rdb.LPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3").Result()
if err != nil {
panic(err)
}
fmt.Println(res42) // >>> 3
res43, err := rdb.Exists(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res43) // >>> 1
res44, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res44) // >>> bike:3
res45, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res45) // >>> bike:2
res46, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res46) // >>> bike:1
res47, err := rdb.Exists(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res47) // >>> 0
// STEP_END
// Output:
// 3
// 1
// bike:3
// bike:2
// bike:1
// 0
}
func ExampleClient_rule3() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START rule_3
res48, err := rdb.Del(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res48) // >>> 0
res49, err := rdb.LLen(ctx, "bikes:repairs").Result()
if err != nil {
panic(err)
}
fmt.Println(res49) // >>> 0
res50, err := rdb.LPop(ctx, "bikes:repairs").Result()
if err != nil {
fmt.Println(err) // >>> redis: nil
}
fmt.Println(res50) // >>> <empty string>
// STEP_END
// Output:
// 0
// 0
// redis: nil
//
}
func ExampleClient_ltrim1() {
ctx := context.Background()
rdb := redis.NewClient(&redis.Options{
Addr: "localhost:6379",
Password: "", // no password docs
DB: 0, // use default DB
})
// REMOVE_START
rdb.Del(ctx, "bikes:repairs")
// REMOVE_END
// STEP_START ltrim.1
res51, err := rdb.LPush(ctx, "bikes:repairs", "bike:1", "bike:2", "bike:3", "bike:4", "bike:5").Result()
if err != nil {
panic(err)
}
fmt.Println(res51) // >>> 5
res52, err := rdb.LTrim(ctx, "bikes:repairs", 0, 2).Result()
if err != nil {
panic(err)
}
fmt.Println(res52) // >>> OK
res53, err := rdb.LRange(ctx, "bikes:repairs", 0, -1).Result()
if err != nil {
panic(err)
}
fmt.Println(res53) // >>> [bike:5 bike:4 bike:3]
// STEP_END
// Output:
// 5
// OK
// [bike:5 bike:4 bike:3]
}
View Git Blame Copy Permalink