@ollie-shop/cli 0.1.3 → 0.3.0

package/src/utils/__tests__/command-parser.test.ts

@@ -0,0 +1,159 @@
+import { InvalidArgumentError } from "@commander-js/extra-typings";
+import { describe, expect, it } from "vitest";
+import {
+  parseBooleanOption,
+  parseComponentName,
+  parseComponentSlot,
+  parseFunctionInvocation,
+  parseFunctionName,
+  parsePath,
+} from "../command-parser";
+
+describe("Command Parsers", () => {
+  describe("parseComponentName", () => {
+    it("should accept valid component names", () => {
+      expect(parseComponentName("header-nav")).toBe("header-nav");
+      expect(parseComponentName("shopping-cart")).toBe("shopping-cart");
+      expect(parseComponentName("product-list-2")).toBe("product-list-2");
+    });
+
+    it("should reject invalid component names", () => {
+      expect(() => parseComponentName("")).toThrow(InvalidArgumentError);
+      expect(() => parseComponentName("Test")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseComponentName("test component")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseComponentName("test_component")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseComponentName("Test-Component")).toThrow(
+        /lowercase with hyphens/,
+      );
+    });
+
+    it("should provide helpful error messages", () => {
+      try {
+        parseComponentName("TestComponent");
+      } catch (error) {
+        expect(error).toBeInstanceOf(InvalidArgumentError);
+        expect(error.message).toContain("Invalid component name");
+        expect(error.message).toContain(
+          "Component names must be lowercase with hyphens only",
+        );
+        expect(error.message).toContain("Examples:");
+      }
+    });
+  });
+
+  describe("parseFunctionName", () => {
+    it("should accept valid function names", () => {
+      expect(parseFunctionName("validate-order")).toBe("validate-order");
+      expect(parseFunctionName("apply-discount")).toBe("apply-discount");
+      expect(parseFunctionName("check-inventory-v2")).toBe(
+        "check-inventory-v2",
+      );
+    });
+
+    it("should reject invalid function names", () => {
+      expect(() => parseFunctionName("")).toThrow(InvalidArgumentError);
+      expect(() => parseFunctionName("ValidateOrder")).toThrow(
+        /lowercase with hyphens/,
+      );
+      expect(() => parseFunctionName("validate order")).toThrow(
+        /lowercase with hyphens/,
+      );
+    });
+  });
+
+  describe("parseComponentSlot", () => {
+    it("should accept valid slots", () => {
+      expect(parseComponentSlot("header")).toBe("header");
+      expect(parseComponentSlot("main")).toBe("main");
+      expect(parseComponentSlot("sidebar")).toBe("sidebar");
+      expect(parseComponentSlot("footer")).toBe("footer");
+    });
+
+    it("should reject invalid slots", () => {
+      expect(() => parseComponentSlot("invalid")).toThrow(InvalidArgumentError);
+      expect(() => parseComponentSlot("")).toThrow(InvalidArgumentError);
+    });
+
+    it("should provide list of valid slots in error", () => {
+      try {
+        parseComponentSlot("invalid");
+      } catch (error) {
+        expect(error.message).toContain(
+          "Valid slots: header, footer, sidebar, main, checkout-summary, payment-method, shipping-method, customer-info, order-confirmation",
+        );
+      }
+    });
+  });
+
+  describe("parseFunctionInvocation", () => {
+    it("should accept valid invocations", () => {
+      expect(parseFunctionInvocation("request")).toBe("request");
+      expect(parseFunctionInvocation("response")).toBe("response");
+    });
+
+    it("should reject invalid invocations", () => {
+      expect(() => parseFunctionInvocation("invalid")).toThrow(
+        InvalidArgumentError,
+      );
+    });
+
+    it("should provide list of valid invocations in error", () => {
+      try {
+        parseFunctionInvocation("invalid");
+      } catch (error) {
+        expect(error.message).toContain("request");
+        expect(error.message).toContain("response");
+      }
+    });
+  });
+
+  describe("parseBooleanOption", () => {
+    it("should parse truthy values", () => {
+      expect(parseBooleanOption("true")).toBe(true);
+      expect(parseBooleanOption("TRUE")).toBe(true);
+      expect(parseBooleanOption("yes")).toBe(true);
+      expect(parseBooleanOption("y")).toBe(true);
+      expect(parseBooleanOption("1")).toBe(true);
+    });
+
+    it("should parse falsy values", () => {
+      expect(parseBooleanOption("false")).toBe(false);
+      expect(parseBooleanOption("FALSE")).toBe(false);
+      expect(parseBooleanOption("no")).toBe(false);
+      expect(parseBooleanOption("n")).toBe(false);
+      expect(parseBooleanOption("0")).toBe(false);
+    });
+
+    it("should reject invalid values", () => {
+      expect(() => parseBooleanOption("maybe")).toThrow(InvalidArgumentError);
+      expect(() => parseBooleanOption("")).toThrow(InvalidArgumentError);
+    });
+
+    it("should provide helpful error message", () => {
+      try {
+        parseBooleanOption("invalid");
+      } catch (error) {
+        expect(error.message).toContain("Use true/false, yes/no, or 1/0");
+      }
+    });
+  });
+
+  describe("parsePath", () => {
+    it("should accept valid paths", () => {
+      expect(parsePath("./components/header")).toBe("./components/header");
+      expect(parsePath("/absolute/path")).toBe("/absolute/path");
+      expect(parsePath("relative/path")).toBe("relative/path");
+    });
+
+    it("should reject empty paths", () => {
+      expect(() => parsePath("")).toThrow(InvalidArgumentError);
+      expect(() => parsePath("")).toThrow(/cannot be empty/);
+    });
+  });
+});

