GearBox/tests/services/category.service.test.ts

import { describe, it, expect, beforeEach } from "bun:test";
import { createTestDb } from "../helpers/db.ts";
import {
  getAllCategories,
  createCategory,
  updateCategory,
  deleteCategory,
} from "../../src/server/services/category.service.ts";
import { createItem } from "../../src/server/services/item.service.ts";
import { items } from "../../src/db/schema.ts";
import { eq } from "drizzle-orm";

describe("Category Service", () => {
  let db: ReturnType<typeof createTestDb>;

  beforeEach(() => {
    db = createTestDb();
  });

  describe("createCategory", () => {
    it("creates with name and icon", () => {
      const cat = createCategory(db, { name: "Shelter", icon: "tent" });

      expect(cat).toBeDefined();
      expect(cat!.id).toBeGreaterThan(0);
      expect(cat!.name).toBe("Shelter");
      expect(cat!.icon).toBe("tent");
    });

    it("uses default icon if not provided", () => {
      const cat = createCategory(db, { name: "Cooking" });

      expect(cat).toBeDefined();
      expect(cat!.icon).toBe("package");
    });
  });

  describe("getAllCategories", () => {
    it("returns all categories", () => {
      createCategory(db, { name: "Shelter", icon: "tent" });
      createCategory(db, { name: "Cooking", icon: "cooking-pot" });

      const all = getAllCategories(db);
      // Includes seeded Uncategorized + 2 new
      expect(all.length).toBeGreaterThanOrEqual(3);
    });
  });

  describe("updateCategory", () => {
    it("renames category", () => {
      const cat = createCategory(db, { name: "Shelter", icon: "tent" });
      const updated = updateCategory(db, cat!.id, { name: "Sleep System" });

      expect(updated).toBeDefined();
      expect(updated!.name).toBe("Sleep System");
      expect(updated!.icon).toBe("tent");
    });

    it("changes icon", () => {
      const cat = createCategory(db, { name: "Shelter", icon: "tent" });
      const updated = updateCategory(db, cat!.id, { icon: "home" });

      expect(updated).toBeDefined();
      expect(updated!.icon).toBe("home");
    });

    it("returns null for non-existent id", () => {
      const result = updateCategory(db, 9999, { name: "Ghost" });
      expect(result).toBeNull();
    });
  });

  describe("deleteCategory", () => {
    it("reassigns items to Uncategorized (id=1) then deletes", () => {
      const shelter = createCategory(db, { name: "Shelter", icon: "tent" });
      createItem(db, { name: "Tent", categoryId: shelter!.id });
      createItem(db, { name: "Tarp", categoryId: shelter!.id });

      const result = deleteCategory(db, shelter!.id);
      expect(result.success).toBe(true);

      // Items should now be in Uncategorized (id=1)
      const reassigned = db
        .select()
        .from(items)
        .where(eq(items.categoryId, 1))
        .all();
      expect(reassigned).toHaveLength(2);
      expect(reassigned.map((i) => i.name).sort()).toEqual(["Tarp", "Tent"]);
    });

    it("cannot delete Uncategorized (id=1)", () => {
      const result = deleteCategory(db, 1);
      expect(result.success).toBe(false);
      expect(result.error).toBeDefined();
    });
  });
});