@ollie-shop/cli 0.1.3 → 0.3.0

package/src/utils/__tests__/context-detector.test.ts

@@ -0,0 +1,258 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { detectProjectContext, getContextualPath } from "../context-detector";
+
+// Mock fs module
+vi.mock("fs", () => ({
+  existsSync: vi.fn(),
+  readFileSync: vi.fn(),
+  statSync: vi.fn(),
+}));
+
+describe("Context Detector", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  describe("detectProjectContext", () => {
+    it("should detect component directory by meta.json", () => {
+      const mockPath = "/project/components/header";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({
+          type: "component",
+          name: "header",
+        }),
+      );
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("component");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBe("header");
+    });
+
+    it("should detect component directory by index.tsx", () => {
+      const mockPath = "/project/components/footer";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        if (p === path.join(mockPath, "index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue("{}");
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("component");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBe("footer");
+    });
+
+    it("should detect function directory by meta.json", () => {
+      const mockPath = "/project/functions/validate-order";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue(
+        JSON.stringify({
+          type: "function",
+          name: "validate-order",
+        }),
+      );
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("function");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBe("validate-order");
+    });
+
+    it("should detect function directory by index.ts", () => {
+      const mockPath = "/project/functions/process-payment";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        if (p === path.join(mockPath, "index.ts")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue("{}");
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("function");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBe("process-payment");
+    });
+
+    it("should detect project root with components directory", () => {
+      const mockPath = "/project";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "components")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("unknown");
+      expect(result.path).toBe(mockPath);
+      expect(result.parentPath).toBe(mockPath);
+    });
+
+    it("should detect when inside components/name directory structure", () => {
+      const mockPath = "/project/components/my-component";
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("component");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBe("my-component");
+    });
+
+    it("should detect when inside functions/name directory structure", () => {
+      const mockPath = "/project/functions/my-function";
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("function");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBe("my-function");
+    });
+
+    it("should return unknown for unrecognized directory", () => {
+      const mockPath = "/some/random/path";
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      const result = detectProjectContext(mockPath);
+
+      expect(result.type).toBe("unknown");
+      expect(result.path).toBe(mockPath);
+      expect(result.name).toBeUndefined();
+    });
+
+    it("should handle invalid meta.json gracefully", () => {
+      const mockPath = "/project/components/broken";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        if (p === path.join(mockPath, "index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue("invalid json");
+
+      const result = detectProjectContext(mockPath);
+
+      // Should fall back to file detection
+      expect(result.type).toBe("component");
+      expect(result.path).toBe(mockPath);
+    });
+  });
+
+  describe("getContextualPath", () => {
+    it("should return explicit path when provided", () => {
+      const explicitPath = "/explicit/path";
+      const result = getContextualPath(explicitPath, "component");
+
+      expect(result).toBe(explicitPath);
+    });
+
+    it("should return current directory when in matching context", () => {
+      const mockPath = "/project/components/header";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        if (p === path.join(mockPath, "index.tsx")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue("{}");
+
+      // Mock process.cwd to return our test path
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue(mockPath);
+
+      const result = getContextualPath(undefined, "component");
+
+      expect(result).toBe(mockPath);
+
+      process.cwd = originalCwd;
+    });
+
+    it("should throw error when in parent directory", () => {
+      const mockPath = "/project";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "components")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.statSync).mockReturnValue({
+        isDirectory: () => true,
+      } as fs.Stats);
+
+      // Mock process.cwd to return our test path
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue(mockPath);
+
+      expect(() => getContextualPath(undefined, "component")).toThrowError(
+        /No component found in current directory/,
+      );
+
+      process.cwd = originalCwd;
+    });
+
+    it("should throw error when in wrong context type", () => {
+      const mockPath = "/project/functions/my-function";
+      vi.mocked(fs.existsSync).mockImplementation((p) => {
+        if (p === path.join(mockPath, "package.json")) return true;
+        if (p === path.join(mockPath, "meta.json")) return true;
+        if (p === path.join(mockPath, "index.ts")) return true;
+        return false;
+      });
+
+      vi.mocked(fs.readFileSync).mockReturnValue("{}");
+
+      // Mock process.cwd to return our test path
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue(mockPath);
+
+      expect(() => getContextualPath(undefined, "component")).toThrowError(
+        /Current directory appears to be a function, not a component/,
+      );
+
+      process.cwd = originalCwd;
+    });
+
+    it("should return current directory for unknown context", () => {
+      const mockPath = "/some/random/path";
+      vi.mocked(fs.existsSync).mockReturnValue(false);
+
+      // Mock process.cwd to return our test path
+      const originalCwd = process.cwd;
+      process.cwd = vi.fn().mockReturnValue(mockPath);
+
+      const result = getContextualPath(undefined, "component");
+
+      expect(result).toBe(mockPath);
+
+      process.cwd = originalCwd;
+    });
+  });
+});

package/src/utils/__tests__/enhanced-error-handler.test.ts

@@ -0,0 +1,137 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { CliConsole } from "../console";
+import {
+  EnhancedErrorHandler,
+  createContextualError,
+} from "../enhanced-error-handler";
+
+describe("EnhancedErrorHandler", () => {
+  let mockConsole: CliConsole;
+  let handler: EnhancedErrorHandler;
+
+  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(),
+    };
+    handler = new EnhancedErrorHandler(mockConsole);
+    vi.clearAllMocks();
+  });
+
+  describe("handle", () => {
+    it("should display basic error message", () => {
+      const error = new Error("Something went wrong");
+      handler.handle(error);
+
+      expect(mockConsole.error).toHaveBeenCalledWith(
+        "\n❌ Something went wrong\n",
+      );
+    });
+
+    it("should show recovery suggestions for ENOENT errors", () => {
+      const error = createContextualError("File not found", "ENOENT");
+      handler.handle(error);
+
+      expect(mockConsole.warn).toHaveBeenCalledWith("💡 Possible solutions:\n");
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Check if the path exists"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("--path"),
+      );
+    });
+
+    it("should show recovery suggestions for ECONNREFUSED errors", () => {
+      const error = createContextualError("Connection failed", "ECONNREFUSED");
+      handler.handle(error);
+
+      expect(mockConsole.warn).toHaveBeenCalledWith("💡 Possible solutions:\n");
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Check your internet connection"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("ollieshop login"),
+      );
+    });
+
+    it("should show recovery suggestions for component exists errors", () => {
+      const error = new Error("Component header-nav already exists");
+      handler.handle(error, { name: "header-nav" });
+
+      expect(mockConsole.warn).toHaveBeenCalledWith("💡 Possible solutions:\n");
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Use a different name"),
+      );
+    });
+
+    it("should display contextual information", () => {
+      const error = new Error("Test error");
+      handler.handle(error, { path: "/test/path" });
+
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("📍 Context:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Current directory:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("Target path: /test/path"),
+      );
+    });
+
+    it("should suggest similar commands for command errors", () => {
+      const error = createContextualError(
+        "Unknown command",
+        "COMMAND_NOT_FOUND",
+        {
+          attemptedCommand: "component crate",
+        },
+      );
+      handler.handle(error, { attemptedCommand: "component crate" });
+
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("💡 Did you mean:"),
+      );
+      expect(mockConsole.log).toHaveBeenCalledWith(
+        expect.stringContaining("component create"),
+      );
+    });
+  });
+
+  describe("createContextualError", () => {
+    it("should create error with code", () => {
+      const error = createContextualError("Test error", "TEST_CODE");
+
+      expect(error.message).toBe("Test error");
+      expect((error as Error & { code?: string }).code).toBe("TEST_CODE");
+    });
+
+    it("should create error with context", () => {
+      const context = { foo: "bar" };
+      const error = createContextualError("Test error", undefined, context);
+
+      expect(
+        (error as Error & { context?: Record<string, unknown> }).context,
+      ).toEqual(context);
+    });
+  });
+});

