test(redis): retry initial writes on 'not leader' to absorb CI leader churn

TestRedis_LuaRPopLPushBullMQLikeLists flaked on CI when the newly-elected
raft leader briefly stepped down ("stepped down to follower since quorum
is not active") between waitForRaftReadiness returning and the first
RPUSH, causing the write to race a re-election and fail with
"etcd raft engine is not leader".
Add small rpushEventually / lpushEventually helpers (backed by a shared
doEventually that retries only on transient "not leader" errors) and use
them for the first two writes in the test. waitForRaftReadiness is left
untouched — other tests rely on its exact semantics.
Failing CI:
https://github.com/bootjp/elastickv/actions/runs/24842581631/job/72720509753

Author: bootjp

adapter/redis_lua_compat_test.go

@@ -121,8 +121,12 @@ func TestRedis_LuaRPopLPushBullMQLikeLists(t *testing.T) {
 rdb:=redis.NewClient(&redis.Options{Addr: nodes[0].redisAddress})
 deferfunc() { _=rdb.Close() }()
 
-require.NoError(t, rdb.RPush(ctx, "bull:test:wait", "job-1", "job-2", "job-3").Err())
-require.NoError(t, rdb.LPush(ctx, "bull:test:active", "job-0").Err())
+// Raft leadership can briefly churn right after createNode returns — the
+// freshly-elected leader can step down if the initial heartbeats miss
+// quorum on a slow CI runner (see waitForRaftReadiness). Retry the first
+// writes so they ride out that re-election instead of failing the test.
+rpushEventually(t, ctx, rdb, "bull:test:wait", "job-1", "job-2", "job-3")
+lpushEventually(t, ctx, rdb, "bull:test:active", "job-0")
 
 result, err:=rdb.Eval(ctx, `
 local moved = redis.call("RPOPLPUSH", KEYS[1], KEYS[2])

adapter/test_util.go

@@ -5,6 +5,7 @@ import (
 "log"
 "net"
 "strconv"
+"strings"
 "sync"
 "sync/atomic"
 "testing"
@@ -18,6 +19,7 @@ import (
 	pb "github.com/bootjp/elastickv/proto"
 "github.com/bootjp/elastickv/store"
 "github.com/cockroachdb/errors"
+"github.com/redis/go-redis/v9"
 "github.com/stretchr/testify/assert"
 "github.com/stretchr/testify/require"
 "golang.org/x/sys/unix"
@@ -30,6 +32,12 @@ const (
 testEngineElectionTick=10
 testEngineMaxSizePerMsg=1<<20
 testEngineMaxInflight=256
+
+// leaderChurnRetryTimeout bounds how long doEventually keeps retrying a
+// write that fails with "not leader" right after createNode returns.
+leaderChurnRetryTimeout=5*time.Second
+// leaderChurnRetryInterval is the poll interval between retries.
+leaderChurnRetryInterval=50*time.Millisecond
 )
 
 funcnewTestFactory() raftengine.Factory {
@@ -442,3 +450,50 @@ func setupNodes(t *testing.T, ctx context.Context, n int, ports []portsAdress) (
 
 returnnodes, grpcAdders, redisAdders, peers
 }
+
+// isTransientNotLeaderErr reports whether err is a transient "not leader"
+// error that can happen right after createNode returns if the newly elected
+// leader briefly steps down due to a missed heartbeat quorum (common on slow
+// CI runners under -race). Callers should retry the write in that case.
+funcisTransientNotLeaderErr(errerror) bool {
+iferr==nil {
+returnfalse
+	}
+returnstrings.Contains(err.Error(), "not leader")
+}
+
+// doEventually retries do() while it returns a transient "not leader" error,
+// giving the cluster a few seconds to re-settle leadership after startup.
+// Non-"not leader" errors fail the test immediately.
+funcdoEventually(t*testing.T, dofunc() error) {
+t.Helper()
+require.Eventually(t, func() bool {
+err:=do()
+iferr==nil {
+returntrue
+ }
+ifisTransientNotLeaderErr(err) {
+returnfalse
+ }
+require.NoError(t, err)
+returntrue
+	}, leaderChurnRetryTimeout, leaderChurnRetryInterval)
+}
+
+// rpushEventually wraps RPUSH in doEventually so transient leader churn
+// immediately after createNode doesn't fail the test.
+funcrpushEventually(t*testing.T, ctx context.Context, rdb*redis.Client, keystring, vals...any) {
+t.Helper()
+doEventually(t, func() error {
+returnrdb.RPush(ctx, key, vals...).Err()
+	})
+}
+
+// lpushEventually wraps LPUSH in doEventually so transient leader churn
+// immediately after createNode doesn't fail the test.
+funclpushEventually(t*testing.T, ctx context.Context, rdb*redis.Client, keystring, vals...any) {
+t.Helper()
+doEventually(t, func() error {
+returnrdb.LPush(ctx, key, vals...).Err()
+	})
+}