@solana-mobile/dapp-store-cli 0.15.0 → 0.16.1

package/src/__tests__/CliSetupTest.ts

@@ -1,183 +1,335 @@
-import { beforeEach, expect } from "@jest/globals";
-import {
-  createAppCliCmd,
-  createCliCmd,
-  createReleaseCliCmd,
-  initCliCmd,
-  mainCli
-} from "../CliSetup";
-import { Constants } from "../CliUtils";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
 
-describe("Cli Setup & Execution", () => {
-  const outputHelpReference = "(outputHelp)"
+import { afterEach, beforeEach, describe, expect, test } from "@jest/globals";
 
-  let errorOutput: string = ""
-  let otherOutput: string = ""
+import { mainCli } from "../CliSetup";
+import {
+  DEFAULT_API_KEY_ENV,
+  DEFAULT_LOCAL_PORTAL_URL,
+  DEFAULT_PRODUCTION_PORTAL_URL,
+  UPDATED_PUBLISHING_CLI_DOCS_URL,
+  formatUpdatedCliUsageError,
+  resolveApiKey,
+  resolvePortalTargets,
+  validateNewVersionArgs,
+  validateResumeArgs,
+} from "../publication/cliValidation";
+
+describe("CLI surface", () => {
+  const outputHelpReference = "(outputHelp)";
+  const trackedEnvKeys = [
+    DEFAULT_API_KEY_ENV,
+    "ALT_DAPP_STORE_API_KEY",
+    "DAPP_STORE_PORTAL_URL",
+    "DAPP_STORE_PORTAL_WEB_URL",
+    "DAPP_STORE_PORTAL_API_BASE_URL",
+  ] as const;
+
+  let errorOutput = "";
+  let otherOutput = "";
+  let tempDir = "";
+  let originalEnv: Record<string, string | undefined> = {};
 
   beforeEach(() => {
     errorOutput = "";
     otherOutput = "";
-    mainCli.exitOverride();
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "dapp-store-cli-test-"));
+    originalEnv = Object.fromEntries(
+      trackedEnvKeys.map((key) => [key, process.env[key]])
+    );
+    for (const key of trackedEnvKeys) {
+      delete process.env[key];
+    }
 
+    mainCli.exitOverride();
     mainCli.configureOutput({
-      getOutHelpWidth(): number { return 250; },
-      getErrHelpWidth(): number { return 250;},
-
+      getOutHelpWidth(): number {
+        return 200;
+      },
+      getErrHelpWidth(): number {
+        return 200;
+      },
       writeOut(str: string) {
         otherOutput += str;
       },
-
       writeErr(str: string) {
         errorOutput += str;
-      }
+      },
     });
+    process.exitCode = 0;
   });
 
-  test("Cli version argument reports correct version", () => {
-
-    expect(() => {
-      mainCli.parse(["npx", "dapp-store", "-V"]);
-    }).toThrow(Constants.CLI_VERSION)
+  afterEach(() => {
+    fs.rmSync(tempDir, { recursive: true, force: true });
+    for (const [key, value] of Object.entries(originalEnv)) {
+      if (typeof value === "undefined") {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
   });
 
-  test("Calling cli with no parameters displays general help", () => {
-    expect(() => {
-        mainCli.parse(["npx", "dapp-store"]);
-      }
-    ).toThrow(outputHelpReference);
+  function createTempApkFile(fileName = "app-release.apk") {
+    const apkPath = path.join(tempDir, fileName);
+    fs.writeFileSync(apkPath, "apk");
+    return apkPath;
+  }
 
-    expect(generalHelp).toEqual(errorOutput)
+  test("version reports the package version", () => {
+    expect(() => {
+      mainCli.parse(["node", "dapp-store", "-V"]);
+    }).toThrow();
   });
 
-  test("Calling init command with help parameter shows contextual help info", () => {
-    initCliCmd.exitOverride()
-
+  test("help advertises the default publication surface", () => {
     expect(() => {
-      initCliCmd.parse(["dapp-store", "init", "-h"])
-    }).toThrow(outputHelpReference)
+      mainCli.parse(["node", "dapp-store", "--help"]);
+    }).toThrow(outputHelpReference);
+
+    expect(otherOutput).not.toContain("--new-version");
+    expect(otherOutput).toContain("resume");
+    expect(otherOutput).toContain("--apk-file");
+    expect(otherOutput).toContain("--apk-url");
+    expect(otherOutput).toContain("--keypair");
+    expect(otherOutput).toContain("--portal-url");
+    expect(otherOutput).not.toContain("--dapp-id");
+    expect(otherOutput).not.toContain("--fee-payer-keypair");
+    expect(otherOutput).not.toContain("--signer-keypair");
+    expect(errorOutput).toBe("");
+  });
 
-    expect(otherOutput).toEqual(initHelp)
-  })
+  test("new-version validation rejects ambiguous APK sources", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkFile: createTempApkFile(),
+        apkUrl: "https://example.com/app.apk",
+        whatsNew: "Fixes",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow("exactly one of `--apk-file` or `--apk-url`");
+  });
 
-  test("Calling create command with no options lists all options", () => {
-    createCliCmd.exitOverride()
+  test("new-version validation rejects missing APK source", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        whatsNew: "Fixes",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow("exactly one of `--apk-file` or `--apk-url`");
+  });
 
-    expect(() => {
-        createCliCmd.parse(["dapp-store", "create"]);
-      }
-    ).toThrow(outputHelpReference);
+  test("new-version validation rejects blank release notes", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkUrl: "https://example.com/app.apk",
+        whatsNew: "   ",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow("`--whats-new` is required.");
+  });
 
-    expect(errorOutput).toEqual(createHelp)
+  test("new-version validation rejects missing keypair", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkUrl: "https://example.com/app.apk",
+        whatsNew: "Fixes",
+      })
+    ).toThrow("`--keypair` is required.");
   });
 
