@ollie-shop/cli 0.3.4 → 1.0.0

package/__tests__/mocks/console.ts

@@ -1,22 +0,0 @@
-import { vi } from "vitest";
-
-export const createMockConsole = () => ({
-  setOptions: vi.fn(),
-  hint: vi.fn(),
-  info: vi.fn(),
-  success: vi.fn(),
-  error: vi.fn(),
-  warn: vi.fn(),
-  debug: vi.fn(),
-  dim: vi.fn(),
-  spinner: vi.fn(() => ({
-    start: vi.fn().mockReturnThis(),
-    succeed: vi.fn().mockReturnThis(),
-    fail: vi.fn().mockReturnThis(),
-    warn: vi.fn().mockReturnThis(),
-    stop: vi.fn().mockReturnThis(),
-    text: "",
-  })),
-});
-
-export const mockConsole = createMockConsole();

package/__tests__/mocks/core.ts

@@ -1,137 +0,0 @@
-import { faker } from "@faker-js/faker";
-import {
-  componentFactory,
-  functionFactory,
-  versionFactory,
-} from "@ollie-shop/core/testing";
-import { vi } from "vitest";
-
-// Mock the services from core
-export const createMockCore = () => {
-  // Component service functions
-  const componentService = {
-    createComponent: vi.fn(),
-    listComponents: vi.fn(),
-    getComponent: vi.fn(),
-    deployComponent: vi.fn(),
-    buildComponent: vi.fn(),
-    validateComponent: vi.fn(),
-    enableComponent: vi.fn(),
-    disableComponent: vi.fn(),
-    updateComponent: vi.fn(),
-    getComponentMeta: vi.fn(),
-    updateComponentMeta: vi.fn(),
-  };
-
-  // Function service functions
-  const functionService = {
-    createFunction: vi.fn(),
-    listFunctions: vi.fn(),
-    deployFunction: vi.fn(),
-    buildFunction: vi.fn(),
-    validateFunction: vi.fn(),
-    testFunction: vi.fn(),
-    getFunctionMeta: vi.fn(),
-    updateFunctionMeta: vi.fn(),
-  };
-
-  // Version service functions
-  const versionService = {
-    createVersion: vi.fn(),
-    listVersions: vi.fn(),
-    getVersion: vi.fn(),
-    updateVersion: vi.fn(),
-    deleteVersion: vi.fn(),
-    setDefaultVersion: vi.fn(),
-    activateVersion: vi.fn(),
-    deactivateVersion: vi.fn(),
-    cloneVersion: vi.fn(),
-  };
-
-  // Setup default behaviors
-  componentService.createComponent.mockImplementation(
-    async (path, _options) => {
-      return { success: true, path };
-    },
-  );
-
-  componentService.listComponents.mockResolvedValue(
-    componentFactory.buildList(3),
-  );
-
-  componentService.deployComponent.mockImplementation(async (id, _path) => {
-    return componentFactory.build({
-      id,
-      url: faker.internet.url(),
-      active: true,
-    });
-  });
-
-  componentService.buildComponent.mockImplementation(async (path) => ({
-    success: true,
-    outputPath: `${path}/dist`,
-    size: faker.number.int({ min: 1000, max: 100000 }),
-    duration: faker.number.int({ min: 100, max: 5000 }),
-  }));
-
-  componentService.validateComponent.mockImplementation(async (_path) => ({
-    valid: true,
-    errors: [],
-    warnings: [],
-  }));
-
-  functionService.createFunction.mockImplementation(async (path, _options) => {
-    return { success: true, path };
-  });
-
-  functionService.listFunctions.mockResolvedValue(functionFactory.buildList(2));
-
-  functionService.deployFunction.mockImplementation(async (id, _path) => {
-    return functionFactory.build({
-      id,
-      urn: `arn:aws:lambda:us-east-1:${faker.string.numeric(12)}:function:deployed`,
-      active: true,
-    });
-  });
-
-  functionService.buildFunction.mockImplementation(async (path) => ({
-    success: true,
-    outputPath: `${path}/dist`,
-    size: faker.number.int({ min: 1000, max: 50000 }),
-    duration: faker.number.int({ min: 100, max: 3000 }),
-  }));
-
-  functionService.validateFunction.mockImplementation(async (_path) => ({
-    valid: true,
-    errors: [],
-    warnings: [],
-  }));
-
-  functionService.testFunction.mockImplementation(async (_path, _payload) => ({
-    success: true,
-    output: { message: "Test successful" },
-    logs: ["Function executed successfully"],
-    duration: faker.number.int({ min: 10, max: 500 }),
-  }));
-
-  versionService.createVersion.mockImplementation(async (data) =>
-    versionFactory.build({ ...data, id: faker.string.uuid() }),
-  );
-
-  versionService.listVersions.mockResolvedValue(versionFactory.buildList(2));
-
-  versionService.setDefaultVersion.mockImplementation(async (id) =>
-    versionFactory.build({ id, default: true }),
-  );
-
-  return {
-    componentService,
-    functionService,
-    versionService,
-  };
-};
-
-// Export individual mocks
-export const mockComponentService = createMockCore().componentService;
-export const mockFunctionService = createMockCore().functionService;
-export const mockVersionService = createMockCore().versionService;

package/__tests__/mocks/index.ts

@@ -1,4 +0,0 @@
-export * from "./core";
-export * from "./console";
-export * from "./inquirer";
-export * from "./progress";

package/__tests__/mocks/inquirer.ts

@@ -1,16 +0,0 @@
-import { vi } from "vitest";
-
-export const createMockInquirer = () => ({
-  prompt: vi.fn().mockResolvedValue({
-    name: "test-name",
-    slot: "header",
-    template: "default",
-    typescript: true,
-    includeTests: true,
-    includeStyles: true,
-    confirm: true,
-  }),
-  registerPrompt: vi.fn(),
-});
-
-export const mockInquirer = createMockInquirer();

package/__tests__/mocks/progress.ts

@@ -1,19 +0,0 @@
-import { vi } from "vitest";
-
-export const createMockProgressBar = () => ({
-  start: vi.fn(),
-  increment: vi.fn(),
-  update: vi.fn(),
-  stop: vi.fn(),
-});
-
-export const mockProgressBar = createMockProgressBar();
-
-export const createMockCliProgress = () => ({
-  SingleBar: vi.fn(() => mockProgressBar),
-  Presets: {
-    shades_classic: {},
-  },
-});
-
-export const mockCliProgress = createMockCliProgress();

package/dist/index.d.ts

@@ -1 +0,0 @@
-#!/usr/bin/env node

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

@@ -1,281 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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(),
-    },
-  };
-}