ui-thing 0.2.6 → 0.2.7

package/tests/utils/installPackages.test.ts

@@ -0,0 +1,114 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { installPackages } from "../../src/utils/installPackages";
+
+// Mock execa at the module level
+vi.mock("execa", () => ({
+  execa: vi.fn(),
+}));
+
+describe("utils/installPackages", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should install dependencies with npm", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", ["vue", "axios"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "vue", "axios"]);
+    expect(mockExeca).toHaveBeenCalledWith(["npx -y nuxt prepare"]);
+  });
+
+  it("should install dev dependencies with npm", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", undefined, ["typescript", "vitest"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "-D", "typescript", "vitest"]);
+  });
+
+  it("should install both dependencies and dev dependencies", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", ["vue"], ["typescript"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "vue"]);
+    expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "-D", "typescript"]);
+  });
+
+  it("should use yarn add instead of install", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("yarn", ["vue"], ["typescript"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("yarn", ["add", "vue"]);
+    expect(mockExeca).toHaveBeenCalledWith("yarn", ["add", "-D", "typescript"]);
+  });
+
+  it("should handle string input for deps", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", "vue");
+
+    expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "vue"]);
+  });
+
+  it("should handle string input for devDeps", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", undefined, "typescript");
+
+    expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "-D", "typescript"]);
+  });
+
+  it("should work with pnpm", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("pnpm", ["vue"], ["typescript"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("pnpm", ["install", "vue"]);
+    expect(mockExeca).toHaveBeenCalledWith("pnpm", ["install", "-D", "typescript"]);
+  });
+
+  it("should run nuxt prepare after installation", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", ["vue"]);
+
+    expect(mockExeca).toHaveBeenCalledWith(["npx -y nuxt prepare"]);
+  });
+
+  it("should skip installing empty dependencies", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("npm", [], []);
+
+    // Should only call nuxt prepare
+    expect(mockExeca).toHaveBeenCalledTimes(1);
+    expect(mockExeca).toHaveBeenCalledWith(["npx -y nuxt prepare"]);
+  });
+});

package/tests/utils/printFancyBoxMessage.test.ts

@@ -0,0 +1,66 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { printFancyBoxMessage } from "../../src/utils/printFancyBoxMessage";
+
+describe("utils/printFancyBoxMessage", () => {
+  let consoleLogSpy: any;
+
+  beforeEach(() => {
+    consoleLogSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should print a fancy box message with title", () => {
+    printFancyBoxMessage("Test Title");
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+    const output = consoleLogSpy.mock.calls[0][0];
+    // ASCII art contains the title but not as plain text
+    expect(output).toBeTruthy();
+    expect(typeof output).toBe("string");
+  });
+
+  it("should print a fancy box message with title and description", () => {
+    printFancyBoxMessage("Test Title", "Test description");
+
+    // Should be called at least once (box is always printed)
+    expect(consoleLogSpy).toHaveBeenCalled();
+    const lastCall = consoleLogSpy.mock.calls[consoleLogSpy.mock.calls.length - 1][0];
+    expect(lastCall).toContain("Test description");
+    printFancyBoxMessage("Test", undefined, {
+      box: { borderColor: "red", borderStyle: "double" },
+    });
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+  });
+
+  it("should accept custom figlet font", () => {
+    printFancyBoxMessage("Test", undefined, {
+      figletFont: "Banner",
+    });
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+  });
+
+  it("should handle empty title gracefully", () => {
+    printFancyBoxMessage("");
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+  });
+
+  it("should handle special characters in title", () => {
+    printFancyBoxMessage("Test!@#$%");
+
+    expect(consoleLogSpy).toHaveBeenCalled();
+  });
+
+  it("should only print box when no description provided", () => {
+    printFancyBoxMessage("Test");
+
+    expect(consoleLogSpy).toHaveBeenCalledTimes(1);
+  });
+});

package/tests/utils/promptForComponents.test.ts

