@ollie-shop/cli 0.2.0 → 0.3.0

package/src/__tests__/helpers/cli-test-helper.ts

@@ -0,0 +1,281 @@
+import { Command } from "@commander-js/extra-typings";
+import { expect, vi } from "vitest";
+
+/**
+ * CLI Testing Helper for Commander.js applications
+ * Based on best practices for testing CLI applications with Vitest
+ */
+
+export interface CLITestResult {
+  exitCode: number;
+  stdout: string[];
+  stderr: string[];
+  error?: Error;
+}
+
+export interface ProcessMocks {
+  exit: ReturnType<typeof vi.fn>;
+  stdout: {
+    write: ReturnType<typeof vi.fn>;
+  };
+  stderr: {
+    write: ReturnType<typeof vi.fn>;
+  };
+}
+
+export interface ConsoleMocks {
+  log: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+  info: ReturnType<typeof vi.fn>;
+}
+
+/**
+ * Create a test-friendly Commander.js program that captures output
+ * and prevents process.exit from terminating the test
+ */
+export function createTestProgram(): {
+  program: Command;
+  mocks: {
+    process: ProcessMocks;
+    console: ConsoleMocks;
+  };
+  getResult: () => CLITestResult;
+} {
+  const stdout: string[] = [];
+  const stderr: string[] = [];
+  let exitCode = 0;
+  let capturedError: Error | undefined;
+
+  // Mock process methods
+  const processMocks: ProcessMocks = {
+    exit: vi.fn((code = 0) => {
+      exitCode = code;
+      // Throw error instead of exiting to prevent test termination
+      throw new Error(`process.exit(${code})`);
+    }),
+    stdout: {
+      write: vi.fn((data: string) => {
+        stdout.push(data);
+        return true;
+      }),
+    },
+    stderr: {
+      write: vi.fn((data: string) => {
+        stderr.push(data);
+        return true;
+      }),
+    },
+  };
+
+  // Mock console methods
+  const consoleMocks: ConsoleMocks = {
+    log: vi.fn((...args: unknown[]) => {
+      stdout.push(`${args.join(" ")}\n`);
+    }),
+    error: vi.fn((...args: unknown[]) => {
+      stderr.push(`${args.join(" ")}\n`);
+    }),
+    warn: vi.fn((...args: unknown[]) => {
+      stderr.push(`${args.join(" ")}\n`);
+    }),
+    info: vi.fn((...args: unknown[]) => {
+      stdout.push(`${args.join(" ")}\n`);
+    }),
+  };
+
+  // Apply mocks
+  vi.spyOn(process, "exit").mockImplementation(((code?: number | undefined) => {
+    throw new Error(`Process exit with code ${code}`);
+  }) as never);
+  vi.spyOn(process.stdout, "write").mockImplementation(
+    processMocks.stdout.write,
+  );
+  vi.spyOn(process.stderr, "write").mockImplementation(
+    processMocks.stderr.write,
+  );
+  vi.spyOn(console, "log").mockImplementation(consoleMocks.log);
+  vi.spyOn(console, "error").mockImplementation(consoleMocks.error);
+  vi.spyOn(console, "warn").mockImplementation(consoleMocks.warn);
+  vi.spyOn(console, "info").mockImplementation(consoleMocks.info);
+
+  // Also mock global.console which is used by the CLI console utility
+  vi.spyOn(global.console, "log").mockImplementation(consoleMocks.log);
+  vi.spyOn(global.console, "error").mockImplementation(consoleMocks.error);
+  vi.spyOn(global.console, "warn").mockImplementation(consoleMocks.warn);
+  vi.spyOn(global.console, "info").mockImplementation(consoleMocks.info);
+
+  // Create program with exitOverride to handle errors gracefully
+  const program = new Command();
+  program
+    .exitOverride((err) => {
+      capturedError = err;
+      exitCode = err.exitCode || 1;
+      throw err;
+    })
+    .configureOutput({
+      writeOut: (str) => {
+        stdout.push(str);
+      },
+      writeErr: (str) => {
+        stderr.push(str);
+      },
+    });
+
+  const getResult = (): CLITestResult => ({
+    exitCode,
+    stdout: [...stdout],
+    stderr: [...stderr],
+    error: capturedError,
+  });
+
+  return {
+    program,
+    mocks: {
+      process: processMocks,
+      console: consoleMocks,
+    },
+    getResult,
+  };
+}
+
+/**
+ * Execute a CLI command with arguments and capture the result
+ */
+export async function executeCLI(
+  program: Command,
+  args: string[],
+  options: { from: "node" | "electron" | "user" } = { from: "user" },
+): Promise<CLITestResult> {
+  const stdout: string[] = [];
+  const stderr: string[] = [];
+  let exitCode = 0;
+  let capturedError: Error | undefined;
+
+  // Capture output
+  const originalWriteOut = program.configureOutput().writeOut;
+  const originalWriteErr = program.configureOutput().writeErr;
+
+  program.configureOutput({
+    writeOut: (str) => {
+      stdout.push(str);
+      if (originalWriteOut) originalWriteOut(str);
+    },
+    writeErr: (str) => {
+      stderr.push(str);
+      if (originalWriteErr) originalWriteErr(str);
+    },
+  });
+
+  try {
+    await program.parseAsync(args, options);
+  } catch (error) {
+    capturedError = error as Error;
+
+    // Handle Commander.js specific errors
+    if (error && typeof error === "object" && "code" in error) {
+      const commanderError = error as { code: string; exitCode: number };
+      exitCode = commanderError.exitCode || 1;
+    } else if (
+      error instanceof Error &&
+      error.message.includes("process.exit")
+    ) {
+      // Handle our mocked process.exit
+      const match = error.message.match(/process\.exit\((\d+)\)/);
+      exitCode = match?.[1] ? Number.parseInt(match[1], 10) : 1;
+    } else {
+      exitCode = 1;
+    }
+  }
+
+  return {
+    exitCode,
+    stdout,
+    stderr,
+    error: capturedError,
+  };
+}
+
+/**
+ * Reset all CLI test mocks between tests
+ */
+export function resetCLIMocks(): void {
+  vi.clearAllMocks();
+  vi.restoreAllMocks();
+}
+
+/**
+ * Create mock for inquirer prompts
+ */
+export function createInquirerMock(responses: Record<string, unknown>) {
+  return {
+    prompt: vi
+      .fn()
+      .mockImplementation(
+        (questions: Array<{ name?: string; [key: string]: unknown }>) => {
+          const answers: Record<string, unknown> = {};
+          for (const question of questions) {
+            if (question.name && responses[question.name] !== undefined) {
+              answers[question.name] = responses[question.name];
+            }
+          }
+          return Promise.resolve(answers);
+        },
+      ),
+  };
+}
+
+/**
+ * Create mock for ora spinner
+ */
+export function createSpinnerMock() {
+  const mock = {
+    start: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+    info: vi.fn().mockReturnThis(),
+    text: "",
+    isSpinning: false,
+  };
+
+  return {
+    mock,
+    create: vi.fn(() => mock),
+  };
+}
+
+/**
+ * Assert CLI output contains expected text
+ */
+export function expectCLIOutput(
+  result: CLITestResult,
+  expected: {
+    stdout?: string | RegExp;
+    stderr?: string | RegExp;
+    exitCode?: number;
+  },
+) {
+  if (expected.exitCode !== undefined) {
+    expect(result.exitCode).toBe(expected.exitCode);
+  }
+
+  if (expected.stdout !== undefined) {
+    const stdoutText = result.stdout.join("");
+    if (typeof expected.stdout === "string") {
+      expect(stdoutText).toContain(expected.stdout);
+    } else {
+      expect(stdoutText).toMatch(expected.stdout);
+    }
+  }
+
+  if (expected.stderr !== undefined) {
+    const stderrText = result.stderr.join("");
+    if (typeof expected.stderr === "string") {
+      expect(stderrText).toContain(expected.stderr);
+    } else {
+      expect(stderrText).toMatch(expected.stderr);
+    }
+  }
+}