package/src/utils/__tests__/error-handler.test.ts

@@ -0,0 +1,107 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { console as cliConsole } from "../console";
+import { handleError } from "../error-handler";
+import { CommandError, ValidationError } from "../errors";
+
+// Mock console with all required methods
+vi.mock("../console", () => ({
+  console: {
+    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(),
+  },
+}));
+
+// Mock process.exit to follow CLI testing best practices
+const _mockExit = vi.spyOn(process, "exit").mockImplementation((code) => {
+  throw new Error(`process.exit(${code})`);
+});
+
+describe("Error Handler", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    process.env.DEBUG = undefined;
+  });
+
+  it("should handle CommandError with specific message", () => {
+    // Arrange
+    const error = new CommandError("Command failed", "COMMAND_FAILED");
+
+    // Act & Assert
+    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
+    expect(cliConsole.error).toHaveBeenCalledWith("\nCommand failed");
+  });
+
+  it("should handle ValidationError with details", () => {
+    // Arrange
+    const error = new ValidationError("Validation failed", [
+      { field: "name", message: "Name is required" },
+      { field: "version", message: "Invalid version format" },
+    ]);
+
+    // Act & Assert
+    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
+    expect(cliConsole.error).toHaveBeenCalledWith("\nValidation failed");
+    expect(cliConsole.dim).toHaveBeenCalledWith("\nContext:");
+    expect(cliConsole.dim).toHaveBeenCalledWith("  fields:");
+    expect(cliConsole.dim).toHaveBeenCalledWith("    name: Name is required");
+    expect(cliConsole.dim).toHaveBeenCalledWith(
+      "    version: Invalid version format",
+    );
+  });
+
+  it("should handle generic Error", () => {
+    // Arrange
+    const error = new Error("Something went wrong");
+
+    // Act & Assert
+    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
+    // Enhanced error handler formats with emoji
+    expect(cliConsole.error).toHaveBeenCalledWith(
+      "\n❌ Something went wrong\n",
+    );
+  });
+
+  it("should handle non-Error objects", () => {
+    // Arrange
+    const error = "String error";
+
+    // Act & Assert
+    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
+    expect(cliConsole.error).toHaveBeenCalledWith(
+      "\nAn unexpected error occurred",
+    );
+    expect(cliConsole.dim).toHaveBeenCalledWith("String error");
+  });
+
+  it("should show debug information when NODE_ENV is development", () => {
+    // Arrange
+    process.env.DEBUG = "1";
+    const error = new Error("Debug error");
+    error.stack = "Error: Debug error\n    at test.js:1:1";
+
+    // Act & Assert
+    expect(() => handleError(error)).toThrow(/process\.exit.*1/);
+    // Enhanced error handler shows context instead of stack trace in dim
+    expect(cliConsole.log).toHaveBeenCalledWith(
+      expect.stringContaining("📍 Context:"),
+    );
+  });
+});

