Files

172 lines
5.4 KiB
Go
Raw Permalink Normal View History

package delayqueue
import (
"context"
"io"
"log/slog"
"testing"
"time"
"github.com/alicebob/miniredis/v2"
"github.com/redis/go-redis/v9"
)
func TestGetRunAtReadsScoreWithoutPayload(t *testing.T) {
ctx := context.Background()
srv := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: srv.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
queue := NewRedisDelayQueue[string](rdb, slog.New(slog.NewTextHandler(io.Discard, nil)), WithPrefix[string]("test"))
runAt := time.Date(2026, 7, 13, 12, 0, 0, 123*int(time.Millisecond), time.UTC)
if _, err := queue.Enqueue(ctx, "recycle", "payload", runAt, "vm-1"); err != nil {
t.Fatal(err)
}
if err := rdb.Del(ctx, queue.jobKey("recycle", "vm-1")).Err(); err != nil {
t.Fatal(err)
}
got, ok, err := queue.GetRunAt(ctx, "recycle", "vm-1")
if err != nil || !ok {
t.Fatalf("GetRunAt() ok = %v, err = %v", ok, err)
}
if !got.Equal(runAt) {
t.Fatalf("run at = %v, want %v", got, runAt)
}
}
func TestGetRunAtReturnsMissing(t *testing.T) {
srv := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: srv.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
queue := NewRedisDelayQueue[string](rdb, slog.Default())
_, ok, err := queue.GetRunAt(context.Background(), "recycle", "missing")
if err != nil || ok {
t.Fatalf("GetRunAt() ok = %v, err = %v", ok, err)
}
}
2026-07-14 15:59:48 +08:00
func TestEnqueueIfMissingAddsNewJob(t *testing.T) {
ctx := context.Background()
srv := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: srv.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
queue := NewRedisDelayQueue[string](rdb, slog.Default())
runAt := time.Date(2026, 7, 13, 12, 0, 0, 0, time.UTC)
id, added, err := queue.EnqueueIfMissing(ctx, "recycle", "payload", runAt, "vm-1")
if err != nil {
t.Fatal(err)
}
if id != "vm-1" || !added {
t.Fatalf("id = %q, added = %v", id, added)
}
job, gotRunAt, ok, err := queue.GetJobInfo(ctx, "recycle", "vm-1")
if err != nil || !ok {
t.Fatalf("GetJobInfo() ok = %v, err = %v", ok, err)
}
if job.Payload != "payload" || !gotRunAt.Equal(runAt) {
t.Fatalf("job = %+v, run at = %v", job, gotRunAt)
}
}
func TestEnqueueIfMissingDoesNotOverwriteExistingJob(t *testing.T) {
ctx := context.Background()
srv := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: srv.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
queue := NewRedisDelayQueue[string](rdb, slog.Default())
originalRunAt := time.Date(2026, 7, 13, 12, 0, 0, 0, time.UTC)
if _, err := queue.Enqueue(ctx, "recycle", "original", originalRunAt, "vm-1"); err != nil {
t.Fatal(err)
}
_, added, err := queue.EnqueueIfMissing(ctx, "recycle", "replacement", originalRunAt.Add(time.Hour), "vm-1")
if err != nil {
t.Fatal(err)
}
if added {
t.Fatal("existing job must not be overwritten")
}
job, gotRunAt, ok, err := queue.GetJobInfo(ctx, "recycle", "vm-1")
if err != nil || !ok {
t.Fatalf("GetJobInfo() ok = %v, err = %v", ok, err)
}
if job.Payload != "original" || !gotRunAt.Equal(originalRunAt) {
t.Fatalf("job = %+v, run at = %v", job, gotRunAt)
}
}
2026-07-14 18:23:24 +08:00
func TestIsFinalAttemptUsesConfiguredMaxAttempts(t *testing.T) {
queue := NewRedisDelayQueue[string](nil, slog.Default(), WithMaxAttempts[string](3))
if queue.IsFinalAttempt(&Job[string]{Attempts: 1}) {
t.Fatal("second attempt must not be final")
}
if !queue.IsFinalAttempt(&Job[string]{Attempts: 2}) {
t.Fatal("third attempt must be final")
}
}
func TestPollOncePreservesJobForRetryAfterMaxAttempts(t *testing.T) {
ctx := context.Background()
srv := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: srv.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
queue := NewRedisDelayQueue[string](
rdb,
slog.Default(),
WithMaxAttempts[string](1),
WithRequeueDelay[string](0),
)
if _, err := queue.Enqueue(ctx, "recycle", "payload", time.Now(), "vm-1"); err != nil {
t.Fatal(err)
}
if err := queue.pollOnce(ctx, "recycle", func(context.Context, *Job[string]) error {
return ErrRetryAfterMaxAttempts
}); err != nil {
t.Fatal(err)
}
job, _, ok, err := queue.GetJobInfo(ctx, "recycle", "vm-1")
if err != nil || !ok {
t.Fatalf("job preserved = %v, err = %v", ok, err)
}
if job.Attempts != 0 {
t.Fatalf("attempts = %d, want 0", job.Attempts)
}
if err := queue.pollOnce(ctx, "recycle", func(context.Context, *Job[string]) error { return nil }); err != nil {
t.Fatal(err)
}
if _, _, ok, err := queue.GetJobInfo(ctx, "recycle", "vm-1"); err != nil || ok {
t.Fatalf("job preserved = %v, err = %v, want removed", ok, err)
}
}
2026-08-05 14:03:57 +08:00
func TestPollOncePreservesRefreshedJob(t *testing.T) {
ctx := context.Background()
srv := miniredis.RunT(t)
rdb := redis.NewClient(&redis.Options{Addr: srv.Addr()})
t.Cleanup(func() { _ = rdb.Close() })
queue := NewRedisDelayQueue[string](rdb, slog.Default())
if _, err := queue.Enqueue(ctx, "recycle", "old", time.Now(), "vm-1"); err != nil {
t.Fatal(err)
}
refreshedAt := time.Now().Add(time.Hour).Truncate(time.Millisecond)
if err := queue.pollOnce(ctx, "recycle", func(context.Context, *Job[string]) error {
if _, err := queue.Enqueue(ctx, "recycle", "refreshed", refreshedAt, "vm-1"); err != nil {
return err
}
return ErrJobRescheduled
}); err != nil {
t.Fatal(err)
}
job, runAt, ok, err := queue.GetJobInfo(ctx, "recycle", "vm-1")
if err != nil || !ok {
t.Fatalf("refreshed job ok = %v, err = %v", ok, err)
}
if job.Payload != "refreshed" || !runAt.Equal(refreshedAt) || job.Attempts != 0 {
t.Fatalf("job = %+v, run at = %v", job, runAt)
}
}