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

chore: auto-fix Biome formatting and configure lint rules
All checks were successful
CI / ci (push) Successful in 15s
Details

Browse Source 
Run biome check --write --unsafe to fix tabs, import ordering, and
non-null assertions across entire codebase. Disable a11y rules not
applicable to this single-user app. Exclude auto-generated routeTree.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
Jean-Luc Makiola
2026-03-15 19:51:34 +01:00
parent 4d0452b7b3
commit b496462df5
63 changed files with 4752 additions and 4672 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1,280 +1,285 @@
import { describe, it, expect, beforeEach } from "bun:test";
import { createTestDb } from "../helpers/db.ts";
import { beforeEach, describe, expect, it } from "bun:test";
import {
createThread,
getAllThreads,
getThreadWithCandidates,
createCandidate,
updateCandidate,
deleteCandidate,
updateThread,
deleteThread,
resolveThread,
createCandidate,
createThread,
deleteCandidate,
deleteThread,
getAllThreads,
getThreadWithCandidates,
resolveThread,
updateCandidate,
updateThread,
} from "../../src/server/services/thread.service.ts";
import { createItem } from "../../src/server/services/item.service.ts";
import { createTestDb } from "../helpers/db.ts";
describe("Thread Service", () => {
let db: ReturnType<typeof createTestDb>;
let db: ReturnType<typeof createTestDb>;
beforeEach(() => {
db = createTestDb();
});
beforeEach(() => {
db = createTestDb();
});
describe("createThread", () => {
it("creates thread with name, returns thread with id/status/timestamps", () => {
const thread = createThread(db, { name: "New Tent", categoryId: 1 });
describe("createThread", () => {
it("creates thread with name, returns thread with id/status/timestamps", () => {
const thread = createThread(db, { name: "New Tent", categoryId: 1 });
expect(thread).toBeDefined();
expect(thread.id).toBeGreaterThan(0);
expect(thread.name).toBe("New Tent");
expect(thread.status).toBe("active");
expect(thread.resolvedCandidateId).toBeNull();
expect(thread.createdAt).toBeDefined();
expect(thread.updatedAt).toBeDefined();
});
});
expect(thread).toBeDefined();
expect(thread.id).toBeGreaterThan(0);
expect(thread.name).toBe("New Tent");
expect(thread.status).toBe("active");
expect(thread.resolvedCandidateId).toBeNull();
expect(thread.createdAt).toBeDefined();
expect(thread.updatedAt).toBeDefined();
});
});
describe("getAllThreads", () => {
it("returns active threads with candidateCount and price range", () => {
const thread = createThread(db, { name: "Backpack Options", categoryId: 1 });
createCandidate(db, thread.id, {
name: "Pack A",
categoryId: 1,
priceCents: 20000,
});
createCandidate(db, thread.id, {
name: "Pack B",
categoryId: 1,
priceCents: 35000,
});
describe("getAllThreads", () => {
it("returns active threads with candidateCount and price range", () => {
const thread = createThread(db, {
name: "Backpack Options",
categoryId: 1,
});
createCandidate(db, thread.id, {
name: "Pack A",
categoryId: 1,
priceCents: 20000,
});
createCandidate(db, thread.id, {
name: "Pack B",
categoryId: 1,
priceCents: 35000,
});
const threads = getAllThreads(db);
expect(threads).toHaveLength(1);
expect(threads[0].name).toBe("Backpack Options");
expect(threads[0].candidateCount).toBe(2);
expect(threads[0].minPriceCents).toBe(20000);
expect(threads[0].maxPriceCents).toBe(35000);
});
const threads = getAllThreads(db);
expect(threads).toHaveLength(1);
expect(threads[0].name).toBe("Backpack Options");
expect(threads[0].candidateCount).toBe(2);
expect(threads[0].minPriceCents).toBe(20000);
expect(threads[0].maxPriceCents).toBe(35000);
});
it("excludes resolved threads by default", () => {
const t1 = createThread(db, { name: "Active Thread", categoryId: 1 });
const t2 = createThread(db, { name: "Resolved Thread", categoryId: 1 });
const candidate = createCandidate(db, t2.id, {
name: "Winner",
categoryId: 1,
});
resolveThread(db, t2.id, candidate.id);
it("excludes resolved threads by default", () => {
const _t1 = createThread(db, { name: "Active Thread", categoryId: 1 });
const t2 = createThread(db, { name: "Resolved Thread", categoryId: 1 });
const candidate = createCandidate(db, t2.id, {
name: "Winner",
categoryId: 1,
});
resolveThread(db, t2.id, candidate.id);
const active = getAllThreads(db);
expect(active).toHaveLength(1);
expect(active[0].name).toBe("Active Thread");
});
const active = getAllThreads(db);
expect(active).toHaveLength(1);
expect(active[0].name).toBe("Active Thread");
});
it("includes resolved threads when includeResolved=true", () => {
const t1 = createThread(db, { name: "Active Thread", categoryId: 1 });
const t2 = createThread(db, { name: "Resolved Thread", categoryId: 1 });
const candidate = createCandidate(db, t2.id, {
name: "Winner",
categoryId: 1,
});
resolveThread(db, t2.id, candidate.id);
it("includes resolved threads when includeResolved=true", () => {
const _t1 = createThread(db, { name: "Active Thread", categoryId: 1 });
const t2 = createThread(db, { name: "Resolved Thread", categoryId: 1 });
const candidate = createCandidate(db, t2.id, {
name: "Winner",
categoryId: 1,
});
resolveThread(db, t2.id, candidate.id);
const all = getAllThreads(db, true);
expect(all).toHaveLength(2);
});
});
const all = getAllThreads(db, true);
expect(all).toHaveLength(2);
});
});
describe("getThreadWithCandidates", () => {
it("returns thread with nested candidates array including category info", () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 });
createCandidate(db, thread.id, {
name: "Tent A",
categoryId: 1,
weightGrams: 1200,
priceCents: 30000,
});
describe("getThreadWithCandidates", () => {
it("returns thread with nested candidates array including category info", () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 });
createCandidate(db, thread.id, {
name: "Tent A",
categoryId: 1,
weightGrams: 1200,
priceCents: 30000,
});
const result = getThreadWithCandidates(db, thread.id);
expect(result).toBeDefined();
expect(result!.name).toBe("Tent Options");
expect(result!.candidates).toHaveLength(1);
expect(result!.candidates[0].name).toBe("Tent A");
expect(result!.candidates[0].categoryName).toBe("Uncategorized");
expect(result!.candidates[0].categoryIcon).toBeDefined();
});
const result = getThreadWithCandidates(db, thread.id);
expect(result).toBeDefined();
expect(result?.name).toBe("Tent Options");
expect(result?.candidates).toHaveLength(1);
expect(result?.candidates[0].name).toBe("Tent A");
expect(result?.candidates[0].categoryName).toBe("Uncategorized");
expect(result?.candidates[0].categoryIcon).toBeDefined();
});
it("returns null for non-existent thread", () => {
const result = getThreadWithCandidates(db, 9999);
expect(result).toBeNull();
});
});
it("returns null for non-existent thread", () => {
const result = getThreadWithCandidates(db, 9999);
expect(result).toBeNull();
});
});
describe("createCandidate", () => {
it("adds candidate to thread with all item-compatible fields", () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Tent A",
weightGrams: 1200,
priceCents: 30000,
categoryId: 1,
notes: "Ultralight 2-person",
productUrl: "https://example.com/tent",
});
describe("createCandidate", () => {
it("adds candidate to thread with all item-compatible fields", () => {
const thread = createThread(db, { name: "Tent Options", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Tent A",
weightGrams: 1200,
priceCents: 30000,
categoryId: 1,
notes: "Ultralight 2-person",
productUrl: "https://example.com/tent",
});
expect(candidate).toBeDefined();
expect(candidate.id).toBeGreaterThan(0);
expect(candidate.threadId).toBe(thread.id);
expect(candidate.name).toBe("Tent A");
expect(candidate.weightGrams).toBe(1200);
expect(candidate.priceCents).toBe(30000);
expect(candidate.categoryId).toBe(1);
expect(candidate.notes).toBe("Ultralight 2-person");
expect(candidate.productUrl).toBe("https://example.com/tent");
});
});
expect(candidate).toBeDefined();
expect(candidate.id).toBeGreaterThan(0);
expect(candidate.threadId).toBe(thread.id);
expect(candidate.name).toBe("Tent A");
expect(candidate.weightGrams).toBe(1200);
expect(candidate.priceCents).toBe(30000);
expect(candidate.categoryId).toBe(1);
expect(candidate.notes).toBe("Ultralight 2-person");
expect(candidate.productUrl).toBe("https://example.com/tent");
});
});
describe("updateCandidate", () => {
it("updates candidate fields, returns updated candidate", () => {
const thread = createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Original",
categoryId: 1,
});
describe("updateCandidate", () => {
it("updates candidate fields, returns updated candidate", () => {
const thread = createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Original",
categoryId: 1,
});
const updated = updateCandidate(db, candidate.id, {
name: "Updated Name",
priceCents: 15000,
});
const updated = updateCandidate(db, candidate.id, {
name: "Updated Name",
priceCents: 15000,
});
expect(updated).toBeDefined();
expect(updated!.name).toBe("Updated Name");
expect(updated!.priceCents).toBe(15000);
});
expect(updated).toBeDefined();
expect(updated?.name).toBe("Updated Name");
expect(updated?.priceCents).toBe(15000);
});
it("returns null for non-existent candidate", () => {
const result = updateCandidate(db, 9999, { name: "Ghost" });
expect(result).toBeNull();
});
});
it("returns null for non-existent candidate", () => {
const result = updateCandidate(db, 9999, { name: "Ghost" });
expect(result).toBeNull();
});
});
describe("deleteCandidate", () => {
it("removes candidate, returns deleted candidate", () => {
const thread = createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "To Delete",
categoryId: 1,
});
describe("deleteCandidate", () => {
it("removes candidate, returns deleted candidate", () => {
const thread = createThread(db, { name: "Test", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "To Delete",
categoryId: 1,
});
const deleted = deleteCandidate(db, candidate.id);
expect(deleted).toBeDefined();
expect(deleted!.name).toBe("To Delete");
const deleted = deleteCandidate(db, candidate.id);
expect(deleted).toBeDefined();
expect(deleted?.name).toBe("To Delete");
// Verify it's gone
const result = getThreadWithCandidates(db, thread.id);
expect(result!.candidates).toHaveLength(0);
});
// Verify it's gone
const result = getThreadWithCandidates(db, thread.id);
expect(result?.candidates).toHaveLength(0);
});
it("returns null for non-existent candidate", () => {
const result = deleteCandidate(db, 9999);
expect(result).toBeNull();
});
});
it("returns null for non-existent candidate", () => {
const result = deleteCandidate(db, 9999);
expect(result).toBeNull();
});
});
describe("updateThread", () => {
it("updates thread name", () => {
const thread = createThread(db, { name: "Original", categoryId: 1 });
const updated = updateThread(db, thread.id, { name: "Renamed" });
describe("updateThread", () => {
it("updates thread name", () => {
const thread = createThread(db, { name: "Original", categoryId: 1 });
const updated = updateThread(db, thread.id, { name: "Renamed" });
expect(updated).toBeDefined();
expect(updated!.name).toBe("Renamed");
});
expect(updated).toBeDefined();
expect(updated?.name).toBe("Renamed");
});
it("returns null for non-existent thread", () => {
const result = updateThread(db, 9999, { name: "Ghost" });
expect(result).toBeNull();
});
});
it("returns null for non-existent thread", () => {
const result = updateThread(db, 9999, { name: "Ghost" });
expect(result).toBeNull();
});
});
describe("deleteThread", () => {
it("removes thread and cascading candidates", () => {
const thread = createThread(db, { name: "To Delete", categoryId: 1 });
createCandidate(db, thread.id, { name: "Candidate", categoryId: 1 });
describe("deleteThread", () => {
it("removes thread and cascading candidates", () => {
const thread = createThread(db, { name: "To Delete", categoryId: 1 });
createCandidate(db, thread.id, { name: "Candidate", categoryId: 1 });
const deleted = deleteThread(db, thread.id);
expect(deleted).toBeDefined();
expect(deleted!.name).toBe("To Delete");
const deleted = deleteThread(db, thread.id);
expect(deleted).toBeDefined();
expect(deleted?.name).toBe("To Delete");
// Thread and candidates gone
const result = getThreadWithCandidates(db, thread.id);
expect(result).toBeNull();
});
// Thread and candidates gone
const result = getThreadWithCandidates(db, thread.id);
expect(result).toBeNull();
});
it("returns null for non-existent thread", () => {
const result = deleteThread(db, 9999);
expect(result).toBeNull();
});
});
it("returns null for non-existent thread", () => {
const result = deleteThread(db, 9999);
expect(result).toBeNull();
});
});
describe("resolveThread", () => {
it("atomically creates collection item from candidate data and archives thread", () => {
const thread = createThread(db, { name: "Tent Decision", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Winner Tent",
weightGrams: 1200,
priceCents: 30000,
categoryId: 1,
notes: "Best choice",
productUrl: "https://example.com/tent",
});
describe("resolveThread", () => {
it("atomically creates collection item from candidate data and archives thread", () => {
const thread = createThread(db, { name: "Tent Decision", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Winner Tent",
weightGrams: 1200,
priceCents: 30000,
categoryId: 1,
notes: "Best choice",
productUrl: "https://example.com/tent",
});
const result = resolveThread(db, thread.id, candidate.id);
expect(result.success).toBe(true);
expect(result.item).toBeDefined();
expect(result.item!.name).toBe("Winner Tent");
expect(result.item!.weightGrams).toBe(1200);
expect(result.item!.priceCents).toBe(30000);
expect(result.item!.categoryId).toBe(1);
expect(result.item!.notes).toBe("Best choice");
expect(result.item!.productUrl).toBe("https://example.com/tent");
const result = resolveThread(db, thread.id, candidate.id);
expect(result.success).toBe(true);
expect(result.item).toBeDefined();
expect(result.item?.name).toBe("Winner Tent");
expect(result.item?.weightGrams).toBe(1200);
expect(result.item?.priceCents).toBe(30000);
expect(result.item?.categoryId).toBe(1);
expect(result.item?.notes).toBe("Best choice");
expect(result.item?.productUrl).toBe("https://example.com/tent");
// Thread should be resolved
const resolved = getThreadWithCandidates(db, thread.id);
expect(resolved!.status).toBe("resolved");
expect(resolved!.resolvedCandidateId).toBe(candidate.id);
});
// Thread should be resolved
const resolved = getThreadWithCandidates(db, thread.id);
expect(resolved?.status).toBe("resolved");
expect(resolved?.resolvedCandidateId).toBe(candidate.id);
});
it("fails if thread is not active", () => {
const thread = createThread(db, { name: "Already Resolved", categoryId: 1 });
const candidate = createCandidate(db, thread.id, {
name: "Winner",
categoryId: 1,
});
resolveThread(db, thread.id, candidate.id);
it("fails if thread is not active", () => {
const thread = createThread(db, {
name: "Already Resolved",
categoryId: 1,
});
const candidate = createCandidate(db, thread.id, {
name: "Winner",
categoryId: 1,
});
resolveThread(db, thread.id, candidate.id);
// Try to resolve again
const result = resolveThread(db, thread.id, candidate.id);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
// Try to resolve again
const result = resolveThread(db, thread.id, candidate.id);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
it("fails if candidate is not in thread", () => {
const thread1 = createThread(db, { name: "Thread 1", categoryId: 1 });
const thread2 = createThread(db, { name: "Thread 2", categoryId: 1 });
const candidate = createCandidate(db, thread2.id, {
name: "Wrong Thread",
categoryId: 1,
});
it("fails if candidate is not in thread", () => {
const thread1 = createThread(db, { name: "Thread 1", categoryId: 1 });
const thread2 = createThread(db, { name: "Thread 2", categoryId: 1 });
const candidate = createCandidate(db, thread2.id, {
name: "Wrong Thread",
categoryId: 1,
});
const result = resolveThread(db, thread1.id, candidate.id);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
const result = resolveThread(db, thread1.id, candidate.id);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
it("fails if candidate not found", () => {
const thread = createThread(db, { name: "Test", categoryId: 1 });
const result = resolveThread(db, thread.id, 9999);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
});
it("fails if candidate not found", () => {
const thread = createThread(db, { name: "Test", categoryId: 1 });
const result = resolveThread(db, thread.id, 9999);
expect(result.success).toBe(false);
expect(result.error).toBeDefined();
});
});
});