ui-thing 0.2.9 → 0.3.1

package/tests/commands/update.test.ts

@@ -0,0 +1,127 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+
+import { runUpdateCommand } from "../../src/commands/update";
+import { Component } from "../../src/types";
+
+vi.mock("../../src/utils/fetchComponents");
+vi.mock("../../src/utils/config");
+vi.mock("../../src/utils/fileExists");
+vi.mock("../../src/utils/writeFile");
+vi.mock("../../src/utils/logger");
+vi.mock("../../src/utils/printFancyBoxMessage");
+vi.mock("prompts");
+
+const mockComponents: Component[] = [
+  {
+    name: "Button",
+    value: "button",
+    files: [{ fileName: "Button.vue", dirPath: "app/components/Ui", fileContent: "<button />" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+  {
+    name: "Input",
+    value: "input",
+    files: [{ fileName: "Input.vue", dirPath: "app/components/Ui", fileContent: "<input />" }],
+    utils: [],
+    composables: [],
+    plugins: [],
+  },
+];
+
+describe("commands/update", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("should update a named component and overwrite its files", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { writeFile } = await import("../../src/utils/writeFile");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+
+    await runUpdateCommand(["button"]);
+
+    expect(vi.mocked(writeFile)).toHaveBeenCalledWith(
+      expect.stringContaining("Button.vue"),
+      "<button />"
+    );
+    expect(vi.mocked(logger.success)).toHaveBeenCalledWith("Updated: Button.vue");
+  });
+
+  it("should warn for unknown component names", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+
+    await runUpdateCommand(["nonexistent"]);
+
+    expect(vi.mocked(logger.warn)).toHaveBeenCalledWith(expect.stringContaining("nonexistent"));
+  });
+
+  it("should prompt for selection when no names given and components are installed", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { writeFile } = await import("../../src/utils/writeFile");
+    const prompts = await import("prompts");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValueOnce(true).mockResolvedValueOnce(false);
+    vi.mocked(prompts.default).mockResolvedValue({ selected: ["button"] });
+
+    await runUpdateCommand([]);
+
+    expect(vi.mocked(writeFile)).toHaveBeenCalledWith(
+      expect.stringContaining("Button.vue"),
+      "<button />"
+    );
+  });
+
+  it("should exit cleanly when user cancels the prompt", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { writeFile } = await import("../../src/utils/writeFile");
+    const prompts = await import("prompts");
+
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(true);
+    vi.mocked(prompts.default).mockResolvedValue({ selected: [] });
+
+    await runUpdateCommand([]);
+
+    expect(exitSpy).toHaveBeenCalledWith(0);
+    expect(vi.mocked(writeFile)).not.toHaveBeenCalled();
+  });
+
+  it("should show info message when no installed components found", async () => {
+    const { fetchComponents } = await import("../../src/utils/fetchComponents");
+    const { getUIConfig } = await import("../../src/utils/config");
+    const { fileExists } = await import("../../src/utils/fileExists");
+    const { logger } = await import("../../src/utils/logger");
+
+    vi.mocked(getUIConfig).mockResolvedValue({ componentsLocation: "app/components/Ui" } as any);
+    vi.mocked(fetchComponents).mockResolvedValue(mockComponents);
+    vi.mocked(fileExists).mockResolvedValue(false);
+
+    await runUpdateCommand([]);
+
+    expect(vi.mocked(logger.info)).toHaveBeenCalledWith("No installed components found.");
+  });
+});

package/tests/utils/fetchBlockCategories.test.ts

@@ -42,10 +42,22 @@ describe("utils/fetchBlockCategories", () => {
     delete process.env.BLOCK_CATEGORIES_API;
   });
 
-  it("should handle API errors", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/blocks/categories").reply(404);
 
-    await expect(fetchBlockCategories()).rejects.toThrow();
+    await fetchBlockCategories();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+    mockAxios.onGet("https://uithing.com/api/blocks/categories").networkError();
+
+    await fetchBlockCategories();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
   it("should return empty array when no categories exist", async () => {

package/tests/utils/fetchBlocks.test.ts

@@ -51,9 +51,21 @@ describe("utils/fetchBlocks", () => {
     delete process.env.BLOCKS_API;
   });
 
-  it("should handle API errors", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/blocks").reply(500);
 
-    await expect(fetchBlocks()).rejects.toThrow();
+    await fetchBlocks();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+    mockAxios.onGet("https://uithing.com/api/blocks").networkError();
+
+    await fetchBlocks();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 });

package/tests/utils/fetchComponents.test.ts

@@ -69,16 +69,22 @@ describe("utils/fetchComponents", () => {
     delete process.env.COMPONENTS_API;
   });
 
-  it("should handle API errors gracefully", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/components").reply(500);
 
-    await expect(fetchComponents()).rejects.toThrow();
+    await fetchComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
-  it("should handle network errors", async () => {
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/components").networkError();
 
-    await expect(fetchComponents()).rejects.toThrow();
+    await fetchComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 
   it("should return empty array when API returns no data", async () => {

package/tests/utils/fetchProseComponents.test.ts

@@ -54,9 +54,21 @@ describe("utils/fetchProseComponents", () => {
     delete process.env.PROSE_COMPONENTS_API;
   });
 
-  it("should handle API errors", async () => {
+  it("should call process.exit(1) on API error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
     mockAxios.onGet("https://uithing.com/api/prose").reply(500);
 
-    await expect(fetchProseComponents()).rejects.toThrow();
+    await fetchProseComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
+  });
+
+  it("should call process.exit(1) on network error", async () => {
+    const exitSpy = vi.spyOn(process, "exit").mockImplementation((() => {}) as any);
+    mockAxios.onGet("https://uithing.com/api/prose").networkError();
+
+    await fetchProseComponents();
+
+    expect(exitSpy).toHaveBeenCalledWith(1);
   });
 });

package/tests/utils/installPackages.test.ts

@@ -79,15 +79,48 @@ describe("utils/installPackages", () => {
     expect(mockExeca).toHaveBeenCalledWith("npm", ["install", "-D", "typescript"]);
   });
 
-  it("should work with pnpm", async () => {
+  it("should use pnpm add instead of install", 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"]);
+    expect(mockExeca).toHaveBeenCalledWith("pnpm", ["add", "vue"]);
+    expect(mockExeca).toHaveBeenCalledWith("pnpm", ["add", "-D", "typescript"]);
+  });
+
+  it("should use bun add instead of install", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("bun", ["vue"], ["typescript"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("bun", ["add", "vue"]);
+    expect(mockExeca).toHaveBeenCalledWith("bun", ["add", "-D", "typescript"]);
+  });
+
+  it("should use deno add with npm: prefix", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("deno", ["vue"], ["typescript"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("deno", ["add", "npm:vue"]);
+    expect(mockExeca).toHaveBeenCalledWith("deno", ["add", "--dev", "npm:typescript"]);
+    expect(mockExeca).toHaveBeenCalledWith("deno", ["run", "-A", "npm:nuxt", "prepare"]);
+  });
+
+  it("should not double-prefix packages already starting with npm:", async () => {
+    const { execa } = await import("execa");
+    const mockExeca = vi.mocked(execa);
+    mockExeca.mockResolvedValue({} as any);
+
+    await installPackages("deno", ["npm:vue"]);
+
+    expect(mockExeca).toHaveBeenCalledWith("deno", ["add", "npm:vue"]);
   });
 
   it("should run nuxt prepare after installation", async () => {