Return arrays from listTesters() and listGroups().

src/appdistribution/client.spec.ts

@@ -100,7 +100,7 @@ describe("distribution", () => {
       expect(nock.isDone()).to.be.true;
     });
 
-    it("should resolve with ListTestersResponse when request succeeds - no filter", async () => {
+    it("should resolve with array of testers when request succeeds - no filter", async () => {
       const testerListing = [
         {
           name: "tester_1",
@@ -119,22 +119,20 @@ describe("distribution", () => {
       nock(appDistributionOrigin()).get(`/v1/${projectName}/testers`).reply(200, {
         testers: testerListing,
       });
-      await expect(appDistributionClient.listTesters(projectName)).to.eventually.deep.eq({
-        testers: [
-          {
-            name: "tester_1",
-            displayName: "Tester 1",
-            groups: [],
-            lastActivityTime: new Date("2024-08-27T02:37:19.539865Z"),
-          },
-          {
-            name: "tester_2",
-            displayName: "Tester 2",
-            groups: [`${projectName}/groups/beta-team`, `${projectName}/groups/alpha-team`],
-            lastActivityTime: new Date("2024-08-26T02:37:19Z"),
-          },
-        ],
-      });
+      await expect(appDistributionClient.listTesters(projectName)).to.eventually.deep.eq([
+        {
+          name: "tester_1",
+          displayName: "Tester 1",
+          groups: [],
+          lastActivityTime: new Date("2024-08-27T02:37:19.539865Z"),
+        },
+        {
+          name: "tester_2",
+          displayName: "Tester 2",
+          groups: [`${projectName}/groups/beta-team`, `${projectName}/groups/alpha-team`],
+          lastActivityTime: new Date("2024-08-26T02:37:19Z"),
+        },
+      ]);
       expect(nock.isDone()).to.be.true;
     });
 
@@ -157,25 +155,21 @@ describe("distribution", () => {
         });
       await expect(
         appDistributionClient.listTesters(projectName, "beta-team"),
-      ).to.eventually.deep.eq({
-        testers: [
-          {
-            name: "tester_2",
-            displayName: "Tester 2",
-            groups: [`${projectName}/groups/beta-team`],
-            lastActivityTime: new Date("2024-08-26T02:37:19Z"),
-          },
-        ],
-      });
+      ).to.eventually.deep.eq([
+        {
+          name: "tester_2",
+          displayName: "Tester 2",
+          groups: [`${projectName}/groups/beta-team`],
+          lastActivityTime: new Date("2024-08-26T02:37:19Z"),
+        },
+      ]);
       expect(nock.isDone()).to.be.true;
     });
 
     it("should gracefully handle no testers", async () => {
       nock(appDistributionOrigin()).get(`/v1/${projectName}/testers`).reply(200, {});
 
-      await expect(appDistributionClient.listTesters(projectName)).to.eventually.deep.eq({
-        testers: [],
-      });
+      await expect(appDistributionClient.listTesters(projectName)).to.eventually.deep.eq([]);
       expect(nock.isDone()).to.be.true;
     });
   });
@@ -403,8 +397,8 @@ describe("distribution", () => {
       expect(nock.isDone()).to.be.true;
     });
 
-    it("should resolve with ListGroupsResponse when request succeeds", async () => {
-      const groupListing: Group[] = [
+    it("should resolve with array of groups when request succeeds", async () => {
+      const groups: Group[] = [
         {
           name: "group_1",
           displayName: "Group 1",
@@ -419,11 +413,9 @@ describe("distribution", () => {
       ];
 
       nock(appDistributionOrigin()).get(`/v1/${projectName}/groups`).reply(200, {
-        groups: groupListing,
-      });
-      await expect(appDistributionClient.listGroups(projectName)).to.eventually.deep.eq({
-        groups: groupListing,
+        groups: groups,
       });
+      await expect(appDistributionClient.listGroups(projectName)).to.eventually.deep.eq(groups);
       expect(nock.isDone()).to.be.true;
     });
   });

src/appdistribution/client.ts

@@ -17,6 +17,7 @@
   mapDeviceToExecution,
   ReleaseTest,
   TestDevice,
+  Tester,
   UploadReleaseResponse,
 } from "./types";
 
@@ -110,15 +111,15 @@
 
     try {
       await this.appDistroV1Client.post(`/${releaseName}:distribute`, data);
     } catch (err: any) {
       let errorMessage = err.message;
       const errorStatus = err?.context?.body?.error?.status;
       if (errorStatus === "FAILED_PRECONDITION") {
         errorMessage = "invalid testers";
       } else if (errorStatus === "INVALID_ARGUMENT") {
         errorMessage = "invalid groups";
       }
       throw new FirebaseError(`failed to distribute to testers/groups: ${errorMessage}`, {
         exit: 1,
       });
     }
@@ -126,17 +127,12 @@
     utils.logSuccess("distributed to testers/groups successfully");
   }
 
-  async listTesters(projectName: string, groupName?: string): Promise<ListTestersResponse> {
-    const listTestersResponse: ListTestersResponse = {
-      testers: [],
-    };
-
+  async listTesters(projectName: string, groupName?: string): Promise<Tester[]> {
+    const testers: Tester[] = [];
     const client = this.appDistroV1Client;
-
-    let pageToken: string | undefined;
-
     const filter = groupName ? `groups=${projectName}/groups/${groupName}` : null;
 
+    let pageToken: string | undefined;
     do {
       const queryParams: Record<string, string> = pageToken ? { pageToken } : {};
       if (filter != null) {
@@ -149,11 +145,11 @@
           queryParams,
         });
       } catch (err) {
         throw new FirebaseError(`Client request failed to list testers ${err}`);
       }
 
       for (const t of apiResponse.body.testers ?? []) {
-        listTestersResponse.testers.push({
+        testers.push({
           name: t.name,
           displayName: t.displayName,
           groups: t.groups,
@@ -163,7 +159,7 @@
 
       pageToken = apiResponse.body.nextPageToken;
     } while (pageToken);
-    return listTestersResponse;
+    return testers;
   }
 
   async addTesters(projectName: string, emails: string[]): Promise<void> {
@@ -197,28 +193,24 @@
     return apiResponse.body;
   }
 
-  async listGroups(projectName: string): Promise<ListGroupsResponse> {
-    const listGroupsResponse: ListGroupsResponse = {
-      groups: [],
-    };
-
+  async listGroups(projectName: string): Promise<Group[]> {
+    const groups: Group[] = [];
     const client = this.appDistroV1Client;
 
     let pageToken: string | undefined;
-
     do {
       const queryParams: Record<string, string> = pageToken ? { pageToken } : {};
       try {
         const apiResponse = await client.get<ListGroupsResponse>(`${projectName}/groups`, {
           queryParams,
         });
-        listGroupsResponse.groups.push(...(apiResponse.body.groups ?? []));
+        groups.push(...(apiResponse.body.groups ?? []));
         pageToken = apiResponse.body.nextPageToken;
       } catch (err) {
         throw new FirebaseError(`Client failed to list groups ${err}`);
       }
     } while (pageToken);
-    return listGroupsResponse;
+    return groups;
   }
 
   async createGroup(projectName: string, displayName: string, alias?: string): Promise<Group> {

src/commands/appdistribution-groups-list.ts

@@ -17,22 +17,21 @@
   .action(async (options?: Options): Promise<ListGroupsResponse> => {
     const projectName = await getProjectName(options);
     const appDistroClient = new AppDistributionClient();
-    let groupsResponse: ListGroupsResponse;
+    let groups: Group[];
     const spinner = ora("Preparing the list of your App Distribution Groups").start();
     try {
-      groupsResponse = await appDistroClient.listGroups(projectName);
+      groups = await appDistroClient.listGroups(projectName);
     } catch (err: any) {
       spinner.fail();
       throw new FirebaseError("Failed to list groups.", {
         exit: 1,
         original: err,
       });
     }
     spinner.succeed();
-    const groups = groupsResponse.groups ?? [];
     printGroupsTable(groups);
     utils.logSuccess(`Groups listed successfully`);
-    return groupsResponse;
+    return { groups };
   });
 
 /**

src/commands/appdistribution-testers-list.ts

@@ -16,10 +16,10 @@ export const command = new Command("appdistribution:testers:list [group]")
   .action(async (group: string | undefined, options: Options): Promise<ListTestersResponse> => {
     const projectName = await getProjectName(options);
     const appDistroClient = new AppDistributionClient();
-    let testersResponse: ListTestersResponse;
+    let testers: Tester[];
     const spinner = ora("Preparing the list of your App Distribution testers").start();
     try {
-      testersResponse = await appDistroClient.listTesters(projectName, group);
+      testers = await appDistroClient.listTesters(projectName, group);
     } catch (err: any) {
       spinner.fail();
       throw new FirebaseError("Failed to list testers.", {
@@ -28,10 +28,9 @@ export const command = new Command("appdistribution:testers:list [group]")
       });
     }
     spinner.succeed();
-    const testers = testersResponse.testers ?? [];
     printTestersTable(testers);
     utils.logSuccess(`Testers listed successfully`);
-    return testersResponse;
+    return { testers };
   });
 
 /**