@ollie-shop/cli 0.3.4 → 1.0.1

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

@@ -1,318 +0,0 @@
-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(),
-}));
-
-// 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",
-        "123e4567-e89b-12d3-a456-426614174000",
-      ]);
-
-      // Assert
-      expect(result.exitCode).toBe(0);
-      expect(componentActions.deployComponent).toHaveBeenCalledWith(
-        expect.objectContaining({
-          path: "./my-component",
-          componentId: "123e4567-e89b-12d3-a456-426614174000",
-        }),
-        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",
-        "123e4567-e89b-12d3-a456-426614174000",
-      ]);
-
-      // Assert
-      expect(result.exitCode).toBe(0);
-      expect(componentActions.deployComponent).toHaveBeenCalledWith(
-        expect.objectContaining({
-          componentId: "123e4567-e89b-12d3-a456-426614174000",
-        }),
-        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

@@ -1,220 +0,0 @@
-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'");
-    });
-  });
-});