-  test("Calling create app command with no arguments warns about required argument", () => {
-    createAppCliCmd.exitOverride()
+  test("new-version validation rejects a missing local APK file", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkFile: path.join(tempDir, "missing.apk"),
+        whatsNew: "Fixes",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow("APK file not found");
+  });
 
-    expect(() => {
-      createAppCliCmd.parse(["dapp-store", "create", "app"]);
-      }
-    ).toThrow(keyPairArgHelp);
+  test("new-version validation rejects non-HTTPS APK URLs", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkUrl: "http://example.com/app.apk",
+        whatsNew: "Fixes",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow("`--apk-url` must use HTTPS.");
   });
 
-  test("Calling create app command with help flag shows contextual help", () => {
-    createAppCliCmd.exitOverride()
+  test("new-version validation accepts an existing APK file", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkFile: createTempApkFile(),
+        whatsNew: "Fixes",
+        keypair: "/tmp/signer.json",
+      })
+    ).not.toThrow();
+  });
 
-    expect(() => {
-      createAppCliCmd.parse(["dapp-store", "create", "app", "-h"]);
-    }).toThrow(outputHelpReference)
+  test("new-version validation accepts a single HTTPS APK URL", () => {
+    expect(() =>
+      validateNewVersionArgs({
+        apkUrl: "https://example.com/app.apk",
+        whatsNew: "Fixes",
+        keypair: "/tmp/signer.json",
+      })
+    ).not.toThrow();
+  });
 