@@ -0,0 +1,94 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { Component } from "../../src/types";
+import { promptUserForComponents } from "../../src/utils/promptForComponents";
+
+// Mock prompts
+vi.mock("prompts");
+
+describe("utils/promptForComponents", () => {
+  const mockComponents: Component[] = [
+    {
+      name: "Button",
+      value: "button",
+      files: [],
+      utils: [],
+      composables: [],
+      plugins: [],
+    },
+    {
+      name: "Input",
+      value: "input",
+      files: [],
+      utils: [],
+      composables: [],
+      plugins: [],
+    },
+    {
+      name: "Card",
+      value: "card",
+      files: [],
+      utils: [],
+      composables: [],
+      plugins: [],
+    },
+  ];
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should return all component values when all is true", async () => {
+    const result = await promptUserForComponents(true, mockComponents);
+
+    expect(result).toEqual(["button", "input", "card"]);
+    expect(result).toHaveLength(3);
+  });
+
+  it("should prompt user for selection when all is false", async () => {
+    const prompts = await import("prompts");
+    vi.mocked(prompts.default).mockResolvedValue({ components: ["button", "input"] });
+
+    const result = await promptUserForComponents(false, mockComponents);
+
+    expect(result).toEqual(["button", "input"]);
+    expect(prompts.default).toHaveBeenCalled();
+  });
+
+  it("should return empty array when user cancels selection", async () => {
+    const prompts = await import("prompts");
+    vi.mocked(prompts.default).mockResolvedValue({ components: undefined });
+
+    const result = await promptUserForComponents(false, mockComponents);
+
+    expect(result).toBeUndefined();
+  });
+
+  it("should handle empty components list", async () => {
+    const result = await promptUserForComponents(true, []);
+
+    expect(result).toEqual([]);
+  });
+
+  it("should pass correct choices to prompts", async () => {
+    const prompts = await import("prompts");
+    vi.mocked(prompts.default).mockResolvedValue({ components: [] });
+
+    await promptUserForComponents(false, mockComponents);
+
+    expect(prompts.default).toHaveBeenCalledWith({
+      type: "autocompleteMultiselect",
+      name: "components",
+      message: "Select the components you want to add",
+      choices: [
+        { title: "Button", value: "button" },
+        { title: "Input", value: "input" },
+        { title: "Card", value: "card" },
+      ],
+    });
+  });
+});

package/tests/utils/writeFile.test.ts

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import * as fileExistsModule from "../../src/utils/fileExists";
+import { writeFile } from "../../src/utils/writeFile";
+
+describe("utils/writeFile", () => {
+  const mockFilePath = "/test/dir/file.txt";
+  const mockContent = "test content";
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should create directory and write file when file does not exist", async () => {
+    // Mock fileExists to return false
+    vi.spyOn(fileExistsModule, "fileExists").mockResolvedValue(false);
+    vi.spyOn(fs, "existsSync").mockReturnValue(false);
+    vi.spyOn(fs, "mkdirSync").mockImplementation(() => undefined);
+    vi.spyOn(fs, "writeFileSync").mockImplementation(() => {});
+
+    await writeFile(mockFilePath, mockContent);
+
+    expect(fileExistsModule.fileExists).toHaveBeenCalledWith(mockFilePath);
+    expect(fs.existsSync).toHaveBeenCalledWith(path.dirname(mockFilePath));
+    expect(fs.mkdirSync).toHaveBeenCalledWith(path.dirname(mockFilePath), { recursive: true });
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockContent);
+  });
+
+  it("should write file when file already exists", async () => {
+    vi.spyOn(fileExistsModule, "fileExists").mockResolvedValue(true);
+    vi.spyOn(fs, "writeFileSync").mockImplementation(() => {});
+
+    await writeFile(mockFilePath, mockContent);
+
+    expect(fileExistsModule.fileExists).toHaveBeenCalledWith(mockFilePath);
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockContent);
+  });
+
+  it("should not create directory if it already exists", async () => {
+    vi.spyOn(fileExistsModule, "fileExists").mockResolvedValue(false);
+    vi.spyOn(fs, "existsSync").mockReturnValue(true);
+    const mkdirSpy = vi.spyOn(fs, "mkdirSync").mockImplementation(() => undefined);
+    vi.spyOn(fs, "writeFileSync").mockImplementation(() => {});
+
+    await writeFile(mockFilePath, mockContent);
+
+    expect(mkdirSpy).not.toHaveBeenCalled();
+    expect(fs.writeFileSync).toHaveBeenCalledWith(mockFilePath, mockContent);
+  });
+});

package/vite.config.ts

@@ -2,8 +2,22 @@ import { defineConfig } from "vitest/config";
 
 export default defineConfig({
   test: {
+    globals: true,
+    environment: "node",
     coverage: {
       provider: "v8",
+      reporter: ["text", "json", "html"],
+      exclude: [
+        "node_modules/",
+        "dist/",
+        "tests/",
+        "**/*.test.ts",
+        "**/*.config.ts",
+        "**/types.ts",
+      ],
     },
+    mockReset: true,
+    restoreMocks: true,
+    clearMocks: true,
   },
 });