@ollie-shop/cli 0.2.0 → 0.3.0

package/src/commands/__tests__/component.test.ts

@@ -0,0 +1,321 @@
+import type { Command } from "@commander-js/extra-typings";
+import {
+  createTestProgram,
+  executeCLI,
+  resetCLIMocks,
+} from "@tests/helpers/cli-test-helper";
+import { createMockCore } from "@tests/mocks";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { registerComponentCommands } from "../component";
+
+// Mock the component actions module
+vi.mock("../../actions/component.actions", () => ({
+  createComponent: vi.fn(),
+  listComponents: vi.fn(),
+  deployComponent: vi.fn(),
+  validateComponent: vi.fn(),
+  checkDeployStatus: vi.fn(),
+}));
+
+// Import mocked actions
+import * as componentActions from "../../actions/component.actions";
+
+describe("Component Command", () => {
+  let program: Command;
+
+  beforeEach(() => {
+    const testSetup = createTestProgram();
+    program = testSetup.program;
+    createMockCore();
+
+    // Register the component commands
+    registerComponentCommands(program);
+
+    // Reset all mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    resetCLIMocks();
+  });
+
+  describe("list subcommand", () => {
+    it("should list components successfully", async () => {
+      // Arrange
+      const components = [
+        { id: "1", name: "Header", slot: "header", active: true },
+        { id: "2", name: "Footer", slot: "footer", active: false },
+      ];
+      vi.mocked(componentActions.listComponents).mockResolvedValue(components);
+
+      // Act
+      const result = await executeCLI(program, ["component", "list"]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.listComponents).toHaveBeenCalled();
+    });
+
+    it("should handle list errors gracefully", async () => {
+      // Arrange
+      const error = new Error("Failed to fetch components");
+      vi.mocked(componentActions.listComponents).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, ["component", "list"]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("create subcommand", () => {
+    it("should create component with options", async () => {
+      // Arrange
+      vi.mocked(componentActions.createComponent).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--name",
+        "my-component",
+        "--slot",
+        "header",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.createComponent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-component",
+          slot: "header",
+          tests: true,
+          interactive: false,
+        }),
+        expect.any(Object), // console object
+      );
+    });
+
+    it("should create component with default values", async () => {
+      // Arrange
+      vi.mocked(componentActions.createComponent).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--name",
+        "my-component",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.createComponent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-component",
+          slot: "main",
+          tests: true,
+          interactive: false,
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should validate component name format - reject uppercase", async () => {
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--name",
+        "Test",
+        "--slot",
+        "header",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(componentActions.createComponent).not.toHaveBeenCalled();
+    });
+
+    it("should validate component name format - reject spaces", async () => {
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--name",
+        "test component",
+        "--slot",
+        "header",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(componentActions.createComponent).not.toHaveBeenCalled();
+    });
+
+    it("should validate component name format - accept valid kebab-case", async () => {
+      // Arrange
+      vi.mocked(componentActions.createComponent).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--name",
+        "test-component",
+        "--slot",
+        "header",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.createComponent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "test-component",
+          slot: "header",
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should require component name", async () => {
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--slot",
+        "header",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+      expect(componentActions.createComponent).not.toHaveBeenCalled();
+    });
+
+    it("should handle action errors", async () => {
+      // Arrange
+      const error = new Error("Creation failed");
+      vi.mocked(componentActions.createComponent).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "create",
+        "--name",
+        "test-component",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("deploy subcommand", () => {
+    it("should deploy a component by path", async () => {
+      // Arrange
+      vi.mocked(componentActions.deployComponent).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "deploy",
+        "--path",
+        "./my-component",
+        "--id",
+        "comp-123",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.deployComponent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          path: "./my-component",
+          wait: false,
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should deploy a component by ID", async () => {
+      // Arrange
+      vi.mocked(componentActions.deployComponent).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "deploy",
+        "--id",
+        "comp-123",
+        "--wait",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.deployComponent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          componentId: "comp-123",
+          wait: true,
+        }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("validate subcommand", () => {
+    it("should validate a component at path", async () => {
+      // Arrange
+      vi.mocked(componentActions.validateComponent).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "validate",
+        "--path",
+        "./my-component",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.validateComponent).toHaveBeenCalledWith(
+        expect.objectContaining({
+          path: "./my-component",
+        }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle validation errors gracefully", async () => {
+      // Arrange
+      const error = new Error("Validation failed");
+      vi.mocked(componentActions.validateComponent).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, [
+        "component",
+        "validate",
+        "--path",
+        "./my-component",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("alias support", () => {
+    it("should work with comp alias", async () => {
+      // Arrange
+      vi.mocked(componentActions.listComponents).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, ["comp", "list"]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(componentActions.listComponents).toHaveBeenCalled();
+    });
+  });
+});

package/src/commands/__tests__/function-validation.test.ts

@@ -0,0 +1,220 @@
+import type { Command } from "@commander-js/extra-typings";
+import {
+  createTestProgram,
+  executeCLI,
+  resetCLIMocks,
+} from "@tests/helpers/cli-test-helper";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { registerFunctionCommands } from "../function";
+
+// Mock the function actions module
+vi.mock("../../actions/function.actions", () => ({
+  createFunction: vi.fn(),
+  listFunctions: vi.fn(),
+  deployFunction: vi.fn(),
+  validateFunction: vi.fn(),
+  testFunction: vi.fn(),
+}));
+
+import * as functionActions from "../../actions/function.actions";
+
+describe("Function Command Validation and DX", () => {
+  let program: Command;
+  let testSetup: ReturnType<typeof createTestProgram>;
+
+  beforeEach(() => {
+    testSetup = createTestProgram();
+    program = testSetup.program;
+    registerFunctionCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    resetCLIMocks();
+  });
+
+  describe("name validation", () => {
+    it("should reject uppercase function names", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "ValidateOrder",
+      ]);
+
+      const consoleOutput = testSetup.mocks.console.error.mock.calls
+        .map((call) => call.join(" "))
+        .join("\n");
+
+      expect(result.exitCode).toBe(1);
+      expect(consoleOutput).toContain("Validation failed");
+      expect(consoleOutput).toContain("Must be lowercase with hyphens only");
+      expect(functionActions.createFunction).not.toHaveBeenCalled();
+    });
+
+    it("should reject function names with spaces", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "validate order",
+      ]);
+
+      const consoleOutput = testSetup.mocks.console.error.mock.calls
+        .map((call) => call.join(" "))
+        .join("\n");
+
+      expect(result.exitCode).toBe(1);
+      expect(consoleOutput).toContain("Validation failed");
+      expect(functionActions.createFunction).not.toHaveBeenCalled();
+    });
+
+    it("should reject function names with underscores", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "validate_order",
+      ]);
+
+      const consoleOutput = testSetup.mocks.console.error.mock.calls
+        .map((call) => call.join(" "))
+        .join("\n");
+
+      expect(result.exitCode).toBe(1);
+      expect(consoleOutput).toContain("Validation failed");
+      expect(functionActions.createFunction).not.toHaveBeenCalled();
+    });
+
+    it("should require function name", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--event",
+        "cart",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(functionActions.createFunction).not.toHaveBeenCalled();
+    });
+
+    it("should accept valid kebab-case names", async () => {
+      vi.mocked(functionActions.createFunction).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "validate-order",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.createFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "validate-order",
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should accept names with numbers", async () => {
+      vi.mocked(functionActions.createFunction).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "validate-order-v2",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.createFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "validate-order-v2",
+        }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("invocation validation", () => {
+    it("should reject invalid invocation types", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "test-func",
+        "--invocation",
+        "invalid",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.join("")).toContain("Invalid function invocation");
+      expect(result.stderr.join("")).toContain(
+        "Valid invocations: request, response",
+      );
+      expect(functionActions.createFunction).not.toHaveBeenCalled();
+    });
+
+    it("should accept all valid invocation types", async () => {
+      vi.mocked(functionActions.createFunction).mockResolvedValue();
+
+      const validInvocations = ["request", "response"];
+
+      for (const invocation of validInvocations) {
+        vi.clearAllMocks();
+
+        const result = await executeCLI(program, [
+          "function",
+          "create",
+          "--name",
+          "test-func",
+          "--invocation",
+          invocation,
+        ]);
+
+        expect(result.exitCode).toBe(0);
+        expect(functionActions.createFunction).toHaveBeenCalledWith(
+          expect.objectContaining({
+            invocation,
+          }),
+          expect.any(Object),
+        );
+      }
+    });
+  });
+
+  describe("help command", () => {
+    it("should show examples in help output", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--help",
+      ]);
+
+      const output = result.stdout.join("") + result.stderr.join("");
+      expect(output).toContain("Examples:");
+      expect(output).toContain("Create a function to validate orders:");
+      expect(output).toContain(
+        "$ ollieshop function create --name validate-order --event order --timing before",
+      );
+      expect(output).toContain("Create a discount function for cart:");
+      expect(output).toContain("Create a JavaScript function without tests:");
+    });
+  });
+
+  describe("unknown options", () => {
+    it("should provide helpful error for unknown options", async () => {
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "test",
+        "--unknown",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.join("")).toContain("unknown option '--unknown'");
+    });
+  });
+});