-    expect(otherOutput).toEqual(createAppHelp)
+  test("resume validation requires a single target", () => {
+    expect(() =>
+      validateResumeArgs({
+        releaseId: "release-1",
+        sessionId: "session-1",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow("exactly one of `--release-id` or `--session-id`");
   });
 
-  test("Calling create release command with no arguments warns about required argument", () => {
-    createReleaseCliCmd.exitOverride()
+  test("resume validation accepts alias flags", () => {
+    expect(() =>
+      validateResumeArgs({
+        resumeRelease: "release-1",
+        keypair: "/tmp/signer.json",
+      })
+    ).not.toThrow();
+
+    expect(() =>
+      validateResumeArgs({
+        resumeSession: "session-1",
+        keypair: "/tmp/signer.json",
+      })
+    ).not.toThrow();
+  });
 
-    expect(() => {
-        createReleaseCliCmd.parse(["dapp-store", "create", "release"]);
-      }
-    ).toThrow(keyPairArgHelp);
+  test("resume validation rejects conflicting release aliases", () => {
+    expect(() =>
+      validateResumeArgs({
+        releaseId: "release-1",
+        resumeRelease: "release-2",
+        keypair: "/tmp/signer.json",
+      })
+    ).toThrow(
+      "Conflicting values were provided for --release-id and --resume-release."
+    );
   });
 
-  test("Calling create release command with help flag shows contextual help", () => {
-    createReleaseCliCmd.exitOverride()
+  test("resume validation accepts a release id", () => {
+    expect(() =>
+      validateResumeArgs({
+        releaseId: "release-1",
+        keypair: "/tmp/signer.json",
+      })
+    ).not.toThrow();
+  });
 
-    expect(() => {
-      createReleaseCliCmd.parse(["dapp-store", "create", "release", "-h"]);
-    }).toThrow(outputHelpReference)
+  test("portal targets default to production when unset", () => {
+    const targets = resolvePortalTargets({});
 
-    expect(otherOutput).toEqual(createReleaseHelp)
+    expect(targets.apiBaseUrl).toBe(`${DEFAULT_PRODUCTION_PORTAL_URL}/api`);
   });
 
-  //--------------------------------------------------
+  test("portal targets default to localhost in local-dev mode", () => {
+    const targets = resolvePortalTargets({
+      localDev: true,
+    });
 
-  const generalHelp = `Usage: dapp-store [options] [command]
+    expect(targets.apiBaseUrl).toBe(`${DEFAULT_LOCAL_PORTAL_URL}/api`);
+  });
 
-CLI to assist with publishing to the Saga Dapp Store
+  test("portal targets derive the API base URL from the configured portal URL", () => {
+    const targets = resolvePortalTargets({
+      portalUrl: "https://staging.publish.solanamobile.com",
+    });
 
-Options:
-  -V, --version       output the version number
-  -h, --help          display help for command
+    expect(targets.apiBaseUrl).toBe(
+      "https://staging.publish.solanamobile.com/api"
+    );
+  });
 
-Commands:
-  init                First-time initialization of tooling configuration
-  create              Create a \`app\`, or \`release\`
-  validate [options]  Validates details prior to publishing
-  publish             Submit a publishing request (\`submit\`, \`update\`, \`remove\`, or \`support\`) to the Solana Mobile dApp publisher portal
-  help [command]      display help for command
-`;
+  test("portal targets preserve portal subpaths when deriving /api", () => {
+    const targets = resolvePortalTargets({
+      portalUrl: "https://portal.example.com/publishing",
+    });
 
-  const initHelp = `Usage: dapp-store init [options]
+    expect(targets.apiBaseUrl).toBe(
+      "https://portal.example.com/publishing/api"
+    );
+  });
 
-First-time initialization of tooling configuration
+  test("portal targets honor DAPP_STORE_PORTAL_URL from the environment", () => {
+    process.env.DAPP_STORE_PORTAL_URL = "https://env.publish.solanamobile.com";
 
-Options:
-  -h, --help  display help for command
-`;
+    const targets = resolvePortalTargets({});
 
-  const keyPairArgHelp = "error: required option '-k, --keypair <path-to-keypair-file>' not specified"
+    expect(targets.apiBaseUrl).toBe("https://env.publish.solanamobile.com/api");
+  });
 
-const createHelp = `Usage: dapp-store create [options] [command]
+  test("portal targets ignore removed legacy portal env vars", () => {
+    process.env.DAPP_STORE_PORTAL_WEB_URL =
+      "https://legacy-web.publish.solanamobile.com";
+    process.env.DAPP_STORE_PORTAL_API_BASE_URL =
+      "https://legacy.publish.solanamobile.com/root/api";
 
-Create a \`app\`, or \`release\`
+    const targets = resolvePortalTargets({});
 
-Options:
-  -h, --help         display help for command
+    expect(targets.apiBaseUrl).toBe(`${DEFAULT_PRODUCTION_PORTAL_URL}/api`);
+  });
 
-Commands:
-  app [options]      Create a app
-  release [options]  Create a release
-  help [command]     display help for command
+  test("local-dev mode rejects non-local portal URLs", () => {
+    expect(() =>
+      resolvePortalTargets({
+        localDev: true,
+        portalUrl: "https://portal.example.com",
+      })
+    ).toThrow("only allows localhost portal endpoints");
+  });
 
-Release metadata notes:
-  We include publisher.support_email when provided; if omitted we fall back to publisher.email.
-`;
+  test("non-local portal endpoints must use HTTPS", () => {
+    expect(() =>
+      resolvePortalTargets({
+        portalUrl: "http://portal.example.com",
+      })
+    ).toThrow("Portal endpoints must use HTTPS unless --local-dev is set.");
+  });
 
-  const createAppHelp = `Usage: dapp-store create app [options]
+  test("portal targets honor the configured API key env name", () => {
+    expect(DEFAULT_API_KEY_ENV).toBe("DAPP_STORE_API_KEY");
+  });
 
-Create a app
+  test("resolveApiKey reads the default API key env var", async () => {
+    process.env.DAPP_STORE_API_KEY = "portal-secret";
 
-Options:
-  -k, --keypair <path-to-keypair-file>                 Path to keypair file
-  -u, --url <url>                                      RPC URL (default: "https://api.devnet.solana.com")
-  -d, --dry-run                                        Flag for dry run. Doesn't mint an NFT
-  -s, --storage-config <storage-config>                Provide alternative storage configuration details
-  -p, --priority-fee-lamports <priority-fee-lamports>  Priority Fee lamports
-  -h, --help                                           display help for command
-`;
+    await expect(resolveApiKey({})).resolves.toBe("portal-secret");
+  });
 
-  const createReleaseHelp = `Usage: dapp-store create release [options]
+  test("resolveApiKey reads a custom API key env var", async () => {
+    process.env.ALT_DAPP_STORE_API_KEY = "alt-secret";
 
-Create a release
+    await expect(
+      resolveApiKey({ apiKeyEnv: "ALT_DAPP_STORE_API_KEY" })
+    ).resolves.toBe("alt-secret");
+  });
 
-Options:
-  -k, --keypair <path-to-keypair-file>                 Path to keypair file
-  -a, --app-mint-address <app-mint-address>            The mint address of the app NFT
-  -u, --url <url>                                      RPC URL (default: "https://api.devnet.solana.com")
-  -d, --dry-run                                        Flag for dry run. Doesn't mint an NFT
-  -b, --build-tools-path <build-tools-path>            Path to Android build tools which contains AAPT2
-  -s, --storage-config <storage-config>                Provide alternative storage configuration details
-  -p, --priority-fee-lamports <priority-fee-lamports>  Priority Fee lamports
-  -h, --help                                           display help for command
-`;
+  test("resolveApiKey rejects when no API key is available", async () => {
+    await expect(resolveApiKey({})).rejects.toThrow(
+      "Portal API key is required."
+    );
+    await expect(resolveApiKey({})).rejects.toThrow(
+      UPDATED_PUBLISHING_CLI_DOCS_URL
+    );
+  });
 
+  test("formatUpdatedCliUsageError converts unknown-option errors into docs guidance", () => {
+    expect(formatUpdatedCliUsageError("error: unknown option '-k'")).toContain(
+      "Unknown option '-k'."
+    );
+    expect(formatUpdatedCliUsageError("error: unknown option '-k'")).toContain(
+      UPDATED_PUBLISHING_CLI_DOCS_URL
+    );
+  });
 });

package/src/cli/__tests__/parseErrors.test.ts

@@ -0,0 +1,34 @@
+import { describe, expect, test } from "@jest/globals";
+
+import {
+  getCommanderUserFacingError,
+  isCommanderLifecycleExit,
+} from "../parseErrors";
+import { UPDATED_PUBLISHING_CLI_DOCS_URL } from "../../publication/cliValidation";
+
+describe("CLI parse error handling", () => {
+  test("legacy parse errors point to the updated publishing docs", () => {
+    const error = getCommanderUserFacingError({
+      code: "commander.unknownOption",
+      exitCode: 1,
+      message: "error: unknown option '-k'",
+      name: "CommanderError",
+    });
+
+    expect(error).not.toBeNull();
+    expect(error?.exitCode).toBe(1);
+    expect(error?.message).toContain("Unknown option '-k'.");
+    expect(error?.message).toContain(UPDATED_PUBLISHING_CLI_DOCS_URL);
+  });
+
+  test("help exits are ignored", () => {
+    expect(
+      isCommanderLifecycleExit({
+        code: "commander.helpDisplayed",
+        exitCode: 0,
+        message: "(outputHelp)",
+        name: "CommanderError",
+      })
+    ).toBe(true);
+  });
+});