package/src/utils/__tests__/command-suggestions.test.ts

@@ -0,0 +1,185 @@
+import * as fs from "node:fs";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { CommandSuggestions } from "../command-suggestions";
+import type { CliConsole } from "../console";
+
+// Mock the fs module
+vi.mock("fs");
+
+describe("CommandSuggestions", () => {
+  let mockConsole: CliConsole;
+  let suggestions: CommandSuggestions;
+
+  beforeEach(() => {
+    // Create a mock console
+    mockConsole = {
+      log: vi.fn(),
+      error: vi.fn(),
+      warn: vi.fn(),
+      info: vi.fn(),
+      success: vi.fn(),
+      dim: vi.fn(),
+      bold: vi.fn(),
+      list: vi.fn(),
+      table: vi.fn(),
+      json: vi.fn(),
+      spinner: vi.fn(),
+      confirm: vi.fn(),
+      prompt: vi.fn(),
+      setOptions: vi.fn(),
+      group: vi.fn(),
+      groupEnd: vi.fn(),
+      separator: vi.fn(),
+      suggestions: vi.fn(),
+      debug: vi.fn(),
+      nextSteps: vi.fn(),
+    };
+    suggestions = new CommandSuggestions(mockConsole);
+    vi.clearAllMocks();
+
+    // Mock process.cwd
+    vi.spyOn(process, "cwd").mockReturnValue("/test/project");
+  });
+
+  describe("show", () => {
+    it("should show suggestions for component directory", () => {
+      // Mock component detection
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path.toString().includes("package.json")) return true;
+        if (path.toString().includes("meta.json")) return true;
+        if (path.toString().includes("index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ type: "component", name: "header-nav" }),
+      );
+
+      suggestions.show();
+
+      // Check context display
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("You're in a component directory: header-nav"),
+      );
+
+      // Check component commands
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Common commands for this component:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("validate"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("build"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("deploy"),
+      );
+
+      // Check tip
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Run 'ollieshop dev' to start developing"),
+      );
+    });
+
+    it("should show suggestions for function directory", () => {
+      // Mock function detection - ensure we ONLY return true for function files
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        const pathStr = path.toString();
+        // Check for function-specific files
+        const isFunctionFile =
+          pathStr.includes("package.json") ||
+          pathStr.includes("meta.json") ||
+          (pathStr.includes("index.ts") && !pathStr.includes("index.tsx"));
+        return isFunctionFile;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ type: "function", name: "validate-order" }),
+      );
+
+      suggestions.show();
+
+      // Check context display
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "You're in a function directory: validate-order",
+        ),
+      );
+
+      // Check function commands
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Common commands for this function:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("test"),
+      );
+
+      // Check tip
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Run 'ollieshop test' to test this function"),
+      );
+    });
+
+    it("should show suggestions for project root", () => {
+      // Mock project root detection
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path.toString().includes("components")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+
+      suggestions.show();
+
+      // Check context display
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("You're in the project root"),
+      );
+
+      // Check general commands
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Common commands:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("component create"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("function create"),
+      );
+
+      // Check tip
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "Navigate to a component with 'cd components/<name>'",
+        ),
+      );
+    });
+
+    it("should show recent commands for component", () => {
+      // Mock component detection
+      vi.mocked(fs.existsSync).mockImplementation((path) => {
+        if (path.toString().includes("package.json")) return true;
+        if (path.toString().includes("meta.json")) return true;
+        if (path.toString().includes("index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({ type: "component" }),
+      );
+
+      suggestions.show();
+
+      // Check recent commands section
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Recent commands:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("validate --fix"),
+      );
+    });
+  });
+});

package/src/utils/__tests__/console.test.ts

