@enactprotocol/cli 1.2.13 → 2.0.0

package/tests/commands/run.test.ts

@@ -0,0 +1,231 @@
+/**
+ * Tests for the run command
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { Command } from "commander";
+import { configureRunCommand } from "../../src/commands/run";
+
+// Test fixtures directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "fixtures", "run-cmd");
+
+describe("run command", () => {
+  beforeAll(() => {
+    // Create test fixtures
+    mkdirSync(FIXTURES_DIR, { recursive: true });
+  });
+
+  afterAll(() => {
+    // Clean up
+    if (existsSync(FIXTURES_DIR)) {
+      rmSync(FIXTURES_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("command configuration", () => {
+    test("configures run command on program", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      expect(runCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      expect(runCmd?.description()).toBe("Execute a tool with its manifest-defined command");
+    });
+
+    test("accepts tool argument", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const args = runCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThan(0);
+      expect(args[0]?.name()).toBe("tool");
+    });
+
+    test("has --args option for JSON input", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const argsOpt = opts.find((o) => o.long === "--args");
+      expect(argsOpt).toBeDefined();
+    });
+
+    test("has --input option for key=value pairs", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const inputOpt = opts.find((o) => o.long === "--input");
+      expect(inputOpt).toBeDefined();
+    });
+
+    test("has --timeout option", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const timeoutOpt = opts.find((o) => o.long === "--timeout");
+      expect(timeoutOpt).toBeDefined();
+    });
+
+    test("has --dry-run option", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const dryRunOpt = opts.find((o) => o.long === "--dry-run");
+      expect(dryRunOpt).toBeDefined();
+    });
+
+    test("has --verbose option", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const verboseOpt = opts.find((o) => o.long === "--verbose");
+      expect(verboseOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+
+    test("has --no-cache option", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const noCacheOpt = opts.find((o) => o.long === "--no-cache");
+      expect(noCacheOpt).toBeDefined();
+    });
+
+    test("has --local option", () => {
+      const program = new Command();
+      configureRunCommand(program);
+
+      const runCmd = program.commands.find((cmd) => cmd.name() === "run");
+      const opts = runCmd?.options ?? [];
+      const localOpt = opts.find((o) => o.long === "--local");
+      expect(localOpt).toBeDefined();
+    });
+  });
+
+  describe("input parsing helpers", () => {
+    // Test the parseInputArgs logic through module testing
+    // We test the expected behavior patterns
+
+    test("JSON args should be parseable", () => {
+      const argsJson = '{"name": "World", "count": 5}';
+      const parsed = JSON.parse(argsJson);
+      expect(parsed.name).toBe("World");
+      expect(parsed.count).toBe(5);
+    });
+
+    test("key=value pairs should be splittable", () => {
+      const input = "name=Alice";
+      const eqIndex = input.indexOf("=");
+      const key = input.slice(0, eqIndex);
+      const value = input.slice(eqIndex + 1);
+      expect(key).toBe("name");
+      expect(value).toBe("Alice");
+    });
+
+    test("key=value with JSON value should be parseable", () => {
+      const input = 'data={"nested": true}';
+      const eqIndex = input.indexOf("=");
+      const value = input.slice(eqIndex + 1);
+      const parsed = JSON.parse(value);
+      expect(parsed.nested).toBe(true);
+    });
+
+    test("key=value with multiple equals signs", () => {
+      const input = "url=https://api.example.com?key=value";
+      const eqIndex = input.indexOf("=");
+      const key = input.slice(0, eqIndex);
+      const value = input.slice(eqIndex + 1);
+      expect(key).toBe("url");
+      expect(value).toBe("https://api.example.com?key=value");
+    });
+  });
+
+  describe("timeout parsing", () => {
+    // Test timeout format parsing patterns
+
+    test("parses seconds", () => {
+      const match = "30s".match(/^(\d+)(s|m|h)?$/);
+      expect(match).toBeTruthy();
+      expect(match?.[1]).toBe("30");
+      expect(match?.[2]).toBe("s");
+    });
+
+    test("parses minutes", () => {
+      const match = "5m".match(/^(\d+)(s|m|h)?$/);
+      expect(match).toBeTruthy();
+      expect(match?.[1]).toBe("5");
+      expect(match?.[2]).toBe("m");
+    });
+
+    test("parses hours", () => {
+      const match = "1h".match(/^(\d+)(s|m|h)?$/);
+      expect(match).toBeTruthy();
+      expect(match?.[1]).toBe("1");
+      expect(match?.[2]).toBe("h");
+    });
+
+    test("parses number without unit (defaults to seconds)", () => {
+      const match = "30".match(/^(\d+)(s|m|h)?$/);
+      expect(match).toBeTruthy();
+      expect(match?.[1]).toBe("30");
+      expect(match?.[2]).toBeUndefined();
+    });
+
+    test("rejects invalid format", () => {
+      const match = "30x".match(/^(\d+)(s|m|h)?$/);
+      expect(match).toBeNull();
+    });
+
+    test("converts to milliseconds correctly", () => {
+      const parseTimeout = (timeout: string): number => {
+        const match = timeout.match(/^(\d+)(s|m|h)?$/);
+        if (!match) throw new Error("Invalid format");
+        const value = Number.parseInt(match[1] ?? "0", 10);
+        const unit = match[2] || "s";
+        switch (unit) {
+          case "h":
+            return value * 60 * 60 * 1000;
+          case "m":
+            return value * 60 * 1000;
+          default:
+            return value * 1000;
+        }
+      };
+
+      expect(parseTimeout("30s")).toBe(30000);
+      expect(parseTimeout("5m")).toBe(300000);
+      expect(parseTimeout("1h")).toBe(3600000);
+      expect(parseTimeout("30")).toBe(30000);
+    });
+  });
+});

package/tests/commands/search.test.ts

@@ -0,0 +1,131 @@
+/**
+ * Tests for the search command
+ */
+
+import { describe, expect, test } from "bun:test";
+import { Command } from "commander";
+import { configureSearchCommand } from "../../src/commands/search";
+
+describe("search command", () => {
+  describe("command configuration", () => {
+    test("configures search command on program", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      expect(searchCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      expect(searchCmd?.description()).toBe("Search the Enact registry for tools");
+    });
+
+    test("accepts query argument", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      const args = searchCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThan(0);
+      expect(args[0]?.name()).toBe("query");
+    });
+
+    test("has --tags option", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      const opts = searchCmd?.options ?? [];
+      const tagsOpt = opts.find((o) => o.long === "--tags");
+      expect(tagsOpt).toBeDefined();
+    });
+
+    test("has -t short option for tags", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      const opts = searchCmd?.options ?? [];
+      const tagsOpt = opts.find((o) => o.short === "-t");
+      expect(tagsOpt).toBeDefined();
+    });
+
+    test("has --limit option", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      const opts = searchCmd?.options ?? [];
+      const limitOpt = opts.find((o) => o.long === "--limit");
+      expect(limitOpt).toBeDefined();
+    });
+
+    test("has -l short option for limit", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      const opts = searchCmd?.options ?? [];
+      const limitOpt = opts.find((o) => o.short === "-l");
+      expect(limitOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureSearchCommand(program);
+
+      const searchCmd = program.commands.find((cmd) => cmd.name() === "search");
+      const opts = searchCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+  });
+
+  describe("search result display helpers", () => {
+    test("truncates long descriptions", () => {
+      const truncate = (text: string, max: number): string => {
+        if (text.length <= max) return text;
+        return `${text.slice(0, max - 3)}...`;
+      };
+
+      expect(truncate("short", 50)).toBe("short");
+      expect(truncate("a".repeat(60), 50)).toBe(`${"a".repeat(47)}...`);
+    });
+
+    test("formats download count", () => {
+      const formatDownloads = (downloads: number): string => {
+        if (downloads >= 1_000_000) return `${(downloads / 1_000_000).toFixed(1)}M`;
+        if (downloads >= 1_000) return `${(downloads / 1_000).toFixed(1)}k`;
+        return downloads.toString();
+      };
+
+      expect(formatDownloads(500)).toBe("500");
+      expect(formatDownloads(1500)).toBe("1.5k");
+      expect(formatDownloads(1_500_000)).toBe("1.5M");
+    });
+  });
+
+  describe("tag parsing", () => {
+    test("splits comma-separated tags", () => {
+      const tagsInput = "cli,testing,automation";
+      const tags = tagsInput.split(",").map((t) => t.trim());
+      expect(tags).toEqual(["cli", "testing", "automation"]);
+    });
+
+    test("trims whitespace from tags", () => {
+      const tagsInput = "cli , testing , automation";
+      const tags = tagsInput.split(",").map((t) => t.trim());
+      expect(tags).toEqual(["cli", "testing", "automation"]);
+    });
+
+    test("handles single tag", () => {
+      const tagsInput = "cli";
+      const tags = tagsInput.split(",").map((t) => t.trim());
+      expect(tags).toEqual(["cli"]);
+    });
+  });
+});

