test(e2e): cover gateway List API

Summary:

Adds full-stack coverage for the gateway List RPC, including a dedicated e2e queue and assertions for filtering, pagination, and terminal summaries.

Test Plan:

✅ `make fmt && make build && make test && make check-mocks && make e2e-test`

Author: albertywu

service/submitqueue/gateway/server/queues.yaml

@@ -6,6 +6,7 @@
 queues:
   - name: test-queue
   - name: e2e-test-queue
+  - name: e2e-list-queue
   - name: e2e-cancel-queue
   # Routes to an analyzer that always errors (conflictfake.FailAlways) so e2e can
   # exercise the conflict-analysis error path. See newQueueRegistry in the

service/submitqueue/orchestrator/server/main.go

@@ -941,6 +941,7 @@ func newQueueRegistry(logger *zap.Logger, scope tally.Scope, resolver changeset.
 		byQueue: map[string]queueExtensions{
 			"test-queue":               testQueue,
 			"e2e-test-queue":           e2eQueue,
+			"e2e-list-queue":           e2eQueue,
 			"e2e-conflict-error-queue": conflictErrQueue,
 			"file-overlap-queue":       fileOverlapQueue,
 		},

test/e2e/submitqueue/harness_test.go

@@ -51,6 +51,57 @@ func (s *E2EIntegrationSuite) land(queue string, uris ...string) string {
 	return resp.Sqid
 }
 
+// list calls the gateway List RPC and fails the test on unexpected errors.
+func (s *E2EIntegrationSuite) list(req *gatewaypb.ListRequest) *gatewaypb.ListResponse {
+	t := s.T()
+	resp, err := s.gatewayClient.List(s.ctx, req)
+	require.NoError(t, err, "List failed for queue %s", req.Queue)
+	return resp
+}
+
+// awaitListContains polls List until all expected sqids are visible in one
+// response page. The gateway updates request summaries synchronously for Land
+// and asynchronously from the log topic for later statuses, so callers use the
+// same bounded polling style as Status.
+func (s *E2EIntegrationSuite) awaitListContains(req *gatewaypb.ListRequest, want ...string) *gatewaypb.ListResponse {
+	t := s.T()
+	var resp *gatewaypb.ListResponse
+	require.Eventually(t, func() bool {
+		var err error
+		resp, err = s.gatewayClient.List(s.ctx, req)
+		if err != nil {
+			s.log.Logf("List(%s) not ready yet: %v", req.Queue, err)
+			return false
+		}
+		got := summarySQIDs(resp.Requests)
+		s.log.Logf("List(%s) = %v (want %v)", req.Queue, got, want)
+		return containsAll(got, want)
+	}, persistTimeout, persistPollInterval,
+		"List(%s) should contain sqids %v", req.Queue, want)
+	return resp
+}
+
+func summarySQIDs(summaries []*gatewaypb.RequestSummary) []string {
+	out := make([]string, len(summaries))
+	for i, summary := range summaries {
+		out[i] = summary.Sqid
+	}
+	return out
+}
+
+func containsAll(got []string, want []string) bool {
+	seen := make(map[string]struct{}, len(got))
+	for _, sqid := range got {
+		seen[sqid] = struct{}{}
+	}
+	for _, sqid := range want {
+		if _, ok := seen[sqid]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
 // currentStatus reads the request's current customer-facing status via the
 // Status RPC. A transport error is returned so callers can keep polling.
 func (s *E2EIntegrationSuite) currentStatus(sqid string) (entity.RequestStatus, error) {

test/e2e/submitqueue/suite_test.go

@@ -218,6 +218,89 @@ func (s *E2EIntegrationSuite) TestLand_HappyPath_ReachesLanded() {
 		"operating store should show request %s in terminal state landed", sqid)
 }
 
+// TestList_ReturnsFilteredPagedSummaries verifies the customer-facing List RPC
+// against the full stack. Land writes the initial summary through the gateway,
+// later status updates arrive through the request-log topic, and List reads the
+// gateway-owned summary read model through the public RPC surface.
+func (s *E2EIntegrationSuite) TestList_ReturnsFilteredPagedSummaries() {
+	t := s.T()
+
+	startTimeMs := time.Now().Add(-time.Second).UnixMilli()
+	firstURI := "github://uber/e2e-list/pull/101/abcdef0123456789abcdef0123456789abcdef01"
+	secondURI := "github://uber/e2e-list/pull/102/abcdef0123456789abcdef0123456789abcdef02"
+	otherURI := "github://uber/e2e-list-other/pull/201/abcdef0123456789abcdef0123456789abcdef03"
+
+	first := s.land("e2e-list-queue", firstURI)
+	second := s.land("e2e-list-queue", secondURI)
+	otherQueue := s.land("e2e-cancel-queue", otherURI)
+	endTimeMs := time.Now().Add(time.Minute).UnixMilli()
+
+	resp := s.awaitListContains(&gatewaypb.ListRequest{
+		Queue:       "e2e-list-queue",
+		StartTimeMs: startTimeMs,
+		EndTimeMs:   endTimeMs,
+		PageSize:    10,
+	}, first, second)
+
+	assert.NotContains(t, summarySQIDs(resp.Requests), otherQueue,
+		"List should not return requests from a different queue")
+
+	bySQID := make(map[string]*gatewaypb.RequestSummary, len(resp.Requests))
+	for _, summary := range resp.Requests {
+		bySQID[summary.Sqid] = summary
+	}
+
+	firstSummary := bySQID[first]
+	require.NotNil(t, firstSummary, "List response should include %s", first)
+	assert.Equal(t, "e2e-list-queue", firstSummary.Queue)
+	assert.Equal(t, []string{firstURI}, firstSummary.ChangeUris)
+	assert.NotEmpty(t, firstSummary.Status)
+	assert.GreaterOrEqual(t, firstSummary.StartedAtMs, startTimeMs)
+	assert.Less(t, firstSummary.StartedAtMs, endTimeMs)
+	assert.GreaterOrEqual(t, firstSummary.UpdatedAtMs, firstSummary.StartedAtMs)
+
+	s.awaitStatus(first, entity.RequestStatusLanded)
+	s.awaitStatus(second, entity.RequestStatusLanded)
+
+	landedResp := s.awaitListContains(&gatewaypb.ListRequest{
+		Queue:       "e2e-list-queue",
+		StartTimeMs: startTimeMs,
+		EndTimeMs:   endTimeMs,
+		Statuses:    []string{string(entity.RequestStatusLanded)},
+		PageSize:    10,
+	}, first, second)
+	for _, summary := range landedResp.Requests {
+		if summary.Sqid != first && summary.Sqid != second {
+			continue
+		}
+		assert.Equal(t, string(entity.RequestStatusLanded), summary.Status)
+		assert.True(t, summary.Terminal, "landed summary %s should be terminal", summary.Sqid)
+		assert.Greater(t, summary.CompletedAtMs, int64(0), "landed summary %s should have completion time", summary.Sqid)
+	}
+
+	page1 := s.list(&gatewaypb.ListRequest{
+		Queue:       "e2e-list-queue",
+		StartTimeMs: startTimeMs,
+		EndTimeMs:   endTimeMs,
+		PageSize:    1,
+		Sort:        gatewaypb.ListSort_ADMITTED_DESC,
+	})
+	require.Len(t, page1.Requests, 1)
+	require.NotEmpty(t, page1.NextPageToken)
+
+	page2 := s.list(&gatewaypb.ListRequest{
+		Queue:       "e2e-list-queue",
+		StartTimeMs: startTimeMs,
+		EndTimeMs:   endTimeMs,
+		PageSize:    1,
+		PageToken:   page1.NextPageToken,
+		Sort:        gatewaypb.ListSort_ADMITTED_DESC,
+	})
+	require.Len(t, page2.Requests, 1)
+	assert.NotEqual(t, page1.Requests[0].Sqid, page2.Requests[0].Sqid)
+	assert.ElementsMatch(t, []string{first, second}, []string{page1.Requests[0].Sqid, page2.Requests[0].Sqid})
+}
+
 // TestCancelRequest_InvalidSqid verifies the gateway rejects an empty sqid
 // synchronously before publishing anything to the cancel queue.
 func (s *E2EIntegrationSuite) TestCancelRequest_InvalidSqid() {