package/src/utils/__tests__/rich-progress.test.ts

@@ -0,0 +1,170 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { RichProgressReporter, SimpleProgressReporter } from "../rich-progress";
+
+// Mock cli-progress
+vi.mock("cli-progress", () => {
+  const mockBar = {
+    update: vi.fn(),
+  };
+
+  const mockMultiBar = {
+    create: vi.fn().mockReturnValue(mockBar),
+    stop: vi.fn(),
+  };
+
+  return {
+    default: {
+      MultiBar: vi.fn(() => mockMultiBar),
+      Presets: {
+        shades_classic: {},
+      },
+    },
+  };
+});
+
+// Mock ora
+vi.mock("ora", () => ({
+  default: vi.fn(() => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn(),
+    fail: vi.fn(),
+    text: "",
+  })),
+}));
+
+describe("RichProgressReporter", () => {
+  let reporter: RichProgressReporter;
+  let consoleLogSpy: ReturnType<typeof vi.spyOn>;
+
+  beforeEach(() => {
+    // Skip creating the actual reporter to avoid mocking issues
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {
+      // Intentionally empty for test isolation
+    });
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    consoleLogSpy.mockRestore();
+  });
+
+  it("should start progress tracking", () => {
+    reporter = new RichProgressReporter();
+    reporter.start();
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("🚀 Starting deployment..."),
+    );
+  });
+
+  it("should update progress with build status", () => {
+    reporter = new RichProgressReporter();
+
+    const progress = {
+      phase: "build",
+      message: "Bundling files...",
+      progress: 0.5,
+    };
+
+    // Just verify no errors
+    expect(() => reporter.updateProgress(progress)).not.toThrow();
+  });
+
+  it("should show success summary", () => {
+    // Test just the summary method
+    const reporter = new RichProgressReporter();
+    // Access private method for testing
+    const reporterWithPrivate = reporter as unknown as {
+      showSuccessSummary(): void;
+    };
+    reporterWithPrivate.showSuccessSummary();
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("✅ Deployment completed successfully!"),
+    );
+  });
+
+  it("should show failure message", () => {
+    // Create a minimal test that doesn't rely on bars
+    const reporter = new RichProgressReporter();
+    // Access private properties for testing
+    const reporterWithPrivate = reporter as unknown as {
+      multibar: { stop: () => void };
+      bars: Map<string, unknown>;
+    };
+    reporterWithPrivate.multibar = { stop: vi.fn() };
+    reporterWithPrivate.bars = new Map(); // Empty map
+
+    reporter.stop(false);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("❌ Deployment failed"),
+    );
+  });
+
+  it("should display build stats when available", () => {
+    const reporter = new RichProgressReporter();
+
+    // Set stats directly for testing
+    const reporterWithPrivate = reporter as unknown as {
+      stats: { bundleSize?: number; gzippedSize?: number };
+    };
+    reporterWithPrivate.stats = {
+      bundleSize: 150000,
+      gzippedSize: 50000,
+    };
+
+    // Call the summary method
+    const reporterWithSummary = reporter as unknown as {
+      showSuccessSummary(): void;
+    };
+    reporterWithSummary.showSuccessSummary();
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("📊 Build Stats:"),
+    );
+    expect(consoleLogSpy).toHaveBeenCalledWith(
+      expect.stringContaining("Bundle size: 146.5KB"),
+    );
+  });
+});
+
+describe("SimpleProgressReporter", () => {
+  let reporter: SimpleProgressReporter;
+
+  beforeEach(() => {
+    reporter = new SimpleProgressReporter("Testing...");
+    vi.clearAllMocks();
+  });
+
+  it("should start spinner", () => {
+    reporter.start();
+
+    // Spinner is mocked, verify no errors
+    expect(() => reporter.start()).not.toThrow();
+  });
+
+  it("should update message", () => {
+    reporter.start();
+    reporter.update("New message");
+
+    // Update is mocked, verify no errors
+    expect(() => reporter.update("test")).not.toThrow();
+  });
+
+  it("should succeed with message", () => {
+    reporter.start();
+    reporter.succeed("Success!");
+
+    // Success is mocked, verify no errors
+    expect(() => reporter.succeed()).not.toThrow();
+  });
+
+  it("should fail with message", () => {
+    reporter.start();
+    reporter.fail("Failed!");
+
+    // Fail is mocked, verify no errors
+    expect(() => reporter.fail()).not.toThrow();
+  });
+});