@ollie-shop/cli 0.3.4 → 1.0.1

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

@@ -1,286 +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 { 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",
-        "123e4567-e89b-12d3-a456-426614174000",
-      ]);
-
-      // 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

@@ -1,414 +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 { 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();
-    });
-  });
-});