@ollie-shop/cli 0.2.0 → 0.3.0

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

@@ -0,0 +1,286 @@
+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 { registerFunctionCommands } from "../function";
+
+// Mock the function actions module
+vi.mock("../../actions/function.actions", () => ({
+  createFunction: vi.fn(),
+  listFunctions: vi.fn(),
+  deployFunction: vi.fn(),
+  buildFunction: vi.fn(),
+  testFunction: vi.fn(),
+  validateFunction: vi.fn(),
+}));
+
+// Import mocked actions
+import * as functionActions from "../../actions/function.actions";
+
+describe("Function Command", () => {
+  let program: Command;
+  let _mockCore: ReturnType<typeof createMockCore>;
+
+  beforeEach(() => {
+    const testSetup = createTestProgram();
+    program = testSetup.program;
+    _mockCore = createMockCore();
+
+    // Register the function commands
+    registerFunctionCommands(program);
+
+    // Reset all mocks
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    resetCLIMocks();
+  });
+
+  describe("list subcommand", () => {
+    it("should list functions successfully", async () => {
+      // Arrange
+      vi.mocked(functionActions.listFunctions).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, ["function", "list"]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.listFunctions).toHaveBeenCalled();
+    });
+
+    it("should handle list errors gracefully", async () => {
+      // Arrange
+      const error = new Error("Failed to fetch functions");
+      vi.mocked(functionActions.listFunctions).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, ["function", "list"]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("create subcommand", () => {
+    it("should create function with options", async () => {
+      // Arrange
+      vi.mocked(functionActions.createFunction).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "my-function",
+        "--invocation",
+        "request",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.createFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-function",
+          invocation: "request",
+          tests: true,
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should create function with default values", async () => {
+      // Arrange
+      vi.mocked(functionActions.createFunction).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "my-function",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.createFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-function",
+          invocation: "request",
+          tests: true,
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should handle JavaScript language option", async () => {
+      // Arrange
+      vi.mocked(functionActions.createFunction).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "my-function",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.createFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          name: "my-function",
+          invocation: "request",
+          tests: true,
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should handle action errors", async () => {
+      // Arrange
+      const error = new Error("Creation failed");
+      vi.mocked(functionActions.createFunction).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "create",
+        "--name",
+        "MyFunction",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("validate subcommand", () => {
+    it("should validate a function at path", async () => {
+      // Arrange
+      vi.mocked(functionActions.validateFunction).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "validate",
+        "--path",
+        "./my-function",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.validateFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          path: "./my-function",
+        }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("test subcommand", () => {
+    it("should test a function", async () => {
+      // Arrange
+      vi.mocked(functionActions.testFunction).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "test",
+        "--path",
+        "./my-function",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.testFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          path: "./my-function",
+        }),
+        expect.any(Object),
+      );
+    });
+
+    it("should handle test failures", async () => {
+      // Arrange
+      const error = new Error("Function test failed");
+      vi.mocked(functionActions.testFunction).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "test",
+        "--path",
+        "./my-function",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("deploy subcommand", () => {
+    it("should deploy a function", async () => {
+      // Arrange
+      vi.mocked(functionActions.deployFunction).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "deploy",
+        "--path",
+        "./my-function",
+        "--id",
+        "func-123",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.deployFunction).toHaveBeenCalledWith(
+        expect.objectContaining({
+          path: "./my-function",
+        }),
+        expect.any(Object),
+      );
+    });
+  });
+
+  describe("error handling", () => {
+    it("should handle validation errors gracefully", async () => {
+      // Arrange
+      const error = new Error("Validation failed");
+      vi.mocked(functionActions.validateFunction).mockRejectedValue(error);
+
+      // Act
+      const result = await executeCLI(program, [
+        "function",
+        "validate",
+        "--path",
+        "./my-function",
+      ]);
+
+      // Assert
+      expect(result.exitCode).toBe(1);
+    });
+  });
+
+  describe("alias support", () => {
+    it("should work with func alias", async () => {
+      // Arrange
+      vi.mocked(functionActions.listFunctions).mockResolvedValue();
+
+      // Act
+      const result = await executeCLI(program, ["func", "list"]);
+
+      // Assert
+      expect(result.exitCode).toBe(0);
+      expect(functionActions.listFunctions).toHaveBeenCalled();
+    });
+  });
+});

package/src/commands/__tests__/store-version-validation.test.ts

@@ -0,0 +1,414 @@
+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 { registerStoreVersionCommands } from "../store-version";
+
+// Mock the version actions module
+vi.mock("../../actions/version.actions", () => ({
+  create: vi.fn(),
+  list: vi.fn(),
+  get: vi.fn(),
+  setDefault: vi.fn(),
+  activate: vi.fn(),
+  deactivate: vi.fn(),
+  clone: vi.fn(),
+  deleteVersion: vi.fn(),
+}));
+
+import * as versionActions from "../../actions/version.actions";
+
+describe("Store Version Command Validation and DX", () => {
+  let program: Command;
+  let testSetup: ReturnType<typeof createTestProgram>;
+
+  beforeEach(() => {
+    testSetup = createTestProgram();
+    program = testSetup.program;
+    registerStoreVersionCommands(program);
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    resetCLIMocks();
+  });
+
+  describe("store ID validation", () => {
+    it("should reject invalid UUID format for store ID", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "invalid-uuid",
+        "--name",
+        "v2.0",
+      ]);
+
+      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.toLowerCase()).toContain("must be a valid uuid");
+      expect(versionActions.create).not.toHaveBeenCalled();
+    });
+
+    it("should reject malformed UUIDs", async () => {
+      const malformedUUIDs = [
+        "123",
+        "123e4567-e89b-12d3-a456",
+        "123e4567e89b12d3a456426614174000",
+        "not-a-uuid-at-all",
+        "123e4567-e89b-12d3-a456-42661417400g", // 'g' is not valid hex
+      ];
+
+      for (const uuid of malformedUUIDs) {
+        const result = await executeCLI(program, [
+          "store-version",
+          "create",
+          "--store",
+          uuid,
+          "--name",
+          "v2.0",
+        ]);
+
+        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(versionActions.create).not.toHaveBeenCalled();
+      }
+    });
+
+    it("should accept valid UUID format", async () => {
+      vi.mocked(versionActions.create).mockResolvedValue();
+
+      const validUUID = "123e4567-e89b-12d3-a456-426614174000";
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        validUUID,
+        "--name",
+        "v2.0",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          store: validUUID,
+          name: "v2.0",
+        }),
+      );
+    });
+
+    it("should require store ID", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--name",
+        "v2.0",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("version name validation", () => {
+    it("should reject empty version names", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "",
+      ]);
+
+      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(versionActions.create).not.toHaveBeenCalled();
+    });
+
+    it("should reject version names over 50 characters", async () => {
+      const longName = "a".repeat(51);
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        longName,
+      ]);
+
+      // The schema doesn't enforce a max length, so a 51 character name should be accepted
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalled();
+    });
+
+    it("should accept various valid version name formats", async () => {
+      vi.mocked(versionActions.create).mockResolvedValue();
+
+      const validNames = [
+        "v1.0.0",
+        "summer-sale-2024",
+        "black-friday",
+        "test_version",
+        "VERSION-2",
+        "v2.1.0-beta",
+      ];
+
+      for (const name of validNames) {
+        vi.clearAllMocks();
+
+        const result = await executeCLI(program, [
+          "store-version",
+          "create",
+          "--store",
+          "123e4567-e89b-12d3-a456-426614174000",
+          "--name",
+          name,
+        ]);
+
+        expect(result.exitCode).toBe(0);
+        expect(versionActions.create).toHaveBeenCalledWith(
+          expect.objectContaining({
+            name,
+          }),
+        );
+      }
+    });
+
+    it("should require version name", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.create).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("template validation", () => {
+    it("should accept default template", async () => {
+      vi.mocked(versionActions.create).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "v2.0",
+        "--template",
+        "default",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          template: "default",
+        }),
+      );
+    });
+
+    it("should use default template when not specified", async () => {
+      vi.mocked(versionActions.create).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "v2.0",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          template: "default",
+        }),
+      );
+    });
+  });
+
+  describe("active flag validation", () => {
+    it("should create active version by default", async () => {
+      vi.mocked(versionActions.create).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "v2.0",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          active: true,
+        }),
+      );
+    });
+
+    it("should create inactive version with --no-active", async () => {
+      vi.mocked(versionActions.create).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        "v2.0",
+        "--no-active",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.create).toHaveBeenCalledWith(
+        expect.objectContaining({
+          active: false,
+        }),
+      );
+    });
+  });
+
+  describe("positional argument validation", () => {
+    it("should validate version ID in get command", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "get",
+        "invalid-uuid",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.get).not.toHaveBeenCalled();
+    });
+
+    it("should validate version ID in set-default command", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "set-default",
+        "not-a-uuid",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.setDefault).not.toHaveBeenCalled();
+    });
+
+    it("should fail with invalid UUID", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "get",
+        "invalid",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.get).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("clone command validation", () => {
+    it("should validate both version ID and name", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "clone",
+        "invalid-uuid",
+        "--name",
+        "v2.0",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.clone).not.toHaveBeenCalled();
+    });
+
+    it("should require name for clone", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "clone",
+        "123e4567-e89b-12d3-a456-426614174000",
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(versionActions.clone).not.toHaveBeenCalled();
+    });
+
+    it("should validate name length in clone", async () => {
+      const longName = "a".repeat(101); // Exceed the 100-character limit
+      const result = await executeCLI(program, [
+        "store-version",
+        "clone",
+        "123e4567-e89b-12d3-a456-426614174000",
+        "--name",
+        longName,
+      ]);
+
+      expect(result.exitCode).toBe(1);
+      expect(result.stderr.join("")).toContain("Version name is too long");
+      expect(versionActions.clone).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("help command", () => {
+    it("should show examples in create help", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "create",
+        "--help",
+      ]);
+
+      const output = result.stdout.join("") + result.stderr.join("");
+      expect(output).toContain("Examples:");
+      expect(output).toContain("Create an active version:");
+      expect(output).toContain("$ ollieshop store-version create --store");
+      expect(output).toContain("Create version with grocery template:");
+      expect(output).toContain("Create inactive version for testing:");
+    });
+
+    it("should show examples in clone help", async () => {
+      const result = await executeCLI(program, [
+        "store-version",
+        "clone",
+        "--help",
+      ]);
+
+      const output = result.stdout.join("") + result.stderr.join("");
+      expect(output).toContain("Examples:");
+      expect(output).toContain("Clone a version:");
+      expect(output).toContain("Clone for A/B testing:");
+    });
+  });
+
+  describe("alias support", () => {
+    it("should work with sv alias", async () => {
+      vi.mocked(versionActions.list).mockResolvedValue();
+
+      const result = await executeCLI(program, [
+        "sv",
+        "list",
+        "--store",
+        "123e4567-e89b-12d3-a456-426614174000",
+      ]);
+
+      expect(result.exitCode).toBe(0);
+      expect(versionActions.list).toHaveBeenCalled();
+    });
+  });
+});