@@ -0,0 +1,192 @@
+import chalk from "chalk";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { Console } from "../console";
+
+// Mock chalk
+vi.mock("chalk", () => ({
+  default: {
+    green: vi.fn((str: string) => `[GREEN]${str}[/GREEN]`),
+    red: Object.assign(
+      vi.fn((str: string) => `[RED]${str}[/RED]`),
+      {
+        bold: vi.fn((str: string) => `[RED-BOLD]${str}[/RED-BOLD]`),
+      },
+    ),
+    yellow: vi.fn((str: string) => `[YELLOW]${str}[/YELLOW]`),
+    blue: Object.assign(
+      vi.fn((str: string) => `[BLUE]${str}[/BLUE]`),
+      {
+        bold: vi.fn((str: string) => `[BLUE-BOLD]${str}[/BLUE-BOLD]`),
+      },
+    ),
+    gray: vi.fn((str: string) => `[GRAY]${str}[/GRAY]`),
+    cyan: vi.fn((str: string) => `[CYAN]${str}[/CYAN]`),
+    level: 0,
+  },
+}));
+
+// Mock ora
+vi.mock("ora", () => ({
+  default: vi.fn(() => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+    stop: vi.fn().mockReturnThis(),
+  })),
+}));
+
+describe("Console Class", () => {
+  let consoleInstance: Console;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.spyOn(global.console, "log").mockImplementation(() => {
+      // Intentionally empty for test isolation
+    });
+    vi.spyOn(global.console, "error").mockImplementation(() => {
+      // Intentionally empty for test isolation
+    });
+    consoleInstance = new Console();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("setOptions", () => {
+    it("should set noColor option", () => {
+      // Act
+      consoleInstance.setOptions({ noColor: true });
+
+      // Assert
+      expect(chalk.level).toBe(0);
+    });
+  });
+
+  describe("success", () => {
+    it("should log success message in green", () => {
+      // Act
+      consoleInstance.success("Operation completed");
+
+      // Assert
+      expect(global.console.log).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "[BLUE-BOLD][ollie][/BLUE-BOLD] [GREEN]✓[/GREEN] [GREEN]Operation completed[/GREEN]",
+        ),
+      );
+    });
+  });
+
+  describe("error", () => {
+    it("should log error message in red", () => {
+      // Act
+      consoleInstance.error("Operation failed");
+
+      // Assert
+      expect(global.console.error).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "[BLUE-BOLD][ollie][/BLUE-BOLD] [RED]✗[/RED] [RED-BOLD]Operation failed[/RED-BOLD]",
+        ),
+      );
+    });
+  });
+
+  describe("info", () => {
+    it("should log info message", () => {
+      // Act
+      consoleInstance.info("Information message");
+
+      // Assert
+      expect(global.console.log).toHaveBeenCalledWith(
+        expect.stringContaining("Information message"),
+      );
+    });
+  });
+
+  describe("warn", () => {
+    it("should log warning message in yellow", () => {
+      // Act
+      consoleInstance.warn("Warning message");
+
+      // Assert
+      expect(global.console.warn).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "[BLUE-BOLD][ollie][/BLUE-BOLD] [YELLOW]⚠[/YELLOW] [YELLOW]Warning message[/YELLOW]",
+        ),
+      );
+    });
+  });
+
+  describe("hint", () => {
+    it("should log hint message in gray", () => {
+      // Act
+      consoleInstance.hint("Hint message");
+
+      // Assert
+      expect(global.console.log).toHaveBeenCalledWith(
+        expect.stringContaining("[GRAY]Hint message[/GRAY]"),
+      );
+    });
+  });
+
+  describe("spinner", () => {
+    it("should create and return a spinner", () => {
+      // Act
+      const spinner = consoleInstance.spinner("Loading...");
+
+      // Assert
+      expect(spinner).toBeDefined();
+      expect(spinner.start).toBeDefined();
+    });
+  });
+
+  describe("quiet mode", () => {
+    it("should not log messages when quiet mode is enabled", () => {
+      // Arrange
+      consoleInstance.setOptions({ quiet: true });
+
+      // Act
+      consoleInstance.info("Should not appear");
+      consoleInstance.success("Should not appear");
+      consoleInstance.warn("Should not appear");
+
+      // Assert
+      expect(global.console.log).not.toHaveBeenCalled();
+    });
+
+    it("should still log errors in quiet mode", () => {
+      // Arrange
+      consoleInstance.setOptions({ quiet: true });
+
+      // Act
+      consoleInstance.error("Error should appear");
+
+      // Assert
+      expect(global.console.error).toHaveBeenCalled();
+    });
+  });
+
+  describe("verbose mode", () => {
+    it("should log debug messages when verbose mode is enabled", () => {
+      // Arrange
+      consoleInstance.setOptions({ verbose: true });
+
+      // Act
+      consoleInstance.debug("Debug message");
+
+      // Assert
+      expect(global.console.log).toHaveBeenCalledWith(
+        expect.stringContaining("[GRAY]Debug message[/GRAY]"),
+      );
+    });
+
+    it("should not log debug messages when verbose mode is disabled", () => {
+      // Act
+      consoleInstance.debug("Debug message");
+
+      // Assert
+      expect(global.console.log).not.toHaveBeenCalled();
+    });
+  });
+});