Add support for --test-case-ids and --test-case-ids-file to

`appdistribution:distribute` to launch AI Testing Agent.

Author: kaibolay

src/appdistribution/client.ts

@@ -281,6 +281,7 @@ export class AppDistributionClient {
     releaseName: string,
     devices: TestDevice[],
     loginCredential?: LoginCredential,
+    testCaseName?: string,
   ): Promise<ReleaseTest> {
     try {
       const response = await this.appDistroV1AlphaClient.request<ReleaseTest, ReleaseTest>({
@@ -289,6 +290,7 @@ export class AppDistributionClient {
         body: {
           deviceExecutions: devices.map(mapDeviceToExecution),
           loginCredential,
+          testCase: testCaseName,
         },
       });
       return response.body;

src/appdistribution/options-parser-util.spec.ts

@@ -1,5 +1,5 @@
 import { expect } from "chai";
-import { getLoginCredential, getTestDevices } from "./options-parser-util";
+import { getLoginCredential, parseTestDevicesFromStringOrFile } from "./options-parser-util";
 import { FirebaseError } from "../error";
 import * as fs from "fs-extra";
 import { rmSync } from "node:fs";
@@ -21,7 +21,7 @@ describe("options-parser-util", () => {
     it("parses a test device", () => {
       const optionValue = "model=modelname,version=123,orientation=landscape,locale=en_US";
 
-      const result = getTestDevices(optionValue, "");
+      const result = parseTestDevicesFromStringOrFile(optionValue, "");
 
       expect(result).to.deep.equal([
         {
@@ -37,7 +37,7 @@ describe("options-parser-util", () => {
       const optionValue =
         "model=modelname,version=123,orientation=landscape,locale=en_US;model=modelname2,version=456,orientation=portrait,locale=es";
 
-      const result = getTestDevices(optionValue, "");
+      const result = parseTestDevicesFromStringOrFile(optionValue, "");
 
       expect(result).to.deep.equal([
         {
@@ -59,7 +59,7 @@ describe("options-parser-util", () => {
       const optionValue =
         "model=modelname,version=123,orientation=landscape,locale=en_US\nmodel=modelname2,version=456,orientation=portrait,locale=es";
 
-      const result = getTestDevices(optionValue, "");
+      const result = parseTestDevicesFromStringOrFile(optionValue, "");
 
       expect(result).to.deep.equal([
         {
@@ -80,7 +80,7 @@ describe("options-parser-util", () => {
     it("throws an error with correct format when missing a field", () => {
       const optionValue = "model=modelname,version=123,locale=en_US";
 
-      expect(() => getTestDevices(optionValue, "")).to.throw(
+      expect(() => parseTestDevicesFromStringOrFile(optionValue, "")).to.throw(
         FirebaseError,
         "model=<model-id>,version=<os-version-id>,locale=<locale>,orientation=<orientation>",
       );
@@ -90,7 +90,7 @@ describe("options-parser-util", () => {
       const optionValue =
         "model=modelname,version=123,orientation=landscape,locale=en_US,notafield=blah";
 
-      expect(() => getTestDevices(optionValue, "")).to.throw(
+      expect(() => parseTestDevicesFromStringOrFile(optionValue, "")).to.throw(
         FirebaseError,
         "model, version, orientation, locale",
       );

src/appdistribution/options-parser-util.ts

@@ -8,7 +8,7 @@ import { FieldHints, LoginCredential, TestDevice } from "./types";
  * and converts the input into an string[] of testers or groups. Value takes precedent
  * over file.
  */
-export function getTestersOrGroups(value: string, file: string): string[] {
+export function parseCommaSeparatedStringOrFile(value: string, file: string): string[] {
   // If there is no value then the file gets parsed into a string to be split
   if (!value && file) {
     ensureFileExists(file);
@@ -70,7 +70,7 @@ export function getAppName(options: any): string {
  * and converts the input into a string[] of test device strings. Value takes precedent
  * over file.
  */
-export function getTestDevices(value: string, file: string): TestDevice[] {
+export function parseTestDevicesFromStringOrFile(value: string, file: string): TestDevice[] {
   // If there is no value then the file gets parsed into a string to be split
   if (!value && file) {
     ensureFileExists(file);

src/appdistribution/types.ts

@@ -126,4 +126,5 @@ export interface ReleaseTest {
   name?: string;
   deviceExecutions: DeviceExecution[];
   loginCredential?: LoginCredential;
+  testCase?: string;
 }

src/commands/appdistribution-distribute.ts

@@ -9,15 +9,16 @@ import {
   IntegrationState,
   UploadReleaseResult,
   TestDevice,
+  ReleaseTest,
 } from "../appdistribution/types";
 import { FirebaseError, getErrMsg, getErrStatus } from "../error";
 import { Distribution, DistributionFileType } from "../appdistribution/distribution";
 import {
   ensureFileExists,
   getAppName,
   getLoginCredential,
-  getTestDevices,
-  getTestersOrGroups,
+  parseTestDevicesFromStringOrFile,
+  parseCommaSeparatedStringOrFile,
 } from "../appdistribution/options-parser-util";
 
 const TEST_MAX_POLLING_RETRIES = 40;
@@ -35,7 +36,9 @@ function getReleaseNotes(releaseNotes: string, releaseNotesFile: string): string
 }
 
 export const command = new Command("appdistribution:distribute <release-binary-file>")
-  .description("upload a release binary")
+  .description(
+    "upload a release binary, optionally distribute it to testers and/or run automated tests",
+  )
   .option("--app <app_id>", "the app id of your Firebase app")
   .option("--release-notes <string>", "release notes to include")
   .option("--release-notes-file <file>", "path to file with release notes")
@@ -75,14 +78,28 @@ export const command = new Command("appdistribution:distribute <release-binary-f
     "--test-non-blocking",
     "run automated tests without waiting for them to complete. Visit the Firebase console for the test results.",
   )
+  .option("--test-case-ids <string>", "a comma separated list of test case IDs.")
+  .option(
+    "--test-case-ids-file <file>",
+    "path to file with a comma separated list of test case IDs.",
+  )
   .before(requireAuth)
   .action(async (file: string, options: any) => {
     const appName = getAppName(options);
     const distribution = new Distribution(file);
     const releaseNotes = getReleaseNotes(options.releaseNotes, options.releaseNotesFile);
-    const testers = getTestersOrGroups(options.testers, options.testersFile);
-    const groups = getTestersOrGroups(options.groups, options.groupsFile);
-    const testDevices = getTestDevices(options.testDevices, options.testDevicesFile);
+    const testers = parseCommaSeparatedStringOrFile(options.testers, options.testersFile);
+    const groups = parseCommaSeparatedStringOrFile(options.groups, options.groupsFile);
+    const testCases = parseCommaSeparatedStringOrFile(options.testCaseIds, options.testCaseIdsFile);
+    const testDevices = parseTestDevicesFromStringOrFile(
+      options.testDevices,
+      options.testDevicesFile,
+    );
+    if (testCases.length && (options.testUsernameResource || options.testPasswordResource)) {
+      throw new FirebaseError(
+        "Username and password resource names are not supported for the AI testing agent.",
+      );
+    }
     const loginCredential = getLoginCredential({
       username: options.testUsername,
       password: options.testPassword,
@@ -210,56 +227,78 @@ export const command = new Command("appdistribution:distribute <release-binary-f
     await requests.distribute(releaseName, testers, groups);
 
     // Run automated tests
-    if (testDevices?.length) {
-      utils.logBullet("starting automated tests (note: this feature is in beta)");
-      const releaseTest = await requests.createReleaseTest(
-        releaseName,
-        testDevices,
-        loginCredential,
-      );
-      utils.logSuccess(`Release test created successfully`);
+    if (testDevices.length) {
+      utils.logBullet("starting automated test (note: this feature is in beta)");
+      const releaseTestPromises: Promise<ReleaseTest>[] = [];
+      if (!testCases.length) {
+        // fallback to basic automated test
+        releaseTestPromises.push(
+          requests.createReleaseTest(releaseName, testDevices, loginCredential),
+        );
+      } else {
+        for (const testCaseId of testCases) {
+          releaseTestPromises.push(
+            requests.createReleaseTest(
+              releaseName,
+              testDevices,
+              loginCredential,
+              `${appName}/testCases/${testCaseId}`,
+            ),
+          );
+        }
+      }
+      const releaseTests = await Promise.all(releaseTestPromises);
+      utils.logSuccess(`${releaseTests.length} Release test(s) started successfully`);
       if (!options.testNonBlocking) {
-        await awaitTestResults(releaseTest.name!, requests);
+        const releaseTestNames = new Set(releaseTests.map((rt) => rt.name!!));
+        await awaitTestResults(releaseTestNames, requests);
       }
     }
   });
 
 async function awaitTestResults(
-  releaseTestName: string,
+  releaseTestNames: Set<string>,
   requests: AppDistributionClient,
 ): Promise<void> {
   for (let i = 0; i < TEST_MAX_POLLING_RETRIES; i++) {
-    utils.logBullet("the automated tests results are pending");
+    utils.logBullet("the automated test results are pending");
     await delay(TEST_POLLING_INTERVAL_MILLIS);
-    const releaseTest = await requests.getReleaseTest(releaseTestName);
-    if (releaseTest.deviceExecutions.every((e) => e.state === "PASSED")) {
-      utils.logSuccess("automated test(s) passed!");
-      return;
-    }
-    for (const execution of releaseTest.deviceExecutions) {
-      switch (execution.state) {
-        case "PASSED":
-        case "IN_PROGRESS":
+    for (const releaseTestName of releaseTestNames) {
+      const releaseTest = await requests.getReleaseTest(releaseTestName);
+      if (releaseTest.deviceExecutions.every((e) => e.state === "PASSED")) {
+        releaseTestNames.delete(releaseTestName);
+        if (releaseTestNames.size === 0) {
+          utils.logSuccess("automated test(s) passed!");
+          return;
+        } else {
           continue;
-        case "FAILED":
-          throw new FirebaseError(
-            `Automated test failed for ${deviceToString(execution.device)}: ${execution.failedReason}`,
-            { exit: 1 },
-          );
-        case "INCONCLUSIVE":
-          throw new FirebaseError(
-            `Automated test inconclusive for ${deviceToString(execution.device)}: ${execution.inconclusiveReason}`,
-            { exit: 1 },
-          );
-        default:
-          throw new FirebaseError(
-            `Unsupported automated test state for ${deviceToString(execution.device)}: ${execution.state}`,
-            { exit: 1 },
-          );
+        }
+      }
+      for (const execution of releaseTest.deviceExecutions) {
+        switch (execution.state) {
+          case "PASSED":
+          case "IN_PROGRESS":
+            continue;
+          case "FAILED":
+            throw new FirebaseError(
+              `Automated test failed for ${deviceToString(execution.device)}: ${execution.failedReason}`,
+              { exit: 1 },
+            );
+          case "INCONCLUSIVE":
+            throw new FirebaseError(
+              `Automated test inconclusive for ${deviceToString(execution.device)}: ${execution.inconclusiveReason}`,
+              { exit: 1 },
+            );
+          default:
+            throw new FirebaseError(
+              `Unsupported automated test state for ${deviceToString(execution.device)}: ${execution.state}`,
+              { exit: 1 },
+            );
+        }
       }
     }
   }
-  throw new FirebaseError("It took longer than expected to process your test, please try again.", {
+  throw new FirebaseError("It took longer than expected to run your test(s), please try again.", {
     exit: 1,
   });
 }