Rename asynqtest package to testutil

aggregator_test.go

@@ -10,9 +10,9 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/rdb"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 func TestAggregator(t *testing.T) {

asynq_test.go

@@ -14,8 +14,8 @@ import (
 	"github.com/go-redis/redis/v8"
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/log"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 //============================================================================

benchmark_test.go

@@ -12,7 +12,7 @@ import (
 	"testing"
 	"time"
 
-	h "github.com/hibiken/asynq/internal/asynqtest"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 // Creates a new task of type "task<n>" with payload {"data": n}.

client_test.go

@@ -12,8 +12,8 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 func TestClientEnqueueWithProcessAtOption(t *testing.T) {

forwarder_test.go

@@ -10,9 +10,9 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/rdb"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 func TestForwarder(t *testing.T) {

heartbeat_test.go

@@ -12,10 +12,10 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/rdb"
 	"github.com/hibiken/asynq/internal/testbroker"
+	h "github.com/hibiken/asynq/internal/testutil"
 	"github.com/hibiken/asynq/internal/timeutil"
 )
 

inspector_test.go

@@ -15,9 +15,9 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/rdb"
+	h "github.com/hibiken/asynq/internal/testutil"
 	"github.com/hibiken/asynq/internal/timeutil"
 )
 

internal/rdb/benchmark_test.go

@@ -10,19 +10,19 @@ import (
 	"testing"
 	"time"
 
-	"github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
+	"github.com/hibiken/asynq/internal/testutil"
 )
 
 func BenchmarkEnqueue(b *testing.B) {
 	r := setup(b)
 	ctx := context.Background()
-	msg := asynqtest.NewTaskMessage("task1", nil)
+	msg := testutil.NewTaskMessage("task1", nil)
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		testutil.FlushDB(b, r.client)
 		b.StartTimer()
 
 		if err := r.Enqueue(ctx, msg); err != nil {
@@ -45,7 +45,7 @@ func BenchmarkEnqueueUnique(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		testutil.FlushDB(b, r.client)
 		b.StartTimer()
 
 		if err := r.EnqueueUnique(ctx, msg, uniqueTTL); err != nil {
@@ -57,13 +57,13 @@ func BenchmarkEnqueueUnique(b *testing.B) {
 func BenchmarkSchedule(b *testing.B) {
 	r := setup(b)
 	ctx := context.Background()
-	msg := asynqtest.NewTaskMessage("task1", nil)
+	msg := testutil.NewTaskMessage("task1", nil)
 	processAt := time.Now().Add(3 * time.Minute)
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		testutil.FlushDB(b, r.client)
 		b.StartTimer()
 
 		if err := r.Schedule(ctx, msg, processAt); err != nil {
@@ -87,7 +87,7 @@ func BenchmarkScheduleUnique(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		testutil.FlushDB(b, r.client)
 		b.StartTimer()
 
 		if err := r.ScheduleUnique(ctx, msg, processAt, uniqueTTL); err != nil {
@@ -103,9 +103,9 @@ func BenchmarkDequeueSingleQueue(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		testutil.FlushDB(b, r.client)
 		for i := 0; i < 10; i++ {
-			m := asynqtest.NewTaskMessageWithQueue(
+			m := testutil.NewTaskMessageWithQueue(
 				fmt.Sprintf("task%d", i), nil, base.DefaultQueueName)
 			if err := r.Enqueue(ctx, m); err != nil {
 				b.Fatalf("Enqueue failed: %v", err)
@@ -127,10 +127,10 @@ func BenchmarkDequeueMultipleQueues(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
+		testutil.FlushDB(b, r.client)
 		for i := 0; i < 10; i++ {
 			for _, qname := range qnames {
-				m := asynqtest.NewTaskMessageWithQueue(
+				m := testutil.NewTaskMessageWithQueue(
 					fmt.Sprintf("%s_task%d", qname, i), nil, qname)
 				if err := r.Enqueue(ctx, m); err != nil {
 					b.Fatalf("Enqueue failed: %v", err)
@@ -147,9 +147,9 @@ func BenchmarkDequeueMultipleQueues(b *testing.B) {
 
 func BenchmarkDone(b *testing.B) {
 	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
+	m1 := testutil.NewTaskMessage("task1", nil)
+	m2 := testutil.NewTaskMessage("task2", nil)
+	m3 := testutil.NewTaskMessage("task3", nil)
 	msgs := []*base.TaskMessage{m1, m2, m3}
 	zs := []base.Z{
 		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
@@ -161,9 +161,9 @@ func BenchmarkDone(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedLease(b, r.client, zs, base.DefaultQueueName)
+		testutil.FlushDB(b, r.client)
+		testutil.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
+		testutil.SeedLease(b, r.client, zs, base.DefaultQueueName)
 		b.StartTimer()
 
 		if err := r.Done(ctx, msgs[0]); err != nil {
@@ -174,9 +174,9 @@ func BenchmarkDone(b *testing.B) {
 
 func BenchmarkRetry(b *testing.B) {
 	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
+	m1 := testutil.NewTaskMessage("task1", nil)
+	m2 := testutil.NewTaskMessage("task2", nil)
+	m3 := testutil.NewTaskMessage("task3", nil)
 	msgs := []*base.TaskMessage{m1, m2, m3}
 	zs := []base.Z{
 		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
@@ -188,9 +188,9 @@ func BenchmarkRetry(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedLease(b, r.client, zs, base.DefaultQueueName)
+		testutil.FlushDB(b, r.client)
+		testutil.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
+		testutil.SeedLease(b, r.client, zs, base.DefaultQueueName)
 		b.StartTimer()
 
 		if err := r.Retry(ctx, msgs[0], time.Now().Add(1*time.Minute), "error", true /*isFailure*/); err != nil {
@@ -201,9 +201,9 @@ func BenchmarkRetry(b *testing.B) {
 
 func BenchmarkArchive(b *testing.B) {
 	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
+	m1 := testutil.NewTaskMessage("task1", nil)
+	m2 := testutil.NewTaskMessage("task2", nil)
+	m3 := testutil.NewTaskMessage("task3", nil)
 	msgs := []*base.TaskMessage{m1, m2, m3}
 	zs := []base.Z{
 		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
@@ -215,9 +215,9 @@ func BenchmarkArchive(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedLease(b, r.client, zs, base.DefaultQueueName)
+		testutil.FlushDB(b, r.client)
+		testutil.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
+		testutil.SeedLease(b, r.client, zs, base.DefaultQueueName)
 		b.StartTimer()
 
 		if err := r.Archive(ctx, msgs[0], "error"); err != nil {
@@ -228,9 +228,9 @@ func BenchmarkArchive(b *testing.B) {
 
 func BenchmarkRequeue(b *testing.B) {
 	r := setup(b)
-	m1 := asynqtest.NewTaskMessage("task1", nil)
-	m2 := asynqtest.NewTaskMessage("task2", nil)
-	m3 := asynqtest.NewTaskMessage("task3", nil)
+	m1 := testutil.NewTaskMessage("task1", nil)
+	m2 := testutil.NewTaskMessage("task2", nil)
+	m3 := testutil.NewTaskMessage("task3", nil)
 	msgs := []*base.TaskMessage{m1, m2, m3}
 	zs := []base.Z{
 		{Message: m1, Score: time.Now().Add(10 * time.Second).Unix()},
@@ -242,9 +242,9 @@ func BenchmarkRequeue(b *testing.B) {
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
-		asynqtest.SeedLease(b, r.client, zs, base.DefaultQueueName)
+		testutil.FlushDB(b, r.client)
+		testutil.SeedActiveQueue(b, r.client, msgs, base.DefaultQueueName)
+		testutil.SeedLease(b, r.client, zs, base.DefaultQueueName)
 		b.StartTimer()
 
 		if err := r.Requeue(ctx, msgs[0]); err != nil {
@@ -258,16 +258,16 @@ func BenchmarkCheckAndEnqueue(b *testing.B) {
 	now := time.Now()
 	var zs []base.Z
 	for i := -100; i < 100; i++ {
-		msg := asynqtest.NewTaskMessage(fmt.Sprintf("task%d", i), nil)
+		msg := testutil.NewTaskMessage(fmt.Sprintf("task%d", i), nil)
 		score := now.Add(time.Duration(i) * time.Second).Unix()
 		zs = append(zs, base.Z{Message: msg, Score: score})
 	}
 	b.ResetTimer()
 
 	for i := 0; i < b.N; i++ {
 		b.StopTimer()
-		asynqtest.FlushDB(b, r.client)
-		asynqtest.SeedScheduledQueue(b, r.client, zs, base.DefaultQueueName)
+		testutil.FlushDB(b, r.client)
+		testutil.SeedScheduledQueue(b, r.client, zs, base.DefaultQueueName)
 		b.StartTimer()
 
 		if err := r.ForwardIfReady(base.DefaultQueueName); err != nil {

internal/rdb/inspect_test.go

@@ -16,9 +16,9 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/errors"
+	h "github.com/hibiken/asynq/internal/testutil"
 	"github.com/hibiken/asynq/internal/timeutil"
 )
 

internal/rdb/rdb_test.go

@@ -19,9 +19,9 @@ import (
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
 	"github.com/google/uuid"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/errors"
+	h "github.com/hibiken/asynq/internal/testutil"
 	"github.com/hibiken/asynq/internal/timeutil"
 )
 

internal/testbroker/testbroker.go

@@ -15,7 +15,7 @@ import (
 	"github.com/hibiken/asynq/internal/base"
 )
 
-var errRedisDown = errors.New("asynqtest: redis is down")
+var errRedisDown = errors.New("testutil: redis is down")
 
 // TestBroker is a broker implementation which enables
 // to simulate Redis failure in tests.

internal/asynqtest/builder.go → internal/testutil/builder.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a MIT license
 // that can be found in the LICENSE file.
 
-package asynqtest
+package testutil
 
 import (
 	"time"

internal/asynqtest/builder_test.go → internal/testutil/builder_test.go

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a MIT license
 // that can be found in the LICENSE file.
 
-package asynqtest
+package testutil
 
 import (
 	"testing"

internal/asynqtest/asynqtest.go → internal/testutil/testutil.go

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a MIT license
 // that can be found in the LICENSE file.
 
-// Package asynqtest defines test helpers for asynq and its internal packages.
-package asynqtest
+// Package testutil defines test helpers for asynq and its internal packages.
+package testutil
 
 import (
 	"context"

janitor_test.go

@@ -10,9 +10,9 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/rdb"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 func newCompletedTask(qname, tasktype string, payload []byte, completedAt time.Time) *base.TaskMessage {

processor_test.go

@@ -15,11 +15,11 @@ import (
 
 	"github.com/google/go-cmp/cmp"
 	"github.com/google/go-cmp/cmp/cmpopts"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/errors"
 	"github.com/hibiken/asynq/internal/log"
 	"github.com/hibiken/asynq/internal/rdb"
+	h "github.com/hibiken/asynq/internal/testutil"
 	"github.com/hibiken/asynq/internal/timeutil"
 )
 

recoverer_test.go

@@ -10,9 +10,9 @@ import (
 	"time"
 
 	"github.com/google/go-cmp/cmp"
-	h "github.com/hibiken/asynq/internal/asynqtest"
 	"github.com/hibiken/asynq/internal/base"
 	"github.com/hibiken/asynq/internal/rdb"
+	h "github.com/hibiken/asynq/internal/testutil"
 )
 
 func TestRecoverer(t *testing.T) {