Rename Enqueued to Pending

internal/rdb/inspect.go

@@ -31,7 +31,7 @@ type Stats struct {
 	// Size is the total number of tasks in the queue.
 	Size int
 	// Number of tasks in each state.
-	Enqueued   int
+	Pending    int
 	InProgress int
 	Scheduled  int
 	Retry      int
@@ -133,7 +133,7 @@ func (r *RDB) CurrentStats(qname string) (*Stats, error) {
 		val := cast.ToInt(data[i+1])
 		switch key {
 		case base.QueueKey(qname):
-			stats.Enqueued = val
+			stats.Pending = val
 			size += val
 		case base.InProgressKey(qname):
 			stats.InProgress = val
@@ -258,8 +258,8 @@ func (p Pagination) stop() int64 {
 	return int64(p.Size*p.Page + p.Size - 1)
 }
 
-// ListEnqueued returns enqueued tasks that are ready to be processed.
-func (r *RDB) ListEnqueued(qname string, pgn Pagination) ([]*base.TaskMessage, error) {
+// ListPending returns pending tasks that are ready to be processed.
+func (r *RDB) ListPending(qname string, pgn Pagination) ([]*base.TaskMessage, error) {
 	if !r.client.SIsMember(base.AllQueues, qname).Val() {
 		return nil, fmt.Errorf("queue %q does not exist", qname)
 	}
@@ -680,12 +680,12 @@ return redis.status_reply("OK")`)
 // KEYS[5] -> asynq:{<qname>}:dead
 // KEYS[6] -> asynq:{<qname>}:deadlines
 var removeQueueCmd = redis.NewScript(`
-local enqueued = redis.call("LLEN", KEYS[1]) 
+local pending = redis.call("LLEN", KEYS[1]) 
 local inprogress = redis.call("LLEN", KEYS[2])
 local scheduled = redis.call("SCARD", KEYS[3])
 local retry = redis.call("SCARD", KEYS[4])
 local dead = redis.call("SCARD", KEYS[5])
-local total = enqueued + inprogress + scheduled + retry + dead
+local total = pending + inprogress + scheduled + retry + dead
 if total > 0 then
 	return redis.error_reply("QUEUE NOT EMPTY")
 end

internal/rdb/inspect_test.go

@@ -57,7 +57,7 @@ func TestCurrentStats(t *testing.T) {
 	now := time.Now()
 
 	tests := []struct {
-		enqueued   map[string][]*base.TaskMessage
+		pending    map[string][]*base.TaskMessage
 		inProgress map[string][]*base.TaskMessage
 		scheduled  map[string][]base.Z
 		retry      map[string][]base.Z
@@ -69,7 +69,7 @@ func TestCurrentStats(t *testing.T) {
 		want       *Stats
 	}{
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {m1},
 				"critical": {m5},
 				"low":      {m6},
@@ -113,7 +113,7 @@ func TestCurrentStats(t *testing.T) {
 				Queue:      "default",
 				Paused:     false,
 				Size:       4,
-				Enqueued:   1,
+				Pending:    1,
 				InProgress: 1,
 				Scheduled:  2,
 				Retry:      0,
@@ -124,7 +124,7 @@ func TestCurrentStats(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {m1},
 				"critical": {m5},
 				"low":      {m6},
@@ -168,7 +168,7 @@ func TestCurrentStats(t *testing.T) {
 				Queue:      "critical",
 				Paused:     true,
 				Size:       1,
-				Enqueued:   1,
+				Pending:    1,
 				InProgress: 0,
 				Scheduled:  0,
 				Retry:      0,
@@ -187,7 +187,7 @@ func TestCurrentStats(t *testing.T) {
 				t.Fatal(err)
 			}
 		}
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 		h.SeedAllInProgressQueues(t, r.client, tc.inProgress)
 		h.SeedAllScheduledQueues(t, r.client, tc.scheduled)
 		h.SeedAllRetryQueues(t, r.client, tc.retry)
@@ -303,7 +303,7 @@ func TestRedisInfo(t *testing.T) {
 	}
 }
 
-func TestListEnqueued(t *testing.T) {
+func TestListPending(t *testing.T) {
 	r := setup(t)
 
 	m1 := h.NewTaskMessage("send_email", map[string]interface{}{"subject": "hello"})
@@ -312,26 +312,26 @@ func TestListEnqueued(t *testing.T) {
 	m4 := h.NewTaskMessageWithQueue("minor_notification", nil, "low")
 
 	tests := []struct {
-		enqueued map[string][]*base.TaskMessage
-		qname    string
-		want     []*base.TaskMessage
+		pending map[string][]*base.TaskMessage
+		qname   string
+		want    []*base.TaskMessage
 	}{
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				base.DefaultQueueName: {m1, m2},
 			},
 			qname: base.DefaultQueueName,
 			want:  []*base.TaskMessage{m1, m2},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				base.DefaultQueueName: nil,
 			},
 			qname: base.DefaultQueueName,
 			want:  []*base.TaskMessage(nil),
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				base.DefaultQueueName: {m1, m2},
 				"critical":            {m3},
 				"low":                 {m4},
@@ -340,7 +340,7 @@ func TestListEnqueued(t *testing.T) {
 			want:  []*base.TaskMessage{m1, m2},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				base.DefaultQueueName: {m1, m2},
 				"critical":            {m3},
 				"low":                 {m4},
@@ -352,10 +352,10 @@ func TestListEnqueued(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r.client) // clean up db before each test case
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 
-		got, err := r.ListEnqueued(tc.qname, Pagination{Size: 20, Page: 0})
-		op := fmt.Sprintf("r.ListEnqueued(%q, Pagination{Size: 20, Page: 0})", tc.qname)
+		got, err := r.ListPending(tc.qname, Pagination{Size: 20, Page: 0})
+		op := fmt.Sprintf("r.ListPending(%q, Pagination{Size: 20, Page: 0})", tc.qname)
 		if err != nil {
 			t.Errorf("%s = %v, %v, want %v, nil", op, got, err, tc.want)
 			continue
@@ -367,7 +367,7 @@ func TestListEnqueued(t *testing.T) {
 	}
 }
 
-func TestListEnqueuedPagination(t *testing.T) {
+func TestListPendingPagination(t *testing.T) {
 	r := setup(t)
 	var msgs []*base.TaskMessage
 	for i := 0; i < 100; i++ {
@@ -375,7 +375,7 @@ func TestListEnqueuedPagination(t *testing.T) {
 		msgs = append(msgs, msg)
 	}
 	// create 100 tasks in default queue
-	h.SeedEnqueuedQueue(t, r.client, msgs, "default")
+	h.SeedPendingQueue(t, r.client, msgs, "default")
 
 	msgs = []*base.TaskMessage(nil) // empty list
 	for i := 0; i < 100; i++ {
@@ -383,7 +383,7 @@ func TestListEnqueuedPagination(t *testing.T) {
 		msgs = append(msgs, msg)
 	}
 	// create 100 tasks in custom queue
-	h.SeedEnqueuedQueue(t, r.client, msgs, "custom")
+	h.SeedPendingQueue(t, r.client, msgs, "custom")
 
 	tests := []struct {
 		desc      string
@@ -403,8 +403,8 @@ func TestListEnqueuedPagination(t *testing.T) {
 	}
 
 	for _, tc := range tests {
-		got, err := r.ListEnqueued(tc.qname, Pagination{Size: tc.size, Page: tc.page})
-		op := fmt.Sprintf("r.ListEnqueued(%q, Pagination{Size: %d, Page: %d})", tc.qname, tc.size, tc.page)
+		got, err := r.ListPending(tc.qname, Pagination{Size: tc.size, Page: tc.page})
+		op := fmt.Sprintf("r.ListPending(%q, Pagination{Size: %d, Page: %d})", tc.qname, tc.size, tc.page)
 		if err != nil {
 			t.Errorf("%s; %s returned error %v", tc.desc, op, err)
 			continue
@@ -990,13 +990,13 @@ func TestEnqueueDeadTask(t *testing.T) {
 	s2 := time.Now().Add(-time.Hour).Unix()
 
 	tests := []struct {
-		dead         map[string][]base.Z
-		qname        string
-		score        int64
-		id           uuid.UUID
-		want         error // expected return value from calling EnqueueDeadTask
-		wantDead     map[string][]*base.TaskMessage
-		wantEnqueued map[string][]*base.TaskMessage
+		dead        map[string][]base.Z
+		qname       string
+		score       int64
+		id          uuid.UUID
+		want        error // expected return value from calling EnqueueDeadTask
+		wantDead    map[string][]*base.TaskMessage
+		wantPending map[string][]*base.TaskMessage
 	}{
 		{
 			dead: map[string][]base.Z{
@@ -1012,7 +1012,7 @@ func TestEnqueueDeadTask(t *testing.T) {
 			wantDead: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t2},
 			},
 		},
@@ -1030,7 +1030,7 @@ func TestEnqueueDeadTask(t *testing.T) {
 			wantDead: map[string][]*base.TaskMessage{
 				"default": {t1, t2},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 		},
@@ -1052,7 +1052,7 @@ func TestEnqueueDeadTask(t *testing.T) {
 				"default":  {t1, t2},
 				"critical": {},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {},
 				"critical": {t3},
 			},
@@ -1069,9 +1069,9 @@ func TestEnqueueDeadTask(t *testing.T) {
 			continue
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q; (-want, +got)\n%s", base.QueueKey(qname), diff)
 			}
 		}
@@ -1094,13 +1094,13 @@ func TestEnqueueRetryTask(t *testing.T) {
 	s1 := time.Now().Add(-5 * time.Minute).Unix()
 	s2 := time.Now().Add(-time.Hour).Unix()
 	tests := []struct {
-		retry        map[string][]base.Z
-		qname        string
-		score        int64
-		id           uuid.UUID
-		want         error // expected return value from calling EnqueueRetryTask
-		wantRetry    map[string][]*base.TaskMessage
-		wantEnqueued map[string][]*base.TaskMessage
+		retry       map[string][]base.Z
+		qname       string
+		score       int64
+		id          uuid.UUID
+		want        error // expected return value from calling EnqueueRetryTask
+		wantRetry   map[string][]*base.TaskMessage
+		wantPending map[string][]*base.TaskMessage
 	}{
 		{
 			retry: map[string][]base.Z{
@@ -1116,7 +1116,7 @@ func TestEnqueueRetryTask(t *testing.T) {
 			wantRetry: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t2},
 			},
 		},
@@ -1134,7 +1134,7 @@ func TestEnqueueRetryTask(t *testing.T) {
 			wantRetry: map[string][]*base.TaskMessage{
 				"default": {t1, t2},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 		},
@@ -1156,7 +1156,7 @@ func TestEnqueueRetryTask(t *testing.T) {
 				"default": {t1, t2},
 				"low":     {},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 				"low":     {t3},
 			},
@@ -1173,9 +1173,9 @@ func TestEnqueueRetryTask(t *testing.T) {
 			continue
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q; (-want, +got)\n%s", base.QueueKey(qname), diff)
 			}
 		}
@@ -1204,7 +1204,7 @@ func TestEnqueueScheduledTask(t *testing.T) {
 		id            uuid.UUID
 		want          error // expected return value from calling EnqueueScheduledTask
 		wantScheduled map[string][]*base.TaskMessage
-		wantEnqueued  map[string][]*base.TaskMessage
+		wantPending   map[string][]*base.TaskMessage
 	}{
 		{
 			scheduled: map[string][]base.Z{
@@ -1220,7 +1220,7 @@ func TestEnqueueScheduledTask(t *testing.T) {
 			wantScheduled: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t2},
 			},
 		},
@@ -1238,7 +1238,7 @@ func TestEnqueueScheduledTask(t *testing.T) {
 			wantScheduled: map[string][]*base.TaskMessage{
 				"default": {t1, t2},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 		},
@@ -1260,7 +1260,7 @@ func TestEnqueueScheduledTask(t *testing.T) {
 				"default":       {t1, t2},
 				"notifications": {},
 			},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":       {},
 				"notifications": {t3},
 			},
@@ -1277,9 +1277,9 @@ func TestEnqueueScheduledTask(t *testing.T) {
 			continue
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q; (-want, +got)\n%s", base.QueueKey(qname), diff)
 			}
 		}
@@ -1306,7 +1306,7 @@ func TestEnqueueAllScheduledTasks(t *testing.T) {
 		scheduled     map[string][]base.Z
 		qname         string
 		want          int64
-		wantEnqueued  map[string][]*base.TaskMessage
+		wantPending   map[string][]*base.TaskMessage
 		wantScheduled map[string][]*base.TaskMessage
 	}{
 		{
@@ -1320,7 +1320,7 @@ func TestEnqueueAllScheduledTasks(t *testing.T) {
 			},
 			qname: "default",
 			want:  3,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1, t2, t3},
 			},
 			wantScheduled: map[string][]*base.TaskMessage{
@@ -1334,7 +1334,7 @@ func TestEnqueueAllScheduledTasks(t *testing.T) {
 			},
 			qname: "default",
 			want:  0,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			wantScheduled: map[string][]*base.TaskMessage{
@@ -1356,7 +1356,7 @@ func TestEnqueueAllScheduledTasks(t *testing.T) {
 			},
 			qname: "custom",
 			want:  2,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 				"custom":  {t4, t5},
 			},
@@ -1383,9 +1383,9 @@ func TestEnqueueAllScheduledTasks(t *testing.T) {
 				tc.desc, tc.qname, got, err, tc.want)
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("%s; mismatch found in %q; (-want, +got)\n%s", tc.desc, base.QueueKey(qname), diff)
 			}
 		}
@@ -1407,12 +1407,12 @@ func TestEnqueueAllRetryTasks(t *testing.T) {
 	t5 := h.NewTaskMessageWithQueue("minor_notification", nil, "custom")
 
 	tests := []struct {
-		desc         string
-		retry        map[string][]base.Z
-		qname        string
-		want         int64
-		wantEnqueued map[string][]*base.TaskMessage
-		wantRetry    map[string][]*base.TaskMessage
+		desc        string
+		retry       map[string][]base.Z
+		qname       string
+		want        int64
+		wantPending map[string][]*base.TaskMessage
+		wantRetry   map[string][]*base.TaskMessage
 	}{
 		{
 			desc: "with tasks in retry queue",
@@ -1425,7 +1425,7 @@ func TestEnqueueAllRetryTasks(t *testing.T) {
 			},
 			qname: "default",
 			want:  3,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1, t2, t3},
 			},
 			wantRetry: map[string][]*base.TaskMessage{
@@ -1439,7 +1439,7 @@ func TestEnqueueAllRetryTasks(t *testing.T) {
 			},
 			qname: "default",
 			want:  0,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			wantRetry: map[string][]*base.TaskMessage{
@@ -1461,7 +1461,7 @@ func TestEnqueueAllRetryTasks(t *testing.T) {
 			},
 			qname: "custom",
 			want:  2,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 				"custom":  {t4, t5},
 			},
@@ -1488,9 +1488,9 @@ func TestEnqueueAllRetryTasks(t *testing.T) {
 				tc.desc, tc.qname, got, err, tc.want)
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("%s; mismatch found in %q; (-want, +got)\n%s", tc.desc, base.QueueKey(qname), diff)
 			}
 		}
@@ -1512,12 +1512,12 @@ func TestEnqueueAllDeadTasks(t *testing.T) {
 	t5 := h.NewTaskMessageWithQueue("minor_notification", nil, "custom")
 
 	tests := []struct {
-		desc         string
-		dead         map[string][]base.Z
-		qname        string
-		want         int64
-		wantEnqueued map[string][]*base.TaskMessage
-		wantDead     map[string][]*base.TaskMessage
+		desc        string
+		dead        map[string][]base.Z
+		qname       string
+		want        int64
+		wantPending map[string][]*base.TaskMessage
+		wantDead    map[string][]*base.TaskMessage
 	}{
 		{
 			desc: "with tasks in dead queue",
@@ -1530,7 +1530,7 @@ func TestEnqueueAllDeadTasks(t *testing.T) {
 			},
 			qname: "default",
 			want:  3,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1, t2, t3},
 			},
 			wantDead: map[string][]*base.TaskMessage{
@@ -1544,7 +1544,7 @@ func TestEnqueueAllDeadTasks(t *testing.T) {
 			},
 			qname: "default",
 			want:  0,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			wantDead: map[string][]*base.TaskMessage{
@@ -1566,7 +1566,7 @@ func TestEnqueueAllDeadTasks(t *testing.T) {
 			},
 			qname: "custom",
 			want:  2,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 				"custom":  {t4, t5},
 			},
@@ -1593,9 +1593,9 @@ func TestEnqueueAllDeadTasks(t *testing.T) {
 				tc.desc, tc.qname, got, err, tc.want)
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("%s; mismatch found in %q; (-want, +got)\n%s", tc.desc, base.QueueKey(qname), diff)
 			}
 		}
@@ -2608,7 +2608,7 @@ func TestRemoveQueue(t *testing.T) {
 	m4 := h.NewTaskMessageWithQueue("task4", nil, "custom")
 
 	tests := []struct {
-		enqueued   map[string][]*base.TaskMessage
+		pending    map[string][]*base.TaskMessage
 		inProgress map[string][]*base.TaskMessage
 		scheduled  map[string][]base.Z
 		retry      map[string][]base.Z
@@ -2617,7 +2617,7 @@ func TestRemoveQueue(t *testing.T) {
 		force      bool
 	}{
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {m1, m2},
 				"custom":  {},
 			},
@@ -2641,7 +2641,7 @@ func TestRemoveQueue(t *testing.T) {
 			force: false,
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {m1, m2},
 				"custom":  {m3},
 			},
@@ -2668,7 +2668,7 @@ func TestRemoveQueue(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r.client)
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 		h.SeedAllInProgressQueues(t, r.client, tc.inProgress)
 		h.SeedAllScheduledQueues(t, r.client, tc.scheduled)
 		h.SeedAllRetryQueues(t, r.client, tc.retry)
@@ -2709,7 +2709,7 @@ func TestRemoveQueueError(t *testing.T) {
 
 	tests := []struct {
 		desc       string
-		enqueued   map[string][]*base.TaskMessage
+		pending    map[string][]*base.TaskMessage
 		inProgress map[string][]*base.TaskMessage
 		scheduled  map[string][]base.Z
 		retry      map[string][]base.Z
@@ -2719,7 +2719,7 @@ func TestRemoveQueueError(t *testing.T) {
 	}{
 		{
 			desc: "removing non-existent queue",
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {m1, m2},
 				"custom":  {m3},
 			},
@@ -2744,7 +2744,7 @@ func TestRemoveQueueError(t *testing.T) {
 		},
 		{
 			desc: "removing non-empty queue",
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {m1, m2},
 				"custom":  {m3},
 			},
@@ -2769,7 +2769,7 @@ func TestRemoveQueueError(t *testing.T) {
 		},
 		{
 			desc: "force removing queue with tasks in-progress",
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {m1, m2},
 				"custom":  {m3},
 			},
@@ -2797,7 +2797,7 @@ func TestRemoveQueueError(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r.client)
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 		h.SeedAllInProgressQueues(t, r.client, tc.inProgress)
 		h.SeedAllScheduledQueues(t, r.client, tc.scheduled)
 		h.SeedAllRetryQueues(t, r.client, tc.retry)
@@ -2810,9 +2810,9 @@ func TestRemoveQueueError(t *testing.T) {
 		}
 
 		// Make sure that nothing changed
-		for qname, want := range tc.enqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.pending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("%s;mismatch found in %q; (-want,+got):\n%s", tc.desc, base.QueueKey(qname), diff)
 			}
 		}

internal/rdb/rdb_test.go

@@ -80,12 +80,12 @@ func TestEnqueue(t *testing.T) {
 			t.Errorf("(*RDB).Enqueue(msg) = %v, want nil", err)
 		}
 
-		gotEnqueued := h.GetEnqueuedMessages(t, r.client, tc.msg.Queue)
-		if len(gotEnqueued) != 1 {
-			t.Errorf("%q has length %d, want 1", base.QueueKey(tc.msg.Queue), len(gotEnqueued))
+		gotPending := h.GetPendingMessages(t, r.client, tc.msg.Queue)
+		if len(gotPending) != 1 {
+			t.Errorf("%q has length %d, want 1", base.QueueKey(tc.msg.Queue), len(gotPending))
 			continue
 		}
-		if diff := cmp.Diff(tc.msg, gotEnqueued[0]); diff != "" {
+		if diff := cmp.Diff(tc.msg, gotPending[0]); diff != "" {
 			t.Errorf("persisted data differed from the original input (-want, +got)\n%s", diff)
 		}
 		if !r.client.SIsMember(base.AllQueues, tc.msg.Queue).Val() {
@@ -167,24 +167,24 @@ func TestDequeue(t *testing.T) {
 	t3Deadline := now.Unix() + t3.Timeout // use whichever is earliest
 
 	tests := []struct {
-		enqueued       map[string][]*base.TaskMessage
+		pending        map[string][]*base.TaskMessage
 		args           []string // list of queues to query
 		wantMsg        *base.TaskMessage
 		wantDeadline   time.Time
 		err            error
-		wantEnqueued   map[string][]*base.TaskMessage
+		wantPending    map[string][]*base.TaskMessage
 		wantInProgress map[string][]*base.TaskMessage
 		wantDeadlines  map[string][]base.Z
 	}{
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
 			args:         []string{"default"},
 			wantMsg:      t1,
 			wantDeadline: time.Unix(t1Deadline, 0),
 			err:          nil,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			wantInProgress: map[string][]*base.TaskMessage{
@@ -195,14 +195,14 @@ func TestDequeue(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			args:         []string{"default"},
 			wantMsg:      nil,
 			wantDeadline: time.Time{},
 			err:          ErrNoProcessableTask,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			wantInProgress: map[string][]*base.TaskMessage{
@@ -213,7 +213,7 @@ func TestDequeue(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {t2},
 				"low":      {t3},
@@ -222,7 +222,7 @@ func TestDequeue(t *testing.T) {
 			wantMsg:      t2,
 			wantDeadline: time.Unix(t2Deadline, 0),
 			err:          nil,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {},
 				"low":      {t3},
@@ -239,7 +239,7 @@ func TestDequeue(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {t3},
 				"critical": {},
 				"low":      {t2, t1},
@@ -248,7 +248,7 @@ func TestDequeue(t *testing.T) {
 			wantMsg:      t3,
 			wantDeadline: time.Unix(t3Deadline, 0),
 			err:          nil,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {},
 				"critical": {},
 				"low":      {t2, t1},
@@ -265,7 +265,7 @@ func TestDequeue(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {},
 				"critical": {},
 				"low":      {},
@@ -274,7 +274,7 @@ func TestDequeue(t *testing.T) {
 			wantMsg:      nil,
 			wantDeadline: time.Time{},
 			err:          ErrNoProcessableTask,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {},
 				"critical": {},
 				"low":      {},
@@ -294,7 +294,7 @@ func TestDequeue(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r.client) // clean up db before each test case
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 
 		gotMsg, gotDeadline, err := r.Dequeue(tc.args...)
 		if err != tc.err {
@@ -313,9 +313,9 @@ func TestDequeue(t *testing.T) {
 			continue
 		}
 
-		for queue, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, queue)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for queue, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, queue)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q: (-want,+got):\n%s", base.QueueKey(queue), diff)
 			}
 		}
@@ -355,23 +355,23 @@ func TestDequeueIgnoresPausedQueues(t *testing.T) {
 
 	tests := []struct {
 		paused         []string // list of paused queues
-		enqueued       map[string][]*base.TaskMessage
+		pending        map[string][]*base.TaskMessage
 		args           []string // list of queues to query
 		wantMsg        *base.TaskMessage
 		err            error
-		wantEnqueued   map[string][]*base.TaskMessage
+		wantPending    map[string][]*base.TaskMessage
 		wantInProgress map[string][]*base.TaskMessage
 	}{
 		{
 			paused: []string{"default"},
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {t2},
 			},
 			args:    []string{"default", "critical"},
 			wantMsg: t2,
 			err:     nil,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {},
 			},
@@ -382,13 +382,13 @@ func TestDequeueIgnoresPausedQueues(t *testing.T) {
 		},
 		{
 			paused: []string{"default"},
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
 			args:    []string{"default"},
 			wantMsg: nil,
 			err:     ErrNoProcessableTask,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
 			wantInProgress: map[string][]*base.TaskMessage{
@@ -397,14 +397,14 @@ func TestDequeueIgnoresPausedQueues(t *testing.T) {
 		},
 		{
 			paused: []string{"critical", "default"},
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {t2},
 			},
 			args:    []string{"default", "critical"},
 			wantMsg: nil,
 			err:     ErrNoProcessableTask,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {t2},
 			},
@@ -422,7 +422,7 @@ func TestDequeueIgnoresPausedQueues(t *testing.T) {
 				t.Fatal(err)
 			}
 		}
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 
 		got, _, err := r.Dequeue(tc.args...)
 		if !cmp.Equal(got, tc.wantMsg) || err != tc.err {
@@ -431,9 +431,9 @@ func TestDequeueIgnoresPausedQueues(t *testing.T) {
 			continue
 		}
 
-		for queue, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, queue)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for queue, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, queue)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q: (-want,+got):\n%s", base.QueueKey(queue), diff)
 			}
 		}
@@ -627,16 +627,16 @@ func TestRequeue(t *testing.T) {
 	t3Deadline := now.Unix() + t3.Timeout
 
 	tests := []struct {
-		enqueued       map[string][]*base.TaskMessage // initial state of queues
+		pending        map[string][]*base.TaskMessage // initial state of queues
 		inProgress     map[string][]*base.TaskMessage // initial state of the in-progress list
 		deadlines      map[string][]base.Z            // initial state of the deadlines set
 		target         *base.TaskMessage              // task to requeue
-		wantEnqueued   map[string][]*base.TaskMessage // final state of queues
+		wantPending    map[string][]*base.TaskMessage // final state of queues
 		wantInProgress map[string][]*base.TaskMessage // final state of the in-progress list
 		wantDeadlines  map[string][]base.Z            // final state of the deadlines set
 	}{
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			inProgress: map[string][]*base.TaskMessage{
@@ -649,7 +649,7 @@ func TestRequeue(t *testing.T) {
 				},
 			},
 			target: t1,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
 			wantInProgress: map[string][]*base.TaskMessage{
@@ -662,7 +662,7 @@ func TestRequeue(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default": {t1},
 			},
 			inProgress: map[string][]*base.TaskMessage{
@@ -674,7 +674,7 @@ func TestRequeue(t *testing.T) {
 				},
 			},
 			target: t2,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1, t2},
 			},
 			wantInProgress: map[string][]*base.TaskMessage{
@@ -685,7 +685,7 @@ func TestRequeue(t *testing.T) {
 			},
 		},
 		{
-			enqueued: map[string][]*base.TaskMessage{
+			pending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {},
 			},
@@ -698,7 +698,7 @@ func TestRequeue(t *testing.T) {
 				"critical": {{Message: t3, Score: t3Deadline}},
 			},
 			target: t3,
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {t3},
 			},
@@ -715,7 +715,7 @@ func TestRequeue(t *testing.T) {
 
 	for _, tc := range tests {
 		h.FlushDB(t, r.client) // clean up db before each test case
-		h.SeedAllEnqueuedQueues(t, r.client, tc.enqueued)
+		h.SeedAllPendingQueues(t, r.client, tc.pending)
 		h.SeedAllInProgressQueues(t, r.client, tc.inProgress)
 		h.SeedAllDeadlines(t, r.client, tc.deadlines)
 
@@ -725,9 +725,9 @@ func TestRequeue(t *testing.T) {
 			continue
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q; (-want, +got)\n%s", base.QueueKey(qname), diff)
 			}
 		}
@@ -1215,7 +1215,7 @@ func TestCheckAndEnqueue(t *testing.T) {
 		scheduled     map[string][]base.Z
 		retry         map[string][]base.Z
 		qnames        []string
-		wantEnqueued  map[string][]*base.TaskMessage
+		wantPending   map[string][]*base.TaskMessage
 		wantScheduled map[string][]*base.TaskMessage
 		wantRetry     map[string][]*base.TaskMessage
 	}{
@@ -1230,7 +1230,7 @@ func TestCheckAndEnqueue(t *testing.T) {
 				"default": {{Message: t3, Score: secondAgo.Unix()}},
 			},
 			qnames: []string{"default"},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t1, t2, t3},
 			},
 			wantScheduled: map[string][]*base.TaskMessage{
@@ -1251,7 +1251,7 @@ func TestCheckAndEnqueue(t *testing.T) {
 				"default": {{Message: t3, Score: secondAgo.Unix()}},
 			},
 			qnames: []string{"default"},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {t2, t3},
 			},
 			wantScheduled: map[string][]*base.TaskMessage{
@@ -1272,7 +1272,7 @@ func TestCheckAndEnqueue(t *testing.T) {
 				"default": {{Message: t3, Score: hourFromNow.Unix()}},
 			},
 			qnames: []string{"default"},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default": {},
 			},
 			wantScheduled: map[string][]*base.TaskMessage{
@@ -1294,7 +1294,7 @@ func TestCheckAndEnqueue(t *testing.T) {
 				"low":      {{Message: t5, Score: secondAgo.Unix()}},
 			},
 			qnames: []string{"default", "critical", "low"},
-			wantEnqueued: map[string][]*base.TaskMessage{
+			wantPending: map[string][]*base.TaskMessage{
 				"default":  {t1},
 				"critical": {t4},
 				"low":      {t5},
@@ -1323,9 +1323,9 @@ func TestCheckAndEnqueue(t *testing.T) {
 			continue
 		}
 
-		for qname, want := range tc.wantEnqueued {
-			gotEnqueued := h.GetEnqueuedMessages(t, r.client, qname)
-			if diff := cmp.Diff(want, gotEnqueued, h.SortMsgOpt); diff != "" {
+		for qname, want := range tc.wantPending {
+			gotPending := h.GetPendingMessages(t, r.client, qname)
+			if diff := cmp.Diff(want, gotPending, h.SortMsgOpt); diff != "" {
 				t.Errorf("mismatch found in %q; (-want, +got)\n%s", base.QueueKey(qname), diff)
 			}
 		}