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

import { beforeEach, describe, expect, it } from "bun:test";
import {
	createItem,
	deleteItem,
	duplicateItem,
	getAllItems,
	getItemById,
	updateItem,
} from "../../src/server/services/item.service.ts";
import { createTestDb } from "../helpers/db.ts";

describe("Item Service", () => {
	let db: any;

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

	describe("createItem", () => {
		it("creates item with all fields, returns item with id and timestamps", async () => {
			const item = await createItem(db, {
				name: "Tent",
				weightGrams: 1200,
				priceCents: 35000,
				categoryId: 1,
				notes: "Ultralight 2-person",
				productUrl: "https://example.com/tent",
			});

			expect(item).toBeDefined();
			expect(item?.id).toBeGreaterThan(0);
			expect(item?.name).toBe("Tent");
			expect(item?.weightGrams).toBe(1200);
			expect(item?.priceCents).toBe(35000);
			expect(item?.categoryId).toBe(1);
			expect(item?.notes).toBe("Ultralight 2-person");
			expect(item?.productUrl).toBe("https://example.com/tent");
			expect(item?.createdAt).toBeDefined();
			expect(item?.updatedAt).toBeDefined();
		});

		it("only name and categoryId are required, other fields optional", async () => {
			const item = await createItem(db, { name: "Spork", categoryId: 1 });

			expect(item).toBeDefined();
			expect(item?.name).toBe("Spork");
			expect(item?.weightGrams).toBeNull();
			expect(item?.priceCents).toBeNull();
			expect(item?.notes).toBeNull();
			expect(item?.productUrl).toBeNull();
		});
	});

	describe("getAllItems", () => {
		it("returns all items with category info joined", async () => {
			await createItem(db, { name: "Tent", categoryId: 1 });
			await createItem(db, { name: "Sleeping Bag", categoryId: 1 });

			const all = await getAllItems(db);
			expect(all).toHaveLength(2);
			expect(all[0].categoryName).toBe("Uncategorized");
			expect(all[0].categoryIcon).toBeDefined();
		});
	});

	describe("getItemById", () => {
		it("returns single item or null", async () => {
			const created = await createItem(db, { name: "Tent", categoryId: 1 });
			const found = await getItemById(db, created?.id);
			expect(found).toBeDefined();
			expect(found?.name).toBe("Tent");

			const notFound = await getItemById(db, 9999);
			expect(notFound).toBeNull();
		});
	});

	describe("updateItem", () => {
		it("updates specified fields, sets updatedAt", async () => {
			const created = await createItem(db, {
				name: "Tent",
				weightGrams: 1200,
				categoryId: 1,
			});

			const updated = await updateItem(db, created?.id, {
				name: "Big Agnes Tent",
				weightGrams: 1100,
			});

			expect(updated).toBeDefined();
			expect(updated?.name).toBe("Big Agnes Tent");
			expect(updated?.weightGrams).toBe(1100);
		});

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

	describe("duplicateItem", () => {
		it("creates a copy with '(copy)' suffix in name", async () => {
			const original = await createItem(db, {
				name: "Tent",
				weightGrams: 1200,
				priceCents: 35000,
				categoryId: 1,
				notes: "Ultralight",
				productUrl: "https://example.com/tent",
			});

			const copy = await duplicateItem(db, original?.id);

			expect(copy).toBeDefined();
			expect(copy?.name).toBe("Tent (copy)");
			expect(copy?.weightGrams).toBe(1200);
			expect(copy?.priceCents).toBe(35000);
			expect(copy?.categoryId).toBe(1);
			expect(copy?.notes).toBe("Ultralight");
			expect(copy?.productUrl).toBe("https://example.com/tent");
		});

		it("copy has a different ID from the original", async () => {
			const original = await createItem(db, { name: "Helmet", categoryId: 1 });
			const copy = await duplicateItem(db, original?.id);

			expect(copy?.id).not.toBe(original?.id);
		});

		it("returns null for non-existent item", async () => {
			const result = await duplicateItem(db, 9999);
			expect(result).toBeNull();
		});
	});

	describe("deleteItem", () => {
		it("removes item from DB, returns deleted item", async () => {
			const created = await createItem(db, {
				name: "Tent",
				categoryId: 1,
				imageFilename: "tent.jpg",
			});

			const deleted = await deleteItem(db, created?.id);
			expect(deleted).toBeDefined();
			expect(deleted?.name).toBe("Tent");
			expect(deleted?.imageFilename).toBe("tent.jpg");

			// Verify it's gone
			const found = await getItemById(db, created?.id);
			expect(found).toBeNull();
		});

		it("returns null for non-existent id", async () => {
			const result = await deleteItem(db, 9999);
			expect(result).toBeNull();
		});
	});
});