testing/e2e: add group pagination test (#4234)

testing/internal/e2e/boundary/group.go

@@ -8,11 +8,24 @@ import (
 	"encoding/json"
 	"testing"
 
+	"github.com/hashicorp/boundary/api"
 	"github.com/hashicorp/boundary/api/groups"
 	"github.com/hashicorp/boundary/testing/internal/e2e"
 	"github.com/stretchr/testify/require"
 )
 
+// CreateNewGroupApi uses the API to create a new group.
+// Returns the id of the new group.
+func CreateNewGroupApi(t testing.TB, ctx context.Context, client *api.Client, scopeId string) string {
+	gClient := groups.NewClient(client)
+	newGroup, err := gClient.Create(ctx, scopeId)
+	require.NoError(t, err)
+
+	newGroupId := newGroup.Item.Id
+	t.Logf("Created Group: %s", newGroupId)
+	return newGroupId
+}
+
 // CreateNewGroupCli uses the cli to create a new group.
 // Returns the id of the new group.
 func CreateNewGroupCli(t testing.TB, ctx context.Context, scopeId string) string {

testing/internal/e2e/tests/base/paginate_group_test.go

@@ -0,0 +1,188 @@
+// Copyright (c) HashiCorp, Inc.
+// SPDX-License-Identifier: BUSL-1.1
+
+package base_test
+
+import (
+	"context"
+	"encoding/json"
+	"slices"
+	"testing"
+
+	"github.com/google/go-cmp/cmp"
+	"github.com/google/go-cmp/cmp/cmpopts"
+	"github.com/hashicorp/boundary/api/groups"
+	"github.com/hashicorp/boundary/api/scopes"
+	"github.com/hashicorp/boundary/testing/internal/e2e"
+	"github.com/hashicorp/boundary/testing/internal/e2e/boundary"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// TestCliPaginateGroups asserts that the CLI automatically paginates to retrieve
+// all groups in a single invocation.
+func TestCliPaginateGroups(t *testing.T) {
+	e2e.MaybeSkipTest(t)
+	c, err := loadTestConfig()
+	require.NoError(t, err)
+
+	ctx := context.Background()
+	boundary.AuthenticateAdminCli(t, ctx)
+	newOrgId := boundary.CreateNewOrgCli(t, ctx)
+	t.Cleanup(func() {
+		ctx := context.Background()
+		boundary.AuthenticateAdminCli(t, ctx)
+		output := e2e.RunCommand(ctx, "boundary", e2e.WithArgs("scopes", "delete", "-id", newOrgId))
+		require.NoError(t, output.Err, string(output.Stderr))
+	})
+
+	// Create enough groups to overflow a single page.
+	client, err := boundary.NewApiClient()
+	require.NoError(t, err)
+	var groupIds []string
+	for i := 0; i < c.MaxPageSize+1; i++ {
+		groupIds = append(groupIds, boundary.CreateNewGroupApi(t, ctx, client, newOrgId))
+	}
+
+	// List groups
+	output := e2e.RunCommand(ctx, "boundary",
+		e2e.WithArgs(
+			"groups", "list",
+			"-scope-id", newOrgId,
+			"-format=json",
+		),
+	)
+	require.NoError(t, output.Err, string(output.Stderr))
+
+	var initialGroups groups.GroupListResult
+	err = json.Unmarshal(output.Stdout, &initialGroups)
+	require.NoError(t, err)
+
+	var returnedIds []string
+	for _, group := range initialGroups.Items {
+		returnedIds = append(returnedIds, group.Id)
+	}
+
+	require.Len(t, initialGroups.Items, c.MaxPageSize+1)
+	assert.Empty(t, cmp.Diff(returnedIds, groupIds, cmpopts.SortSlices(func(i, j string) bool { return i < j })))
+	assert.Empty(t, initialGroups.ResponseType)
+	assert.Empty(t, initialGroups.RemovedIds)
+	assert.Empty(t, initialGroups.ListToken)
+
+	// Create a new group and destroy one of the other groups
+	newGroupId := boundary.CreateNewGroupApi(t, ctx, client, newOrgId)
+	output = e2e.RunCommand(ctx, "boundary",
+		e2e.WithArgs(
+			"groups", "delete",
+			"-id", initialGroups.Items[0].Id,
+		),
+	)
+	require.NoError(t, output.Err, string(output.Stderr))
+
+	// List again, should have the new group but not the deleted group
+	output = e2e.RunCommand(ctx, "boundary",
+		e2e.WithArgs(
+			"groups", "list",
+			"-scope-id", newOrgId,
+			"-format=json",
+		),
+	)
+	require.NoError(t, output.Err, string(output.Stderr))
+
+	var newGroups groups.GroupListResult
+	err = json.Unmarshal(output.Stdout, &newGroups)
+	require.NoError(t, err)
+
+	require.Len(t, newGroups.Items, c.MaxPageSize+1)
+	// The first item should be the most recently created, which
+	// should be our new group
+	firstItem := newGroups.Items[0]
+	assert.Equal(t, newGroupId, firstItem.Id)
+	assert.Empty(t, newGroups.ResponseType)
+	assert.Empty(t, newGroups.RemovedIds)
+	assert.Empty(t, newGroups.ListToken)
+	// Ensure the deleted group isn't returned
+	for _, group := range newGroups.Items {
+		assert.NotEqual(t, group.Id, initialGroups.Items[0].Id)
+	}
+}
+
+// TestApiPaginateGroups asserts that the API automatically paginates to retrieve
+// all groups in a single invocation.
+func TestApiPaginateGroups(t *testing.T) {
+	e2e.MaybeSkipTest(t)
+	c, err := loadTestConfig()
+	require.NoError(t, err)
+
+	client, err := boundary.NewApiClient()
+	require.NoError(t, err)
+	ctx := context.Background()
+	sClient := scopes.NewClient(client)
+	uClient := groups.NewClient(client)
+	newOrgId := boundary.CreateNewOrgApi(t, ctx, client)
+	t.Cleanup(func() {
+		ctx := context.Background()
+		_, err := sClient.Delete(ctx, newOrgId)
+		require.NoError(t, err)
+	})
+
+	var groupIds []string
+	for i := 0; i < c.MaxPageSize+1; i++ {
+		groupIds = append(groupIds, boundary.CreateNewGroupApi(t, ctx, client, newOrgId))
+	}
+
+	// List groups
+	initialGroups, err := uClient.List(ctx, newOrgId)
+	require.NoError(t, err)
+
+	var returnedIds []string
+	// Ignore the two precreated groups, which will appear at the end
+	for _, group := range initialGroups.Items {
+		returnedIds = append(returnedIds, group.Id)
+	}
+
+	require.Len(t, initialGroups.Items, c.MaxPageSize+1)
+	assert.Empty(t, cmp.Diff(returnedIds, groupIds, cmpopts.SortSlices(func(i, j string) bool { return i < j })))
+	assert.Equal(t, "complete", initialGroups.ResponseType)
+	assert.Empty(t, initialGroups.RemovedIds)
+	assert.NotEmpty(t, initialGroups.ListToken)
+	mapItems, ok := initialGroups.GetResponse().Map["items"]
+	require.True(t, ok)
+	mapSliceItems, ok := mapItems.([]any)
+	require.True(t, ok)
+	assert.Len(t, mapSliceItems, c.MaxPageSize+1)
+
+	// Create a new group and destroy one of the other groups
+	newGroupId := boundary.CreateNewGroupApi(t, ctx, client, newOrgId)
+	_, err = uClient.Delete(ctx, initialGroups.Items[0].Id)
+	require.NoError(t, err)
+
+	// List again, should have the new and deleted group
+	newGroups, err := uClient.List(ctx, newOrgId, groups.WithListToken(initialGroups.ListToken))
+	require.NoError(t, err)
+
+	// Note that this will likely contain all the groups,
+	// since they were created very shortly before the listing,
+	// and we add a 30 second buffer to the lower bound of update
+	// times when listing.
+	require.GreaterOrEqual(t, len(newGroups.Items), 1)
+	// The first item should be the most recently created, which
+	// should be our new group
+	firstItem := newGroups.Items[0]
+	assert.Equal(t, newGroupId, firstItem.Id)
+	assert.Equal(t, "complete", newGroups.ResponseType)
+	// Note that the removed IDs may contain entries from other tests,
+	// so just check that there is at least 1 entry and that our entry
+	// is somewhere in the list.
+	require.GreaterOrEqual(t, len(newGroups.RemovedIds), 1)
+	assert.True(t, slices.ContainsFunc(newGroups.RemovedIds, func(groupId string) bool {
+		return groupId == initialGroups.Items[0].Id
+	}))
+	assert.NotEmpty(t, newGroups.ListToken)
+	// Check that the response map contains all entries
+	mapItems, ok = newGroups.GetResponse().Map["items"]
+	require.True(t, ok)
+	mapSliceItems, ok = mapItems.([]any)
+	require.True(t, ok)
+	assert.GreaterOrEqual(t, len(mapSliceItems), 1)
+}