makiolaj/GearBox
1
0
Fork 0
Code Issues 8 Pull Requests Actions Packages Projects Releases 10 Wiki Activity

feat(14-06): convert all 9 service test files to async PGlite

Browse Source 
- All beforeEach now use async/await createTestDb()
- All service calls in tests now awaited
- All direct DB calls (.run()/.all()) replaced with await
- All test callbacks made async
- Fixed PostgreSQL GROUP BY strictness in totals.service.ts (categories.name and categories.icon added to groupBy)
- db type changed to 'any' to accommodate PGlite type differences

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jean-Luc Makiola
2026-04-04 13:11:52 +02:00
parent cb2a192cb5
commit 458b33f1c7
9 changed files with 406 additions and 408 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
src/server/services/totals.service.ts
View File

@@ -16,7 +16,7 @@ export async function getCategoryTotals(db: Db = prodDb) {
}) })
.from(items) .from(items)
.innerJoin(categories, eq(items.categoryId, categories.id)) .innerJoin(categories, eq(items.categoryId, categories.id))
.groupBy(items.categoryId); .groupBy(items.categoryId, categories.name, categories.icon);
} }
export async function getGlobalTotals(db: Db = prodDb) { export async function getGlobalTotals(db: Db = prodDb) {

28
tests/services/auth.service.test.ts
View File

@@ -15,10 +15,10 @@ import {
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("Auth Service", () => { describe("Auth Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("User Management", () => { describe("User Management", () => {
@@ -48,12 +48,12 @@ describe("Auth Service", () => {
}); });
it("getUserCount returns 0 then 1", async () => { it("getUserCount returns 0 then 1", async () => {
const countBefore = getUserCount(db); const countBefore = await getUserCount(db);
expect(countBefore).toBe(0); expect(countBefore).toBe(0);
await createUser(db, "admin", "secret123"); await createUser(db, "admin", "secret123");
const countAfter = getUserCount(db); const countAfter = await getUserCount(db);
expect(countAfter).toBe(1); expect(countAfter).toBe(1);
}); });
@@ -86,33 +86,33 @@ describe("Auth Service", () => {
describe("Session Management", () => { describe("Session Management", () => {
it("creates and retrieves a session (id length is 64 hex chars)", async () => { it("creates and retrieves a session (id length is 64 hex chars)", async () => {
const user = await createUser(db, "admin", "secret123"); const user = await createUser(db, "admin", "secret123");
const session = createSession(db, user.id); const session = await createSession(db, user.id);
expect(session).toBeDefined(); expect(session).toBeDefined();
expect(session.id).toHaveLength(64); expect(session.id).toHaveLength(64);
expect(session.userId).toBe(user.id); expect(session.userId).toBe(user.id);
expect(session.expiresAt).toBeInstanceOf(Date); expect(session.expiresAt).toBeInstanceOf(Date);
const retrieved = getSession(db, session.id); const retrieved = await getSession(db, session.id);
expect(retrieved).not.toBeNull(); expect(retrieved).not.toBeNull();
expect(retrieved!.id).toBe(session.id); expect(retrieved!.id).toBe(session.id);
}); });
it("returns null for expired session (expiryDays = -1)", async () => { it("returns null for expired session (expiryDays = -1)", async () => {
const user = await createUser(db, "admin", "secret123"); const user = await createUser(db, "admin", "secret123");
const session = createSession(db, user.id, -1); const session = await createSession(db, user.id, -1);
const retrieved = getSession(db, session.id); const retrieved = await getSession(db, session.id);
expect(retrieved).toBeNull(); expect(retrieved).toBeNull();
}); });
it("deletes a session", async () => { it("deletes a session", async () => {
const user = await createUser(db, "admin", "secret123"); const user = await createUser(db, "admin", "secret123");
const session = createSession(db, user.id); const session = await createSession(db, user.id);
deleteSession(db, session.id); await deleteSession(db, session.id);
const retrieved = getSession(db, session.id); const retrieved = await getSession(db, session.id);
expect(retrieved).toBeNull(); expect(retrieved).toBeNull();
}); });
}); });
@@ -144,7 +144,7 @@ describe("Auth Service", () => {
it("deletes key so it is no longer valid", async () => { it("deletes key so it is no longer valid", async () => {
const result = await createApiKey(db, "test-key"); const result = await createApiKey(db, "test-key");
deleteApiKey(db, result.id); await deleteApiKey(db, result.id);
const isValid = await verifyApiKey(db, result.rawKey); const isValid = await verifyApiKey(db, result.rawKey);
expect(isValid).toBe(false); expect(isValid).toBe(false);
@@ -154,7 +154,7 @@ describe("Auth Service", () => {
await createApiKey(db, "key-one"); await createApiKey(db, "key-one");
await createApiKey(db, "key-two"); await createApiKey(db, "key-two");
const keys = listApiKeys(db); const keys = await listApiKeys(db);
expect(keys).toHaveLength(2); expect(keys).toHaveLength(2);
expect(keys[0].name).toBe("key-one"); expect(keys[0].name).toBe("key-one");
expect(keys[1].name).toBe("key-two"); expect(keys[1].name).toBe("key-two");

59
tests/services/category.service.test.ts
View File

@@ -11,15 +11,15 @@ import { createItem } from "../../src/server/services/item.service.ts";
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("Category Service", () => { describe("Category Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("createCategory", () => { describe("createCategory", () => {
it("creates with name and icon", () => { it("creates with name and icon", async () => {
const cat = createCategory(db, { name: "Shelter", icon: "tent" }); const cat = await createCategory(db, { name: "Shelter", icon: "tent" });
expect(cat).toBeDefined(); expect(cat).toBeDefined();
expect(cat?.id).toBeGreaterThan(0); expect(cat?.id).toBeGreaterThan(0);
@@ -27,8 +27,8 @@ describe("Category Service", () => {
expect(cat?.icon).toBe("tent"); expect(cat?.icon).toBe("tent");
}); });
it("uses default icon if not provided", () => { it("uses default icon if not provided", async () => {
const cat = createCategory(db, { name: "Cooking" }); const cat = await createCategory(db, { name: "Cooking" });
expect(cat).toBeDefined(); expect(cat).toBeDefined();
expect(cat?.icon).toBe("package"); expect(cat?.icon).toBe("package");
@@ -36,61 +36,60 @@ describe("Category Service", () => {
}); });
describe("getAllCategories", () => { describe("getAllCategories", () => {
it("returns all categories", () => { it("returns all categories", async () => {
createCategory(db, { name: "Shelter", icon: "tent" }); await createCategory(db, { name: "Shelter", icon: "tent" });
createCategory(db, { name: "Cooking", icon: "cooking-pot" }); await createCategory(db, { name: "Cooking", icon: "cooking-pot" });
const all = getAllCategories(db); const all = await getAllCategories(db);
// Includes seeded Uncategorized + 2 new // Includes seeded Uncategorized + 2 new
expect(all.length).toBeGreaterThanOrEqual(3); expect(all.length).toBeGreaterThanOrEqual(3);
}); });
}); });
describe("updateCategory", () => { describe("updateCategory", () => {
it("renames category", () => { it("renames category", async () => {
const cat = createCategory(db, { name: "Shelter", icon: "tent" }); const cat = await createCategory(db, { name: "Shelter", icon: "tent" });
const updated = updateCategory(db, cat?.id, { name: "Sleep System" }); const updated = await updateCategory(db, cat?.id, { name: "Sleep System" });
expect(updated).toBeDefined(); expect(updated).toBeDefined();
expect(updated?.name).toBe("Sleep System"); expect(updated?.name).toBe("Sleep System");
expect(updated?.icon).toBe("tent"); expect(updated?.icon).toBe("tent");
}); });
it("changes icon", () => { it("changes icon", async () => {
const cat = createCategory(db, { name: "Shelter", icon: "tent" }); const cat = await createCategory(db, { name: "Shelter", icon: "tent" });
const updated = updateCategory(db, cat?.id, { icon: "home" }); const updated = await updateCategory(db, cat?.id, { icon: "home" });
expect(updated).toBeDefined(); expect(updated).toBeDefined();
expect(updated?.icon).toBe("home"); expect(updated?.icon).toBe("home");
}); });
it("returns null for non-existent id", () => { it("returns null for non-existent id", async () => {
const result = updateCategory(db, 9999, { name: "Ghost" }); const result = await updateCategory(db, 9999, { name: "Ghost" });
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("deleteCategory", () => { describe("deleteCategory", () => {
it("reassigns items to Uncategorized (id=1) then deletes", () => { it("reassigns items to Uncategorized (id=1) then deletes", async () => {
const shelter = createCategory(db, { name: "Shelter", icon: "tent" }); const shelter = await createCategory(db, { name: "Shelter", icon: "tent" });
createItem(db, { name: "Tent", categoryId: shelter?.id }); await createItem(db, { name: "Tent", categoryId: shelter?.id });
createItem(db, { name: "Tarp", categoryId: shelter?.id }); await createItem(db, { name: "Tarp", categoryId: shelter?.id });
const result = deleteCategory(db, shelter?.id); const result = await deleteCategory(db, shelter?.id);
expect(result.success).toBe(true); expect(result.success).toBe(true);
// Items should now be in Uncategorized (id=1) // Items should now be in Uncategorized (id=1)
const reassigned = db const reassigned = await db
.select() .select()
.from(items) .from(items)
.where(eq(items.categoryId, 1)) .where(eq(items.categoryId, 1));
.all();
expect(reassigned).toHaveLength(2); expect(reassigned).toHaveLength(2);
expect(reassigned.map((i) => i.name).sort()).toEqual(["Tarp", "Tent"]); expect(reassigned.map((i: any) => i.name).sort()).toEqual(["Tarp", "Tent"]);
}); });
it("cannot delete Uncategorized (id=1)", () => { it("cannot delete Uncategorized (id=1)", async () => {
const result = deleteCategory(db, 1); const result = await deleteCategory(db, 1);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toBeDefined(); expect(result.error).toBeDefined();
}); });

81
tests/services/csv.service.test.ts
View File

@@ -8,17 +8,17 @@ import { createItem } from "../../src/server/services/item.service.ts";
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("CSV Service", () => { describe("CSV Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
// ── Export ──────────────────────────────────────────────────────────────── // ── Export ────────────────────────────────────────────────────────────────
describe("exportItemsCsv", () => { describe("exportItemsCsv", () => {
it("returns correct headers on empty collection", () => { it("returns correct headers on empty collection", async () => {
const csv = exportItemsCsv(db); const csv = await exportItemsCsv(db);
const lines = csv.split("\n"); const lines = csv.split("\n");
expect(lines[0]).toBe( expect(lines[0]).toBe(
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
@@ -26,8 +26,8 @@ describe("CSV Service", () => {
expect(lines).toHaveLength(1); expect(lines).toHaveLength(1);
}); });
it("exports items with correct values", () => { it("exports items with correct values", async () => {
createItem(db, { await createItem(db, {
name: "Tent", name: "Tent",
weightGrams: 1200, weightGrams: 1200,
priceCents: 35000, priceCents: 35000,
@@ -36,7 +36,7 @@ describe("CSV Service", () => {
productUrl: "https://example.com/tent", productUrl: "https://example.com/tent",
}); });
const csv = exportItemsCsv(db); const csv = await exportItemsCsv(db);
const lines = csv.split("\n"); const lines = csv.split("\n");
expect(lines).toHaveLength(2); expect(lines).toHaveLength(2);
expect(lines[1]).toContain("Tent"); expect(lines[1]).toContain("Tent");
@@ -47,44 +47,43 @@ describe("CSV Service", () => {
expect(lines[1]).toContain("https://example.com/tent"); expect(lines[1]).toContain("https://example.com/tent");
}); });
it("properly escapes fields with commas", () => { it("properly escapes fields with commas", async () => {
createItem(db, { await createItem(db, {
name: "Tent, Ultralight", name: "Tent, Ultralight",
categoryId: 1, categoryId: 1,
}); });
const csv = exportItemsCsv(db); const csv = await exportItemsCsv(db);
const lines = csv.split("\n"); const lines = csv.split("\n");
expect(lines[1]).toContain('"Tent, Ultralight"'); expect(lines[1]).toContain('"Tent, Ultralight"');
}); });
it("properly escapes fields with double quotes", () => { it("properly escapes fields with double quotes", async () => {
createItem(db, { await createItem(db, {
name: 'He said "great tent"', name: 'He said "great tent"',
categoryId: 1, categoryId: 1,
}); });
const csv = exportItemsCsv(db); const csv = await exportItemsCsv(db);
const lines = csv.split("\n"); const lines = csv.split("\n");
expect(lines[1]).toContain('"He said ""great tent"""'); expect(lines[1]).toContain('"He said ""great tent"""');
}); });
it("exports multiple items", () => { it("exports multiple items", async () => {
createItem(db, { name: "Tent", categoryId: 1 }); await createItem(db, { name: "Tent", categoryId: 1 });
createItem(db, { name: "Sleeping Bag", categoryId: 1 }); await createItem(db, { name: "Sleeping Bag", categoryId: 1 });
const csv = exportItemsCsv(db); const csv = await exportItemsCsv(db);
const lines = csv.split("\n"); const lines = csv.split("\n");
expect(lines).toHaveLength(3); // header + 2 items expect(lines).toHaveLength(3); // header + 2 items
}); });
it("exports quantity correctly", () => { it("exports quantity correctly", async () => {
// Insert directly to set quantity > 1 (createItem service defaults to 1) // Insert directly to set quantity > 1 (createItem service defaults to 1)
db.insert(items) await db.insert(items)
.values({ name: "Bolt", categoryId: 1, quantity: 4 }) .values({ name: "Bolt", categoryId: 1, quantity: 4 });
.run();
const csv = exportItemsCsv(db); const csv = await exportItemsCsv(db);
const lines = csv.split("\n"); const lines = csv.split("\n");
const fields = lines[1].split(","); const fields = lines[1].split(",");
// quantity is second field // quantity is second field
@@ -95,101 +94,101 @@ describe("CSV Service", () => {
// ── Import ──────────────────────────────────────────────────────────────── // ── Import ────────────────────────────────────────────────────────────────
describe("importItemsCsv", () => { describe("importItemsCsv", () => {
it("parses a valid CSV and creates items", () => { it("parses a valid CSV and creates items", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
"Tent,1,1200,35000,Camping,Ultralight,https://example.com/tent", "Tent,1,1200,35000,Camping,Ultralight,https://example.com/tent",
"Sleeping Bag,1,800,25000,Camping,,", "Sleeping Bag,1,800,25000,Camping,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(2); expect(result.imported).toBe(2);
expect(result.errors).toHaveLength(0); expect(result.errors).toHaveLength(0);
}); });
it("creates missing category and reports it", () => { it("creates missing category and reports it", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
"Helmet,1,350,12000,Cycling,,", "Helmet,1,350,12000,Cycling,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.createdCategories).toContain("Cycling"); expect(result.createdCategories).toContain("Cycling");
expect(result.errors).toHaveLength(0); expect(result.errors).toHaveLength(0);
}); });
it("uses existing category (case-insensitive) without creating a duplicate", () => { it("uses existing category (case-insensitive) without creating a duplicate", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
// "uncategorized" should match the seeded "Uncategorized" // "uncategorized" should match the seeded "Uncategorized"
"Spork,1,,,uncategorized,,", "Spork,1,,,uncategorized,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.createdCategories).toHaveLength(0); expect(result.createdCategories).toHaveLength(0);
}); });
it("skips rows with no name and records an error", () => { it("skips rows with no name and records an error", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
",1,200,,,", ",1,200,,,",
"Tent,1,1200,,,", "Tent,1,1200,,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.errors).toHaveLength(1); expect(result.errors).toHaveLength(1);
expect(result.errors[0]).toMatch(/missing required field "name"/); expect(result.errors[0]).toMatch(/missing required field "name"/);
}); });
it("defaults quantity to 1 when not provided", () => { it("defaults quantity to 1 when not provided", async () => {
const csv = [ const csv = [
"name,weightGrams,priceCents,category,notes,productUrl", "name,weightGrams,priceCents,category,notes,productUrl",
"Tent,1200,35000,Camping,,", "Tent,1200,35000,Camping,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.errors).toHaveLength(0); expect(result.errors).toHaveLength(0);
}); });
it("handles optional fields being empty", () => { it("handles optional fields being empty", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
"Tent,,,,,", "Tent,,,,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.errors).toHaveLength(0); expect(result.errors).toHaveLength(0);
}); });
it("handles quoted fields containing commas", () => { it("handles quoted fields containing commas", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
'"Tent, Ultralight",1,1200,,,', '"Tent, Ultralight",1,1200,,,',
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.errors).toHaveLength(0); expect(result.errors).toHaveLength(0);
}); });
it("returns zero imported on empty CSV", () => { it("returns zero imported on empty CSV", async () => {
const result = importItemsCsv(db, ""); const result = await importItemsCsv(db, "");
expect(result.imported).toBe(0); expect(result.imported).toBe(0);
expect(result.errors).toHaveLength(0); expect(result.errors).toHaveLength(0);
}); });
it("uses Uncategorized when category column is empty", () => { it("uses Uncategorized when category column is empty", async () => {
const csv = [ const csv = [
"name,quantity,weightGrams,priceCents,category,notes,productUrl", "name,quantity,weightGrams,priceCents,category,notes,productUrl",
"Tent,1,,,,", "Tent,1,,,,",
].join("\n"); ].join("\n");
const result = importItemsCsv(db, csv); const result = await importItemsCsv(db, csv);
expect(result.imported).toBe(1); expect(result.imported).toBe(1);
expect(result.createdCategories).toHaveLength(0); expect(result.createdCategories).toHaveLength(0);
}); });

68
tests/services/item.service.test.ts
View File

@@ -10,15 +10,15 @@ import {
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("Item Service", () => { describe("Item Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("createItem", () => { describe("createItem", () => {
it("creates item with all fields, returns item with id and timestamps", () => { it("creates item with all fields, returns item with id and timestamps", async () => {
const item = createItem(db, { const item = await createItem(db, {
name: "Tent", name: "Tent",
weightGrams: 1200, weightGrams: 1200,
priceCents: 35000, priceCents: 35000,
@@ -39,8 +39,8 @@ describe("Item Service", () => {
expect(item?.updatedAt).toBeDefined(); expect(item?.updatedAt).toBeDefined();
}); });
it("only name and categoryId are required, other fields optional", () => { it("only name and categoryId are required, other fields optional", async () => {
const item = createItem(db, { name: "Spork", categoryId: 1 }); const item = await createItem(db, { name: "Spork", categoryId: 1 });
expect(item).toBeDefined(); expect(item).toBeDefined();
expect(item?.name).toBe("Spork"); expect(item?.name).toBe("Spork");
@@ -52,11 +52,11 @@ describe("Item Service", () => {
}); });
describe("getAllItems", () => { describe("getAllItems", () => {
it("returns all items with category info joined", () => { it("returns all items with category info joined", async () => {
createItem(db, { name: "Tent", categoryId: 1 }); await createItem(db, { name: "Tent", categoryId: 1 });
createItem(db, { name: "Sleeping Bag", categoryId: 1 }); await createItem(db, { name: "Sleeping Bag", categoryId: 1 });
const all = getAllItems(db); const all = await getAllItems(db);
expect(all).toHaveLength(2); expect(all).toHaveLength(2);
expect(all[0].categoryName).toBe("Uncategorized"); expect(all[0].categoryName).toBe("Uncategorized");
expect(all[0].categoryIcon).toBeDefined(); expect(all[0].categoryIcon).toBeDefined();
@@ -64,26 +64,26 @@ describe("Item Service", () => {
}); });
describe("getItemById", () => { describe("getItemById", () => {
it("returns single item or null", () => { it("returns single item or null", async () => {
const created = createItem(db, { name: "Tent", categoryId: 1 }); const created = await createItem(db, { name: "Tent", categoryId: 1 });
const found = getItemById(db, created?.id); const found = await getItemById(db, created?.id);
expect(found).toBeDefined(); expect(found).toBeDefined();
expect(found?.name).toBe("Tent"); expect(found?.name).toBe("Tent");
const notFound = getItemById(db, 9999); const notFound = await getItemById(db, 9999);
expect(notFound).toBeNull(); expect(notFound).toBeNull();
}); });
}); });
describe("updateItem", () => { describe("updateItem", () => {
it("updates specified fields, sets updatedAt", () => { it("updates specified fields, sets updatedAt", async () => {
const created = createItem(db, { const created = await createItem(db, {
name: "Tent", name: "Tent",
weightGrams: 1200, weightGrams: 1200,
categoryId: 1, categoryId: 1,
}); });
const updated = updateItem(db, created?.id, { const updated = await updateItem(db, created?.id, {
name: "Big Agnes Tent", name: "Big Agnes Tent",
weightGrams: 1100, weightGrams: 1100,
}); });
@@ -93,15 +93,15 @@ describe("Item Service", () => {
expect(updated?.weightGrams).toBe(1100); expect(updated?.weightGrams).toBe(1100);
}); });
it("returns null for non-existent id", () => { it("returns null for non-existent id", async () => {
const result = updateItem(db, 9999, { name: "Ghost" }); const result = await updateItem(db, 9999, { name: "Ghost" });
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("duplicateItem", () => { describe("duplicateItem", () => {
it("creates a copy with '(copy)' suffix in name", () => { it("creates a copy with '(copy)' suffix in name", async () => {
const original = createItem(db, { const original = await createItem(db, {
name: "Tent", name: "Tent",
weightGrams: 1200, weightGrams: 1200,
priceCents: 35000, priceCents: 35000,
@@ -110,7 +110,7 @@ describe("Item Service", () => {
productUrl: "https://example.com/tent", productUrl: "https://example.com/tent",
}); });
const copy = duplicateItem(db, original?.id); const copy = await duplicateItem(db, original?.id);
expect(copy).toBeDefined(); expect(copy).toBeDefined();
expect(copy?.name).toBe("Tent (copy)"); expect(copy?.name).toBe("Tent (copy)");
@@ -121,39 +121,39 @@ describe("Item Service", () => {
expect(copy?.productUrl).toBe("https://example.com/tent"); expect(copy?.productUrl).toBe("https://example.com/tent");
}); });
it("copy has a different ID from the original", () => { it("copy has a different ID from the original", async () => {
const original = createItem(db, { name: "Helmet", categoryId: 1 }); const original = await createItem(db, { name: "Helmet", categoryId: 1 });
const copy = duplicateItem(db, original?.id); const copy = await duplicateItem(db, original?.id);
expect(copy?.id).not.toBe(original?.id); expect(copy?.id).not.toBe(original?.id);
}); });
it("returns null for non-existent item", () => { it("returns null for non-existent item", async () => {
const result = duplicateItem(db, 9999); const result = await duplicateItem(db, 9999);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("deleteItem", () => { describe("deleteItem", () => {
it("removes item from DB, returns deleted item", () => { it("removes item from DB, returns deleted item", async () => {
const created = createItem(db, { const created = await createItem(db, {
name: "Tent", name: "Tent",
categoryId: 1, categoryId: 1,
imageFilename: "tent.jpg", imageFilename: "tent.jpg",
}); });
const deleted = deleteItem(db, created?.id); const deleted = await deleteItem(db, created?.id);
expect(deleted).toBeDefined(); expect(deleted).toBeDefined();
expect(deleted?.name).toBe("Tent"); expect(deleted?.name).toBe("Tent");
expect(deleted?.imageFilename).toBe("tent.jpg"); expect(deleted?.imageFilename).toBe("tent.jpg");
// Verify it's gone // Verify it's gone
const found = getItemById(db, created?.id); const found = await getItemById(db, created?.id);
expect(found).toBeNull(); expect(found).toBeNull();
}); });
it("returns null for non-existent id", () => { it("returns null for non-existent id", async () => {
const result = deleteItem(db, 9999); const result = await deleteItem(db, 9999);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });

54
tests/services/oauth.service.test.ts
View File

@@ -17,15 +17,15 @@ function generatePkce() {
} }
describe("OAuth Service", () => { describe("OAuth Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("Client Registration", () => { describe("Client Registration", () => {
it("registers a client and returns clientId (string, non-empty)", () => { it("registers a client and returns clientId (string, non-empty)", async () => {
const result = registerClient(db, "Test App", [ const result = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
@@ -34,32 +34,32 @@ describe("OAuth Service", () => {
expect(result.clientId.length).toBeGreaterThan(0); expect(result.clientId.length).toBeGreaterThan(0);
}); });
it("getClient returns registered client with correct clientName and redirectUris (JSON parsed)", () => { it("getClient returns registered client with correct clientName and redirectUris (JSON parsed)", async () => {
const redirectUris = ["http://localhost:8080/callback"]; const redirectUris = ["http://localhost:8080/callback"];
const { clientId } = registerClient(db, "Test App", redirectUris); const { clientId } = await registerClient(db, "Test App", redirectUris);
const client = getClient(db, clientId); const client = await getClient(db, clientId);
expect(client).not.toBeNull(); expect(client).not.toBeNull();
expect(client!.clientName).toBe("Test App"); expect(client!.clientName).toBe("Test App");
expect(JSON.parse(client!.redirectUris)).toEqual(redirectUris); expect(JSON.parse(client!.redirectUris)).toEqual(redirectUris);
}); });
it("getClient returns null for unknown client", () => { it("getClient returns null for unknown client", async () => {
const client = getClient(db, "unknown-client-id"); const client = await getClient(db, "unknown-client-id");
expect(client).toBeNull(); expect(client).toBeNull();
}); });
}); });
describe("Authorization Code + PKCE", () => { describe("Authorization Code + PKCE", () => {
it("creates an authorization code (non-empty)", () => { it("creates an authorization code (non-empty)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { challenge } = generatePkce(); const { challenge } = generatePkce();
const result = createAuthorizationCode( const result = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -73,12 +73,12 @@ describe("OAuth Service", () => {
}); });
it("exchanges code for tokens with valid PKCE verifier (returns accessToken, refreshToken, expiresIn=3600)", async () => { it("exchanges code for tokens with valid PKCE verifier (returns accessToken, refreshToken, expiresIn=3600)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { verifier, challenge } = generatePkce(); const { verifier, challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -103,12 +103,12 @@ describe("OAuth Service", () => {
}); });
it("rejects code exchange with wrong PKCE verifier (returns null)", async () => { it("rejects code exchange with wrong PKCE verifier (returns null)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { challenge } = generatePkce(); const { challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -128,12 +128,12 @@ describe("OAuth Service", () => {
}); });
it("rejects code exchange with wrong redirect_uri (returns null)", async () => { it("rejects code exchange with wrong redirect_uri (returns null)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { verifier, challenge } = generatePkce(); const { verifier, challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -153,12 +153,12 @@ describe("OAuth Service", () => {
}); });
it("rejects replayed code - single use (second exchange returns null)", async () => { it("rejects replayed code - single use (second exchange returns null)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { verifier, challenge } = generatePkce(); const { verifier, challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -190,12 +190,12 @@ describe("OAuth Service", () => {
describe("Token Verification", () => { describe("Token Verification", () => {
it("verifies a valid access token (returns true)", async () => { it("verifies a valid access token (returns true)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { verifier, challenge } = generatePkce(); const { verifier, challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -223,12 +223,12 @@ describe("OAuth Service", () => {
describe("Token Refresh", () => { describe("Token Refresh", () => {
it("refreshes a valid refresh token and returns new tokens (different accessToken)", async () => { it("refreshes a valid refresh token and returns new tokens (different accessToken)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { verifier, challenge } = generatePkce(); const { verifier, challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,
@@ -257,12 +257,12 @@ describe("OAuth Service", () => {
}); });
it("rejects refresh with wrong clientId (returns null)", async () => { it("rejects refresh with wrong clientId (returns null)", async () => {
const { clientId } = registerClient(db, "Test App", [ const { clientId } = await registerClient(db, "Test App", [
"http://localhost:8080/callback", "http://localhost:8080/callback",
]); ]);
const { verifier, challenge } = generatePkce(); const { verifier, challenge } = generatePkce();
const { code } = createAuthorizationCode( const { code } = await createAuthorizationCode(
db, db,
clientId, clientId,
challenge, challenge,

218
tests/services/setup.service.test.ts
View File

@@ -1,4 +1,6 @@
import { beforeEach, describe, expect, it } from "bun:test"; import { beforeEach, describe, expect, it } from "bun:test";
import { eq } from "drizzle-orm";
import { items as itemsTable } from "../../src/db/schema.ts";
import { createItem } from "../../src/server/services/item.service.ts"; import { createItem } from "../../src/server/services/item.service.ts";
import { import {
createSetup, createSetup,
@@ -13,15 +15,15 @@ import {
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("Setup Service", () => { describe("Setup Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("createSetup", () => { describe("createSetup", () => {
it("creates setup with name, returns setup with id/timestamps", () => { it("creates setup with name, returns setup with id/timestamps", async () => {
const setup = createSetup(db, { name: "Day Hike" }); const setup = await createSetup(db, { name: "Day Hike" });
expect(setup).toBeDefined(); expect(setup).toBeDefined();
expect(setup.id).toBeGreaterThan(0); expect(setup.id).toBeGreaterThan(0);
@@ -32,23 +34,23 @@ describe("Setup Service", () => {
}); });
describe("getAllSetups", () => { describe("getAllSetups", () => {
it("returns setups with itemCount, totalWeight, totalCost", () => { it("returns setups with itemCount, totalWeight, totalCost", async () => {
const setup = createSetup(db, { name: "Backpacking" }); const setup = await createSetup(db, { name: "Backpacking" });
const item1 = createItem(db, { const item1 = await createItem(db, {
name: "Tent", name: "Tent",
categoryId: 1, categoryId: 1,
weightGrams: 1200, weightGrams: 1200,
priceCents: 30000, priceCents: 30000,
}); });
const item2 = createItem(db, { const item2 = await createItem(db, {
name: "Sleeping Bag", name: "Sleeping Bag",
categoryId: 1, categoryId: 1,
weightGrams: 800, weightGrams: 800,
priceCents: 20000, priceCents: 20000,
}); });
syncSetupItems(db, setup.id, [item1.id, item2.id]); await syncSetupItems(db, setup.id, [item1.id, item2.id]);
const setups = getAllSetups(db); const setups = await getAllSetups(db);
expect(setups).toHaveLength(1); expect(setups).toHaveLength(1);
expect(setups[0].name).toBe("Backpacking"); expect(setups[0].name).toBe("Backpacking");
expect(setups[0].itemCount).toBe(2); expect(setups[0].itemCount).toBe(2);
@@ -56,10 +58,10 @@ describe("Setup Service", () => {
expect(setups[0].totalCost).toBe(50000); expect(setups[0].totalCost).toBe(50000);
}); });
it("returns 0 for weight/cost when setup has no items", () => { it("returns 0 for weight/cost when setup has no items", async () => {
createSetup(db, { name: "Empty Setup" }); await createSetup(db, { name: "Empty Setup" });
const setups = getAllSetups(db); const setups = await getAllSetups(db);
expect(setups).toHaveLength(1); expect(setups).toHaveLength(1);
expect(setups[0].itemCount).toBe(0); expect(setups[0].itemCount).toBe(0);
expect(setups[0].totalWeight).toBe(0); expect(setups[0].totalWeight).toBe(0);
@@ -68,17 +70,17 @@ describe("Setup Service", () => {
}); });
describe("getSetupWithItems", () => { describe("getSetupWithItems", () => {
it("returns setup with full item details and category info", () => { it("returns setup with full item details and category info", async () => {
const setup = createSetup(db, { name: "Day Hike" }); const setup = await createSetup(db, { name: "Day Hike" });
const item = createItem(db, { const item = await createItem(db, {
name: "Water Bottle", name: "Water Bottle",
categoryId: 1, categoryId: 1,
weightGrams: 200, weightGrams: 200,
priceCents: 2500, priceCents: 2500,
}); });
syncSetupItems(db, setup.id, [item.id]); await syncSetupItems(db, setup.id, [item.id]);
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result).toBeDefined(); expect(result).toBeDefined();
expect(result?.name).toBe("Day Hike"); expect(result?.name).toBe("Day Hike");
expect(result?.items).toHaveLength(1); expect(result?.items).toHaveLength(1);
@@ -87,127 +89,127 @@ describe("Setup Service", () => {
expect(result?.items[0].categoryIcon).toBeDefined(); expect(result?.items[0].categoryIcon).toBeDefined();
}); });
it("returns null for non-existent setup", () => { it("returns null for non-existent setup", async () => {
const result = getSetupWithItems(db, 9999); const result = await getSetupWithItems(db, 9999);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("updateSetup", () => { describe("updateSetup", () => {
it("updates setup name, returns updated setup", () => { it("updates setup name, returns updated setup", async () => {
const setup = createSetup(db, { name: "Original" }); const setup = await createSetup(db, { name: "Original" });
const updated = updateSetup(db, setup.id, { name: "Renamed" }); const updated = await updateSetup(db, setup.id, { name: "Renamed" });
expect(updated).toBeDefined(); expect(updated).toBeDefined();
expect(updated?.name).toBe("Renamed"); expect(updated?.name).toBe("Renamed");
}); });
it("returns null for non-existent setup", () => { it("returns null for non-existent setup", async () => {
const result = updateSetup(db, 9999, { name: "Ghost" }); const result = await updateSetup(db, 9999, { name: "Ghost" });
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("deleteSetup", () => { describe("deleteSetup", () => {
it("removes setup and cascades to setup_items", () => { it("removes setup and cascades to setup_items", async () => {
const setup = createSetup(db, { name: "To Delete" }); const setup = await createSetup(db, { name: "To Delete" });
const item = createItem(db, { name: "Item", categoryId: 1 }); const item = await createItem(db, { name: "Item", categoryId: 1 });
syncSetupItems(db, setup.id, [item.id]); await syncSetupItems(db, setup.id, [item.id]);
const deleted = deleteSetup(db, setup.id); const deleted = await deleteSetup(db, setup.id);
expect(deleted).toBe(true); expect(deleted).toBe(true);
// Setup gone // Setup gone
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
it("returns false for non-existent setup", () => { it("returns false for non-existent setup", async () => {
const result = deleteSetup(db, 9999); const result = await deleteSetup(db, 9999);
expect(result).toBe(false); expect(result).toBe(false);
}); });
}); });
describe("syncSetupItems", () => { describe("syncSetupItems", () => {
it("sets items for a setup (delete-all + re-insert)", () => { it("sets items for a setup (delete-all + re-insert)", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 }); const item1 = await createItem(db, { name: "Item 1", categoryId: 1 });
const item2 = createItem(db, { name: "Item 2", categoryId: 1 }); const item2 = await createItem(db, { name: "Item 2", categoryId: 1 });
const item3 = createItem(db, { name: "Item 3", categoryId: 1 }); const item3 = await createItem(db, { name: "Item 3", categoryId: 1 });
// Initial sync // Initial sync
syncSetupItems(db, setup.id, [item1.id, item2.id]); await syncSetupItems(db, setup.id, [item1.id, item2.id]);
let result = getSetupWithItems(db, setup.id); let result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(2); expect(result?.items).toHaveLength(2);
// Re-sync with different items // Re-sync with different items
syncSetupItems(db, setup.id, [item2.id, item3.id]); await syncSetupItems(db, setup.id, [item2.id, item3.id]);
result = getSetupWithItems(db, setup.id); result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(2); expect(result?.items).toHaveLength(2);
const names = result?.items.map((i: any) => i.name).sort(); const names = result?.items.map((i: any) => i.name).sort();
expect(names).toEqual(["Item 2", "Item 3"]); expect(names).toEqual(["Item 2", "Item 3"]);
}); });
it("syncing with empty array clears all items", () => { it("syncing with empty array clears all items", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item = createItem(db, { name: "Item", categoryId: 1 }); const item = await createItem(db, { name: "Item", categoryId: 1 });
syncSetupItems(db, setup.id, [item.id]); await syncSetupItems(db, setup.id, [item.id]);
syncSetupItems(db, setup.id, []); await syncSetupItems(db, setup.id, []);
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(0); expect(result?.items).toHaveLength(0);
}); });
}); });
describe("removeSetupItem", () => { describe("removeSetupItem", () => {
it("removes single item from setup", () => { it("removes single item from setup", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 }); const item1 = await createItem(db, { name: "Item 1", categoryId: 1 });
const item2 = createItem(db, { name: "Item 2", categoryId: 1 }); const item2 = await createItem(db, { name: "Item 2", categoryId: 1 });
syncSetupItems(db, setup.id, [item1.id, item2.id]); await syncSetupItems(db, setup.id, [item1.id, item2.id]);
removeSetupItem(db, setup.id, item1.id); await removeSetupItem(db, setup.id, item1.id);
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(1); expect(result?.items).toHaveLength(1);
expect(result?.items[0].name).toBe("Item 2"); expect(result?.items[0].name).toBe("Item 2");
}); });
}); });
describe("getSetupWithItems - classification", () => { describe("getSetupWithItems - classification", () => {
it("returns classification field defaulting to 'base' for each item", () => { it("returns classification field defaulting to 'base' for each item", async () => {
const setup = createSetup(db, { name: "Day Hike" }); const setup = await createSetup(db, { name: "Day Hike" });
const item = createItem(db, { const item = await createItem(db, {
name: "Water Bottle", name: "Water Bottle",
categoryId: 1, categoryId: 1,
weightGrams: 200, weightGrams: 200,
priceCents: 2500, priceCents: 2500,
}); });
syncSetupItems(db, setup.id, [item.id]); await syncSetupItems(db, setup.id, [item.id]);
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(1); expect(result?.items).toHaveLength(1);
expect(result?.items[0].classification).toBe("base"); expect(result?.items[0].classification).toBe("base");
}); });
}); });
describe("syncSetupItems - classification preservation", () => { describe("syncSetupItems - classification preservation", () => {
it("preserves existing classifications when re-syncing items", () => { it("preserves existing classifications when re-syncing items", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Tent", categoryId: 1 }); const item1 = await createItem(db, { name: "Tent", categoryId: 1 });
const item2 = createItem(db, { name: "Jacket", categoryId: 1 }); const item2 = await createItem(db, { name: "Jacket", categoryId: 1 });
const item3 = createItem(db, { name: "Stove", categoryId: 1 }); const item3 = await createItem(db, { name: "Stove", categoryId: 1 });
// Initial sync // Initial sync
syncSetupItems(db, setup.id, [item1.id, item2.id]); await syncSetupItems(db, setup.id, [item1.id, item2.id]);
// Change classifications // Change classifications
updateItemClassification(db, setup.id, item1.id, "worn"); await updateItemClassification(db, setup.id, item1.id, "worn");
updateItemClassification(db, setup.id, item2.id, "consumable"); await updateItemClassification(db, setup.id, item2.id, "consumable");
// Re-sync with item2 kept and item3 added (item1 removed) // Re-sync with item2 kept and item3 added (item1 removed)
syncSetupItems(db, setup.id, [item2.id, item3.id]); await syncSetupItems(db, setup.id, [item2.id, item3.id]);
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(2); expect(result?.items).toHaveLength(2);
const item2Result = result?.items.find((i: any) => i.name === "Jacket"); const item2Result = result?.items.find((i: any) => i.name === "Jacket");
@@ -216,57 +218,57 @@ describe("Setup Service", () => {
expect(item3Result?.classification).toBe("base"); expect(item3Result?.classification).toBe("base");
}); });
it("assigns 'base' to newly added items with no prior classification", () => { it("assigns 'base' to newly added items with no prior classification", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 }); const item1 = await createItem(db, { name: "Item 1", categoryId: 1 });
syncSetupItems(db, setup.id, [item1.id]); await syncSetupItems(db, setup.id, [item1.id]);
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items[0].classification).toBe("base"); expect(result?.items[0].classification).toBe("base");
}); });
}); });
describe("updateItemClassification", () => { describe("updateItemClassification", () => {
it("sets classification for a specific item in a specific setup", () => { it("sets classification for a specific item in a specific setup", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item = createItem(db, { name: "Tent", categoryId: 1 }); const item = await createItem(db, { name: "Tent", categoryId: 1 });
syncSetupItems(db, setup.id, [item.id]); await syncSetupItems(db, setup.id, [item.id]);
updateItemClassification(db, setup.id, item.id, "worn"); await updateItemClassification(db, setup.id, item.id, "worn");
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items[0].classification).toBe("worn"); expect(result?.items[0].classification).toBe("worn");
}); });
it("changes item from default 'base' to 'worn'", () => { it("changes item from default 'base' to 'worn'", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item = createItem(db, { name: "Jacket", categoryId: 1 }); const item = await createItem(db, { name: "Jacket", categoryId: 1 });
syncSetupItems(db, setup.id, [item.id]); await syncSetupItems(db, setup.id, [item.id]);
// Verify default // Verify default
let result = getSetupWithItems(db, setup.id); let result = await getSetupWithItems(db, setup.id);
expect(result?.items[0].classification).toBe("base"); expect(result?.items[0].classification).toBe("base");
// Update // Update
updateItemClassification(db, setup.id, item.id, "worn"); await updateItemClassification(db, setup.id, item.id, "worn");
result = getSetupWithItems(db, setup.id); result = await getSetupWithItems(db, setup.id);
expect(result?.items[0].classification).toBe("worn"); expect(result?.items[0].classification).toBe("worn");
}); });
it("same item in two different setups can have different classifications", () => { it("same item in two different setups can have different classifications", async () => {
const setup1 = createSetup(db, { name: "Hiking" }); const setup1 = await createSetup(db, { name: "Hiking" });
const setup2 = createSetup(db, { name: "Biking" }); const setup2 = await createSetup(db, { name: "Biking" });
const item = createItem(db, { name: "Jacket", categoryId: 1 }); const item = await createItem(db, { name: "Jacket", categoryId: 1 });
syncSetupItems(db, setup1.id, [item.id]); await syncSetupItems(db, setup1.id, [item.id]);
syncSetupItems(db, setup2.id, [item.id]); await syncSetupItems(db, setup2.id, [item.id]);
updateItemClassification(db, setup1.id, item.id, "worn"); await updateItemClassification(db, setup1.id, item.id, "worn");
updateItemClassification(db, setup2.id, item.id, "base"); await updateItemClassification(db, setup2.id, item.id, "base");
const result1 = getSetupWithItems(db, setup1.id); const result1 = await getSetupWithItems(db, setup1.id);
const result2 = getSetupWithItems(db, setup2.id); const result2 = await getSetupWithItems(db, setup2.id);
expect(result1?.items[0].classification).toBe("worn"); expect(result1?.items[0].classification).toBe("worn");
expect(result2?.items[0].classification).toBe("base"); expect(result2?.items[0].classification).toBe("base");
@@ -274,18 +276,16 @@ describe("Setup Service", () => {
}); });
describe("cascade behavior", () => { describe("cascade behavior", () => {
it("deleting a collection item removes it from all setups", () => { it("deleting a collection item removes it from all setups", async () => {
const setup = createSetup(db, { name: "Kit" }); const setup = await createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 }); const item1 = await createItem(db, { name: "Item 1", categoryId: 1 });
const item2 = createItem(db, { name: "Item 2", categoryId: 1 }); const item2 = await createItem(db, { name: "Item 2", categoryId: 1 });
syncSetupItems(db, setup.id, [item1.id, item2.id]); await syncSetupItems(db, setup.id, [item1.id, item2.id]);
// Delete item1 from collection (need direct DB access) // Delete item1 from collection
const { items: itemsTable } = require("../../src/db/schema.ts"); await db.delete(itemsTable).where(eq(itemsTable.id, item1.id));
const { eq } = require("drizzle-orm");
db.delete(itemsTable).where(eq(itemsTable.id, item1.id)).run();
const result = getSetupWithItems(db, setup.id); const result = await getSetupWithItems(db, setup.id);
expect(result?.items).toHaveLength(1); expect(result?.items).toHaveLength(1);
expect(result?.items[0].name).toBe("Item 2"); expect(result?.items[0].name).toBe("Item 2");
}); });

270
tests/services/thread.service.test.ts
View File

@@ -14,15 +14,15 @@ import {
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("Thread Service", () => { describe("Thread Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("createThread", () => { describe("createThread", () => {
it("creates thread with name, returns thread with id/status/timestamps", () => { it("creates thread with name, returns thread with id/status/timestamps", async () => {
const thread = createThread(db, { name: "New Tent", categoryId: 1 }); const thread = await createThread(db, { name: "New Tent", categoryId: 1 });
expect(thread).toBeDefined(); expect(thread).toBeDefined();
expect(thread.id).toBeGreaterThan(0); expect(thread.id).toBeGreaterThan(0);
@@ -35,23 +35,23 @@ describe("Thread Service", () => {
}); });
describe("getAllThreads", () => { describe("getAllThreads", () => {
it("returns active threads with candidateCount and price range", () => { it("returns active threads with candidateCount and price range", async () => {
const thread = createThread(db, { const thread = await createThread(db, {
name: "Backpack Options", name: "Backpack Options",
categoryId: 1, categoryId: 1,
}); });
createCandidate(db, thread.id, { await createCandidate(db, thread.id, {
name: "Pack A", name: "Pack A",
categoryId: 1, categoryId: 1,
priceCents: 20000, priceCents: 20000,
}); });
createCandidate(db, thread.id, { await createCandidate(db, thread.id, {
name: "Pack B", name: "Pack B",
categoryId: 1, categoryId: 1,
priceCents: 35000, priceCents: 35000,
}); });
const threads = getAllThreads(db); const threads = await getAllThreads(db);
expect(threads).toHaveLength(1); expect(threads).toHaveLength(1);
expect(threads[0].name).toBe("Backpack Options"); expect(threads[0].name).toBe("Backpack Options");
expect(threads[0].candidateCount).toBe(2); expect(threads[0].candidateCount).toBe(2);
@@ -59,45 +59,45 @@ describe("Thread Service", () => {
expect(threads[0].maxPriceCents).toBe(35000); expect(threads[0].maxPriceCents).toBe(35000);
}); });
it("excludes resolved threads by default", () => { it("excludes resolved threads by default", async () => {
const _t1 = createThread(db, { name: "Active Thread", categoryId: 1 }); const _t1 = await createThread(db, { name: "Active Thread", categoryId: 1 });
const t2 = createThread(db, { name: "Resolved Thread", categoryId: 1 }); const t2 = await createThread(db, { name: "Resolved Thread", categoryId: 1 });
const candidate = createCandidate(db, t2.id, { const candidate = await createCandidate(db, t2.id, {
name: "Winner", name: "Winner",
categoryId: 1, categoryId: 1,
}); });
resolveThread(db, t2.id, candidate.id); await resolveThread(db, t2.id, candidate.id);
const active = getAllThreads(db); const active = await getAllThreads(db);
expect(active).toHaveLength(1); expect(active).toHaveLength(1);
expect(active[0].name).toBe("Active Thread"); expect(active[0].name).toBe("Active Thread");
}); });
it("includes resolved threads when includeResolved=true", () => { it("includes resolved threads when includeResolved=true", async () => {
const _t1 = createThread(db, { name: "Active Thread", categoryId: 1 }); const _t1 = await createThread(db, { name: "Active Thread", categoryId: 1 });
const t2 = createThread(db, { name: "Resolved Thread", categoryId: 1 }); const t2 = await createThread(db, { name: "Resolved Thread", categoryId: 1 });
const candidate = createCandidate(db, t2.id, { const candidate = await createCandidate(db, t2.id, {
name: "Winner", name: "Winner",
categoryId: 1, categoryId: 1,
}); });
resolveThread(db, t2.id, candidate.id); await resolveThread(db, t2.id, candidate.id);
const all = getAllThreads(db, true); const all = await getAllThreads(db, true);
expect(all).toHaveLength(2); expect(all).toHaveLength(2);
}); });
}); });
describe("getThreadWithCandidates", () => { describe("getThreadWithCandidates", () => {
it("returns thread with nested candidates array including category info", () => { it("returns thread with nested candidates array including category info", async () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 }); const thread = await createThread(db, { name: "Tent Options", categoryId: 1 });
createCandidate(db, thread.id, { await createCandidate(db, thread.id, {
name: "Tent A", name: "Tent A",
categoryId: 1, categoryId: 1,
weightGrams: 1200, weightGrams: 1200,
priceCents: 30000, priceCents: 30000,
}); });
const result = getThreadWithCandidates(db, thread.id); const result = await getThreadWithCandidates(db, thread.id);
expect(result).toBeDefined(); expect(result).toBeDefined();
expect(result?.name).toBe("Tent Options"); expect(result?.name).toBe("Tent Options");
expect(result?.candidates).toHaveLength(1); expect(result?.candidates).toHaveLength(1);
@@ -106,21 +106,21 @@ describe("Thread Service", () => {
expect(result?.candidates[0].categoryIcon).toBeDefined(); expect(result?.candidates[0].categoryIcon).toBeDefined();
}); });
it("returns null for non-existent thread", () => { it("returns null for non-existent thread", async () => {
const result = getThreadWithCandidates(db, 9999); const result = await getThreadWithCandidates(db, 9999);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
it("includes pros and cons on each candidate", () => { it("includes pros and cons on each candidate", async () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 }); const thread = await createThread(db, { name: "Tent Options", categoryId: 1 });
createCandidate(db, thread.id, { await createCandidate(db, thread.id, {
name: "Tent A", name: "Tent A",
categoryId: 1, categoryId: 1,
pros: "Lightweight", pros: "Lightweight",
cons: "Pricey", cons: "Pricey",
}); });
const result = getThreadWithCandidates(db, thread.id); const result = await getThreadWithCandidates(db, thread.id);
expect(result).toBeDefined(); expect(result).toBeDefined();
expect(result?.candidates[0].pros).toBe("Lightweight"); expect(result?.candidates[0].pros).toBe("Lightweight");
expect(result?.candidates[0].cons).toBe("Pricey"); expect(result?.candidates[0].cons).toBe("Pricey");
@@ -128,9 +128,9 @@ describe("Thread Service", () => {
}); });
describe("createCandidate", () => { describe("createCandidate", () => {
it("adds candidate to thread with all item-compatible fields", () => { it("adds candidate to thread with all item-compatible fields", async () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 }); const thread = await createThread(db, { name: "Tent Options", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Tent A", name: "Tent A",
weightGrams: 1200, weightGrams: 1200,
priceCents: 30000, priceCents: 30000,
@@ -150,9 +150,9 @@ describe("Thread Service", () => {
expect(candidate.productUrl).toBe("https://example.com/tent"); expect(candidate.productUrl).toBe("https://example.com/tent");
}); });
it("stores and returns pros and cons", () => { it("stores and returns pros and cons", async () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 }); const thread = await createThread(db, { name: "Tent Options", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Tent A", name: "Tent A",
categoryId: 1, categoryId: 1,
pros: "Lightweight\nGood reviews", pros: "Lightweight\nGood reviews",
@@ -163,9 +163,9 @@ describe("Thread Service", () => {
expect(candidate.cons).toBe("Expensive"); expect(candidate.cons).toBe("Expensive");
}); });
it("returns null for pros and cons when not provided", () => { it("returns null for pros and cons when not provided", async () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 }); const thread = await createThread(db, { name: "Tent Options", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Tent B", name: "Tent B",
categoryId: 1, categoryId: 1,
}); });
@@ -176,14 +176,14 @@ describe("Thread Service", () => {
}); });
describe("updateCandidate", () => { describe("updateCandidate", () => {
it("updates candidate fields, returns updated candidate", () => { it("updates candidate fields, returns updated candidate", async () => {
const thread = createThread(db, { name: "Test", categoryId: 1 }); const thread = await createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Original", name: "Original",
categoryId: 1, categoryId: 1,
}); });
const updated = updateCandidate(db, candidate.id, { const updated = await updateCandidate(db, candidate.id, {
name: "Updated Name", name: "Updated Name",
priceCents: 15000, priceCents: 15000,
}); });
@@ -193,20 +193,20 @@ describe("Thread Service", () => {
expect(updated?.priceCents).toBe(15000); expect(updated?.priceCents).toBe(15000);
}); });
it("returns null for non-existent candidate", () => { it("returns null for non-existent candidate", async () => {
const result = updateCandidate(db, 9999, { name: "Ghost" }); const result = await updateCandidate(db, 9999, { name: "Ghost" });
expect(result).toBeNull(); expect(result).toBeNull();
}); });
it("can set and clear pros and cons", () => { it("can set and clear pros and cons", async () => {
const thread = createThread(db, { name: "Test", categoryId: 1 }); const thread = await createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Original", name: "Original",
categoryId: 1, categoryId: 1,
}); });
// Set pros and cons // Set pros and cons
const withPros = updateCandidate(db, candidate.id, { const withPros = await updateCandidate(db, candidate.id, {
pros: "Lightweight", pros: "Lightweight",
cons: "Expensive", cons: "Expensive",
}); });
@@ -214,7 +214,7 @@ describe("Thread Service", () => {
expect(withPros?.cons).toBe("Expensive"); expect(withPros?.cons).toBe("Expensive");
// Clear pros and cons by setting to empty string // Clear pros and cons by setting to empty string
const cleared = updateCandidate(db, candidate.id, { const cleared = await updateCandidate(db, candidate.id, {
pros: "", pros: "",
cons: "", cons: "",
}); });
@@ -225,67 +225,67 @@ describe("Thread Service", () => {
}); });
describe("deleteCandidate", () => { describe("deleteCandidate", () => {
it("removes candidate, returns deleted candidate", () => { it("removes candidate, returns deleted candidate", async () => {
const thread = createThread(db, { name: "Test", categoryId: 1 }); const thread = await createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "To Delete", name: "To Delete",
categoryId: 1, categoryId: 1,
}); });
const deleted = deleteCandidate(db, candidate.id); const deleted = await deleteCandidate(db, candidate.id);
expect(deleted).toBeDefined(); expect(deleted).toBeDefined();
expect(deleted?.name).toBe("To Delete"); expect(deleted?.name).toBe("To Delete");
// Verify it's gone // Verify it's gone
const result = getThreadWithCandidates(db, thread.id); const result = await getThreadWithCandidates(db, thread.id);
expect(result?.candidates).toHaveLength(0); expect(result?.candidates).toHaveLength(0);
}); });
it("returns null for non-existent candidate", () => { it("returns null for non-existent candidate", async () => {
const result = deleteCandidate(db, 9999); const result = await deleteCandidate(db, 9999);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("updateThread", () => { describe("updateThread", () => {
it("updates thread name", () => { it("updates thread name", async () => {
const thread = createThread(db, { name: "Original", categoryId: 1 }); const thread = await createThread(db, { name: "Original", categoryId: 1 });
const updated = updateThread(db, thread.id, { name: "Renamed" }); const updated = await updateThread(db, thread.id, { name: "Renamed" });
expect(updated).toBeDefined(); expect(updated).toBeDefined();
expect(updated?.name).toBe("Renamed"); expect(updated?.name).toBe("Renamed");
}); });
it("returns null for non-existent thread", () => { it("returns null for non-existent thread", async () => {
const result = updateThread(db, 9999, { name: "Ghost" }); const result = await updateThread(db, 9999, { name: "Ghost" });
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("deleteThread", () => { describe("deleteThread", () => {
it("removes thread and cascading candidates", () => { it("removes thread and cascading candidates", async () => {
const thread = createThread(db, { name: "To Delete", categoryId: 1 }); const thread = await createThread(db, { name: "To Delete", categoryId: 1 });
createCandidate(db, thread.id, { name: "Candidate", categoryId: 1 }); await createCandidate(db, thread.id, { name: "Candidate", categoryId: 1 });
const deleted = deleteThread(db, thread.id); const deleted = await deleteThread(db, thread.id);
expect(deleted).toBeDefined(); expect(deleted).toBeDefined();
expect(deleted?.name).toBe("To Delete"); expect(deleted?.name).toBe("To Delete");
// Thread and candidates gone // Thread and candidates gone
const result = getThreadWithCandidates(db, thread.id); const result = await getThreadWithCandidates(db, thread.id);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
it("returns null for non-existent thread", () => { it("returns null for non-existent thread", async () => {
const result = deleteThread(db, 9999); const result = await deleteThread(db, 9999);
expect(result).toBeNull(); expect(result).toBeNull();
}); });
}); });
describe("candidate status", () => { describe("candidate status", () => {
it("createCandidate without status returns a candidate with status 'researching'", () => { it("createCandidate without status returns a candidate with status 'researching'", async () => {
const thread = createThread(db, { name: "Test Thread", categoryId: 1 }); const thread = await createThread(db, { name: "Test Thread", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "No Status", name: "No Status",
categoryId: 1, categoryId: 1,
}); });
@@ -293,9 +293,9 @@ describe("Thread Service", () => {
expect(candidate.status).toBe("researching"); expect(candidate.status).toBe("researching");
}); });
it("createCandidate with status 'ordered' returns a candidate with status 'ordered'", () => { it("createCandidate with status 'ordered' returns a candidate with status 'ordered'", async () => {
const thread = createThread(db, { name: "Test Thread", categoryId: 1 }); const thread = await createThread(db, { name: "Test Thread", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Ordered Item", name: "Ordered Item",
categoryId: 1, categoryId: 1,
status: "ordered", status: "ordered",
@@ -304,58 +304,58 @@ describe("Thread Service", () => {
expect(candidate.status).toBe("ordered"); expect(candidate.status).toBe("ordered");
}); });
it("updateCandidate can change status from 'researching' to 'ordered'", () => { it("updateCandidate can change status from 'researching' to 'ordered'", async () => {
const thread = createThread(db, { name: "Test Thread", categoryId: 1 }); const thread = await createThread(db, { name: "Test Thread", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Status Change", name: "Status Change",
categoryId: 1, categoryId: 1,
}); });
expect(candidate.status).toBe("researching"); expect(candidate.status).toBe("researching");
const updated = updateCandidate(db, candidate.id, { const updated = await updateCandidate(db, candidate.id, {
status: "ordered", status: "ordered",
}); });
expect(updated?.status).toBe("ordered"); expect(updated?.status).toBe("ordered");
}); });
it("updateCandidate can change status from 'ordered' to 'arrived'", () => { it("updateCandidate can change status from 'ordered' to 'arrived'", async () => {
const thread = createThread(db, { name: "Test Thread", categoryId: 1 }); const thread = await createThread(db, { name: "Test Thread", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Arriving Item", name: "Arriving Item",
categoryId: 1, categoryId: 1,
status: "ordered", status: "ordered",
}); });
const updated = updateCandidate(db, candidate.id, { const updated = await updateCandidate(db, candidate.id, {
status: "arrived", status: "arrived",
}); });
expect(updated?.status).toBe("arrived"); expect(updated?.status).toBe("arrived");
}); });
it("getThreadWithCandidates includes status field on each candidate", () => { it("getThreadWithCandidates includes status field on each candidate", async () => {
const thread = createThread(db, { name: "Status Thread", categoryId: 1 }); const thread = await createThread(db, { name: "Status Thread", categoryId: 1 });
createCandidate(db, thread.id, { await createCandidate(db, thread.id, {
name: "Candidate A", name: "Candidate A",
categoryId: 1, categoryId: 1,
}); });
createCandidate(db, thread.id, { await createCandidate(db, thread.id, {
name: "Candidate B", name: "Candidate B",
categoryId: 1, categoryId: 1,
status: "ordered", status: "ordered",
}); });
const result = getThreadWithCandidates(db, thread.id); const result = await getThreadWithCandidates(db, thread.id);
expect(result).toBeDefined(); expect(result).toBeDefined();
expect(result?.candidates).toHaveLength(2); expect(result?.candidates).toHaveLength(2);
const candidateA = result?.candidates.find( const candidateA = result?.candidates.find(
(c) => c.name === "Candidate A", (c: any) => c.name === "Candidate A",
); );
const candidateB = result?.candidates.find( const candidateB = result?.candidates.find(
(c) => c.name === "Candidate B", (c: any) => c.name === "Candidate B",
); );
expect(candidateA?.status).toBe("researching"); expect(candidateA?.status).toBe("researching");
@@ -364,43 +364,43 @@ describe("Thread Service", () => {
}); });
describe("sort_order ordering", () => { describe("sort_order ordering", () => {
it("getThreadWithCandidates returns candidates ordered by sort_order ascending", () => { it("getThreadWithCandidates returns candidates ordered by sort_order ascending", async () => {
const thread = createThread(db, { name: "Order Test", categoryId: 1 }); const thread = await createThread(db, { name: "Order Test", categoryId: 1 });
const c1 = createCandidate(db, thread.id, { const c1 = await createCandidate(db, thread.id, {
name: "Candidate 1", name: "Candidate 1",
categoryId: 1, categoryId: 1,
}); });
const c2 = createCandidate(db, thread.id, { const c2 = await createCandidate(db, thread.id, {
name: "Candidate 2", name: "Candidate 2",
categoryId: 1, categoryId: 1,
}); });
const c3 = createCandidate(db, thread.id, { const c3 = await createCandidate(db, thread.id, {
name: "Candidate 3", name: "Candidate 3",
categoryId: 1, categoryId: 1,
}); });
// Manually set sort_orders out of creation order using reorderCandidates // Manually set sort_orders out of creation order using reorderCandidates
reorderCandidates(db, thread.id, [c3.id, c1.id, c2.id]); await reorderCandidates(db, thread.id, [c3.id, c1.id, c2.id]);
const result = getThreadWithCandidates(db, thread.id); const result = await getThreadWithCandidates(db, thread.id);
expect(result).toBeDefined(); expect(result).toBeDefined();
expect(result?.candidates[0].id).toBe(c3.id); expect(result?.candidates[0].id).toBe(c3.id);
expect(result?.candidates[1].id).toBe(c1.id); expect(result?.candidates[1].id).toBe(c1.id);
expect(result?.candidates[2].id).toBe(c2.id); expect(result?.candidates[2].id).toBe(c2.id);
}); });
it("createCandidate assigns sort_order = max existing sort_order + 1000", () => { it("createCandidate assigns sort_order = max existing sort_order + 1000", async () => {
const thread = createThread(db, { name: "Append Test", categoryId: 1 }); const thread = await createThread(db, { name: "Append Test", categoryId: 1 });
// First candidate should get sort_order 1000 // First candidate should get sort_order 1000
const c1 = createCandidate(db, thread.id, { const c1 = await createCandidate(db, thread.id, {
name: "First", name: "First",
categoryId: 1, categoryId: 1,
}); });
expect(c1.sortOrder).toBe(1000); expect(c1.sortOrder).toBe(1000);
// Second candidate should get sort_order 2000 // Second candidate should get sort_order 2000
const c2 = createCandidate(db, thread.id, { const c2 = await createCandidate(db, thread.id, {
name: "Second", name: "Second",
categoryId: 1, categoryId: 1,
}); });
@@ -409,56 +409,56 @@ describe("Thread Service", () => {
}); });
describe("reorderCandidates", () => { describe("reorderCandidates", () => {
it("reorderCandidates updates sort_order so querying returns candidates in new order", () => { it("reorderCandidates updates sort_order so querying returns candidates in new order", async () => {
const thread = createThread(db, { name: "Reorder Test", categoryId: 1 }); const thread = await createThread(db, { name: "Reorder Test", categoryId: 1 });
const c1 = createCandidate(db, thread.id, { const c1 = await createCandidate(db, thread.id, {
name: "Candidate 1", name: "Candidate 1",
categoryId: 1, categoryId: 1,
}); });
const c2 = createCandidate(db, thread.id, { const c2 = await createCandidate(db, thread.id, {
name: "Candidate 2", name: "Candidate 2",
categoryId: 1, categoryId: 1,
}); });
const c3 = createCandidate(db, thread.id, { const c3 = await createCandidate(db, thread.id, {
name: "Candidate 3", name: "Candidate 3",
categoryId: 1, categoryId: 1,
}); });
const result = reorderCandidates(db, thread.id, [c3.id, c1.id, c2.id]); const result = await reorderCandidates(db, thread.id, [c3.id, c1.id, c2.id]);
expect(result.success).toBe(true); expect(result.success).toBe(true);
const fetched = getThreadWithCandidates(db, thread.id); const fetched = await getThreadWithCandidates(db, thread.id);
expect(fetched?.candidates[0].id).toBe(c3.id); expect(fetched?.candidates[0].id).toBe(c3.id);
expect(fetched?.candidates[1].id).toBe(c1.id); expect(fetched?.candidates[1].id).toBe(c1.id);
expect(fetched?.candidates[2].id).toBe(c2.id); expect(fetched?.candidates[2].id).toBe(c2.id);
}); });
it("returns { success: false, error } when thread status is 'resolved'", () => { it("returns { success: false, error } when thread status is 'resolved'", async () => {
const thread = createThread(db, { const thread = await createThread(db, {
name: "Resolved Thread", name: "Resolved Thread",
categoryId: 1, categoryId: 1,
}); });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Winner", name: "Winner",
categoryId: 1, categoryId: 1,
}); });
resolveThread(db, thread.id, candidate.id); await resolveThread(db, thread.id, candidate.id);
const result = reorderCandidates(db, thread.id, [candidate.id]); const result = await reorderCandidates(db, thread.id, [candidate.id]);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toBeDefined(); expect(result.error).toBeDefined();
}); });
it("returns { success: false } when thread does not exist", () => { it("returns { success: false } when thread does not exist", async () => {
const result = reorderCandidates(db, 9999, [1, 2]); const result = await reorderCandidates(db, 9999, [1, 2]);
expect(result.success).toBe(false); expect(result.success).toBe(false);
}); });
}); });
describe("resolveThread", () => { describe("resolveThread", () => {
it("atomically creates collection item from candidate data and archives thread", () => { it("atomically creates collection item from candidate data and archives thread", async () => {
const thread = createThread(db, { name: "Tent Decision", categoryId: 1 }); const thread = await createThread(db, { name: "Tent Decision", categoryId: 1 });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Winner Tent", name: "Winner Tent",
weightGrams: 1200, weightGrams: 1200,
priceCents: 30000, priceCents: 30000,
@@ -467,7 +467,7 @@ describe("Thread Service", () => {
productUrl: "https://example.com/tent", productUrl: "https://example.com/tent",
}); });
const result = resolveThread(db, thread.id, candidate.id); const result = await resolveThread(db, thread.id, candidate.id);
expect(result.success).toBe(true); expect(result.success).toBe(true);
expect(result.item).toBeDefined(); expect(result.item).toBeDefined();
expect(result.item?.name).toBe("Winner Tent"); expect(result.item?.name).toBe("Winner Tent");
@@ -478,44 +478,44 @@ describe("Thread Service", () => {
expect(result.item?.productUrl).toBe("https://example.com/tent"); expect(result.item?.productUrl).toBe("https://example.com/tent");
// Thread should be resolved // Thread should be resolved
const resolved = getThreadWithCandidates(db, thread.id); const resolved = await getThreadWithCandidates(db, thread.id);
expect(resolved?.status).toBe("resolved"); expect(resolved?.status).toBe("resolved");
expect(resolved?.resolvedCandidateId).toBe(candidate.id); expect(resolved?.resolvedCandidateId).toBe(candidate.id);
}); });
it("fails if thread is not active", () => { it("fails if thread is not active", async () => {
const thread = createThread(db, { const thread = await createThread(db, {
name: "Already Resolved", name: "Already Resolved",
categoryId: 1, categoryId: 1,
}); });
const candidate = createCandidate(db, thread.id, { const candidate = await createCandidate(db, thread.id, {
name: "Winner", name: "Winner",
categoryId: 1, categoryId: 1,
}); });
resolveThread(db, thread.id, candidate.id); await resolveThread(db, thread.id, candidate.id);
// Try to resolve again // Try to resolve again
const result = resolveThread(db, thread.id, candidate.id); const result = await resolveThread(db, thread.id, candidate.id);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toBeDefined(); expect(result.error).toBeDefined();
}); });
it("fails if candidate is not in thread", () => { it("fails if candidate is not in thread", async () => {
const thread1 = createThread(db, { name: "Thread 1", categoryId: 1 }); const thread1 = await createThread(db, { name: "Thread 1", categoryId: 1 });
const thread2 = createThread(db, { name: "Thread 2", categoryId: 1 }); const thread2 = await createThread(db, { name: "Thread 2", categoryId: 1 });
const candidate = createCandidate(db, thread2.id, { const candidate = await createCandidate(db, thread2.id, {
name: "Wrong Thread", name: "Wrong Thread",
categoryId: 1, categoryId: 1,
}); });
const result = resolveThread(db, thread1.id, candidate.id); const result = await resolveThread(db, thread1.id, candidate.id);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toBeDefined(); expect(result.error).toBeDefined();
}); });
it("fails if candidate not found", () => { it("fails if candidate not found", async () => {
const thread = createThread(db, { name: "Test", categoryId: 1 }); const thread = await createThread(db, { name: "Test", categoryId: 1 });
const result = resolveThread(db, thread.id, 9999); const result = await resolveThread(db, thread.id, 9999);
expect(result.success).toBe(false); expect(result.success).toBe(false);
expect(result.error).toBeDefined(); expect(result.error).toBeDefined();
}); });

34
tests/services/totals.test.ts
View File

@@ -8,29 +8,29 @@ import {
import { createTestDb } from "../helpers/db.ts"; import { createTestDb } from "../helpers/db.ts";
describe("Totals Service", () => { describe("Totals Service", () => {
let db: ReturnType<typeof createTestDb>; let db: any;
beforeEach(() => { beforeEach(async () => {
db = createTestDb(); db = await createTestDb();
}); });
describe("getCategoryTotals", () => { describe("getCategoryTotals", () => {
it("returns weight sum, cost sum, item count per category", () => { it("returns weight sum, cost sum, item count per category", async () => {
const shelter = createCategory(db, { name: "Shelter", icon: "tent" }); const shelter = await createCategory(db, { name: "Shelter", icon: "tent" });
createItem(db, { await createItem(db, {
name: "Tent", name: "Tent",
weightGrams: 1200, weightGrams: 1200,
priceCents: 35000, priceCents: 35000,
categoryId: shelter?.id, categoryId: shelter?.id,
}); });
createItem(db, { await createItem(db, {
name: "Tarp", name: "Tarp",
weightGrams: 300, weightGrams: 300,
priceCents: 8000, priceCents: 8000,
categoryId: shelter?.id, categoryId: shelter?.id,
}); });
const totals = getCategoryTotals(db); const totals = await getCategoryTotals(db);
expect(totals).toHaveLength(1); // Only Shelter has items expect(totals).toHaveLength(1); // Only Shelter has items
expect(totals[0].categoryName).toBe("Shelter"); expect(totals[0].categoryName).toBe("Shelter");
expect(totals[0].totalWeight).toBe(1500); expect(totals[0].totalWeight).toBe(1500);
@@ -38,38 +38,38 @@ describe("Totals Service", () => {
expect(totals[0].itemCount).toBe(2); expect(totals[0].itemCount).toBe(2);
}); });
it("excludes empty categories (no items)", () => { it("excludes empty categories (no items)", async () => {
createCategory(db, { name: "Shelter", icon: "tent" }); await createCategory(db, { name: "Shelter", icon: "tent" });
// No items added // No items added
const totals = getCategoryTotals(db); const totals = await getCategoryTotals(db);
expect(totals).toHaveLength(0); expect(totals).toHaveLength(0);
}); });
}); });
describe("getGlobalTotals", () => { describe("getGlobalTotals", () => {
it("returns overall weight, cost, count", () => { it("returns overall weight, cost, count", async () => {
createItem(db, { await createItem(db, {
name: "Tent", name: "Tent",
weightGrams: 1200, weightGrams: 1200,
priceCents: 35000, priceCents: 35000,
categoryId: 1, categoryId: 1,
}); });
createItem(db, { await createItem(db, {
name: "Spork", name: "Spork",
weightGrams: 20, weightGrams: 20,
priceCents: 500, priceCents: 500,
categoryId: 1, categoryId: 1,
}); });
const totals = getGlobalTotals(db); const totals = await getGlobalTotals(db);
expect(totals).toBeDefined(); expect(totals).toBeDefined();
expect(totals?.totalWeight).toBe(1220); expect(totals?.totalWeight).toBe(1220);
expect(totals?.totalCost).toBe(35500); expect(totals?.totalCost).toBe(35500);
expect(totals?.itemCount).toBe(2); expect(totals?.itemCount).toBe(2);
}); });
it("returns zeros when no items exist", () => { it("returns zeros when no items exist", async () => {
const totals = getGlobalTotals(db); const totals = await getGlobalTotals(db);
expect(totals).toBeDefined(); expect(totals).toBeDefined();
expect(totals?.totalWeight).toBe(0); expect(totals?.totalWeight).toBe(0);
expect(totals?.totalCost).toBe(0); expect(totals?.totalCost).toBe(0);