package/src/__tests__/mocks/index.ts

@@ -0,0 +1,142 @@
+import { vi } from "vitest";
+
+export interface MockConsole {
+  success: ReturnType<typeof vi.fn>;
+  error: ReturnType<typeof vi.fn>;
+  info: ReturnType<typeof vi.fn>;
+  warn: ReturnType<typeof vi.fn>;
+  hint: ReturnType<typeof vi.fn>;
+  spinner: ReturnType<typeof vi.fn>;
+  log: ReturnType<typeof vi.fn>;
+  dim: ReturnType<typeof vi.fn>;
+}
+
+export interface MockInquirer {
+  prompt: ReturnType<typeof vi.fn>;
+  select: ReturnType<typeof vi.fn>;
+  input: ReturnType<typeof vi.fn>;
+  confirm: ReturnType<typeof vi.fn>;
+}
+
+export interface MockSpinner {
+  succeed: ReturnType<typeof vi.fn>;
+  fail: ReturnType<typeof vi.fn>;
+  start: ReturnType<typeof vi.fn>;
+  stop: ReturnType<typeof vi.fn>;
+}
+
+export interface MockCore {
+  listComponents: ReturnType<typeof vi.fn>;
+  createComponent: ReturnType<typeof vi.fn>;
+  deployComponent: ReturnType<typeof vi.fn>;
+  deleteComponent: ReturnType<typeof vi.fn>;
+  listFunctions: ReturnType<typeof vi.fn>;
+  createFunction: ReturnType<typeof vi.fn>;
+  deployFunction: ReturnType<typeof vi.fn>;
+  deleteFunction: ReturnType<typeof vi.fn>;
+  listVersions: ReturnType<typeof vi.fn>;
+  createVersion: ReturnType<typeof vi.fn>;
+  setDefaultVersion: ReturnType<typeof vi.fn>;
+  deleteVersion: ReturnType<typeof vi.fn>;
+}
+
+export function createMockConsole(): MockConsole {
+  return {
+    success: vi.fn(),
+    error: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    hint: vi.fn(),
+    spinner: vi.fn(() => createMockSpinner()),
+    log: vi.fn(),
+    dim: vi.fn(),
+  };
+}
+
+export function createMockInquirer(): MockInquirer {
+  return {
+    prompt: vi.fn(),
+    select: vi.fn(),
+    input: vi.fn(),
+    confirm: vi.fn(),
+  };
+}
+
+export function createMockSpinner(): MockSpinner {
+  return {
+    succeed: vi.fn(),
+    fail: vi.fn(),
+    start: vi.fn(),
+    stop: vi.fn(),
+  };
+}
+
+export function createMockCore(): MockCore & {
+  versionService: {
+    list: ReturnType<typeof vi.fn>;
+    create: ReturnType<typeof vi.fn>;
+    setDefault: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+    clone: ReturnType<typeof vi.fn>;
+    activate: ReturnType<typeof vi.fn>;
+    deactivate: ReturnType<typeof vi.fn>;
+  };
+  projectService: {
+    getProjectInfo: ReturnType<typeof vi.fn>;
+  };
+  componentService: {
+    list: ReturnType<typeof vi.fn>;
+    create: ReturnType<typeof vi.fn>;
+    deploy: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+  };
+  functionService: {
+    list: ReturnType<typeof vi.fn>;
+    create: ReturnType<typeof vi.fn>;
+    deploy: ReturnType<typeof vi.fn>;
+    delete: ReturnType<typeof vi.fn>;
+    update: ReturnType<typeof vi.fn>;
+    test: ReturnType<typeof vi.fn>;
+  };
+} {
+  return {
+    listComponents: vi.fn(),
+    createComponent: vi.fn(),
+    deployComponent: vi.fn(),
+    deleteComponent: vi.fn(),
+    listFunctions: vi.fn(),
+    createFunction: vi.fn(),
+    deployFunction: vi.fn(),
+    deleteFunction: vi.fn(),
+    listVersions: vi.fn(),
+    createVersion: vi.fn(),
+    setDefaultVersion: vi.fn(),
+    deleteVersion: vi.fn(),
+    versionService: {
+      list: vi.fn(),
+      create: vi.fn(),
+      setDefault: vi.fn(),
+      delete: vi.fn(),
+      clone: vi.fn(),
+      activate: vi.fn(),
+      deactivate: vi.fn(),
+    },
+    projectService: {
+      getProjectInfo: vi.fn(),
+    },
+    componentService: {
+      list: vi.fn(),
+      create: vi.fn(),
+      deploy: vi.fn(),
+      delete: vi.fn(),
+    },
+    functionService: {
+      list: vi.fn(),
+      create: vi.fn(),
+      deploy: vi.fn(),
+      delete: vi.fn(),
+      update: vi.fn(),
+      test: vi.fn(),
+    },
+  };
+}