package/tests/commands/sign.test.ts

@@ -0,0 +1,164 @@
+/**
+ * Tests for the sign command
+ */
+
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { Command } from "commander";
+import { configureSignCommand } from "../../src/commands/sign";
+
+// Test fixtures directory
+const FIXTURES_DIR = join(import.meta.dir, "..", "fixtures", "sign-cmd");
+
+describe("sign command", () => {
+  beforeAll(() => {
+    mkdirSync(FIXTURES_DIR, { recursive: true });
+
+    // Create a test manifest
+    writeFileSync(
+      join(FIXTURES_DIR, "enact.yaml"),
+      `enact: "2.0.0"
+name: "test/sign-tool"
+version: "1.0.0"
+description: "A test tool for signing"
+from: "alpine:latest"
+command: "echo hello"
+`
+    );
+  });
+
+  afterAll(() => {
+    if (existsSync(FIXTURES_DIR)) {
+      rmSync(FIXTURES_DIR, { recursive: true, force: true });
+    }
+  });
+
+  describe("command configuration", () => {
+    test("configures sign command on program", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      expect(signCmd).toBeDefined();
+    });
+
+    test("has correct description", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      expect(signCmd?.description()).toBe(
+        "Cryptographically sign a tool and submit attestation to registry"
+      );
+    });
+
+    test("accepts path argument", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const args = signCmd?.registeredArguments ?? [];
+      expect(args.length).toBeGreaterThanOrEqual(1);
+      expect(args[0]?.name()).toBe("path");
+    });
+
+    test("has --identity option", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const opts = signCmd?.options ?? [];
+      const identityOpt = opts.find((o) => o.long === "--identity");
+      expect(identityOpt).toBeDefined();
+    });
+
+    test("has --output option", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const opts = signCmd?.options ?? [];
+      const outputOpt = opts.find((o) => o.long === "--output");
+      expect(outputOpt).toBeDefined();
+    });
+
+    test("has --dry-run option", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const opts = signCmd?.options ?? [];
+      const dryRunOpt = opts.find((o) => o.long === "--dry-run");
+      expect(dryRunOpt).toBeDefined();
+    });
+
+    test("has --verbose option", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const opts = signCmd?.options ?? [];
+      const verboseOpt = opts.find((o) => o.long === "--verbose");
+      expect(verboseOpt).toBeDefined();
+    });
+
+    test("has --json option", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const opts = signCmd?.options ?? [];
+      const jsonOpt = opts.find((o) => o.long === "--json");
+      expect(jsonOpt).toBeDefined();
+    });
+
+    test("has --local option", () => {
+      const program = new Command();
+      configureSignCommand(program);
+
+      const signCmd = program.commands.find((cmd) => cmd.name() === "sign");
+      const opts = signCmd?.options ?? [];
+      const localOpt = opts.find((o) => o.long === "--local");
+      expect(localOpt).toBeDefined();
+    });
+  });
+
+  describe("signing workflow", () => {
+    test("default bundle filename is .sigstore-bundle.json", () => {
+      // This is defined in the module
+      const expectedFilename = ".sigstore-bundle.json";
+      expect(expectedFilename).toBe(".sigstore-bundle.json");
+    });
+
+    test("signing requires OIDC authentication", () => {
+      // Sigstore keyless signing requires OIDC
+      const requiresOIDC = true;
+      expect(requiresOIDC).toBe(true);
+    });
+
+    test("signing creates in-toto attestation", () => {
+      // The sign command creates in-toto attestations
+      const attestationType = "https://in-toto.io/Statement/v1";
+      expect(attestationType).toContain("in-toto");
+    });
+  });
+
+  describe("Sigstore integration", () => {
+    test("uses Fulcio for certificate issuance", () => {
+      const fulcioUrl = "https://fulcio.sigstore.dev";
+      expect(fulcioUrl).toContain("fulcio");
+    });
+
+    test("uses Rekor for transparency logging", () => {
+      const rekorUrl = "https://rekor.sigstore.dev";
+      expect(rekorUrl).toContain("rekor");
+    });
+
+    test("creates Enact tool attestation predicate", () => {
+      const predicateType = "https://enact.tools/attestation/tool/v1";
+      expect(predicateType).toContain("enact.tools");
+      expect(predicateType).toContain("tool");
+    });
+  });
+});