test(03-01): add failing tests for setup backend

- Add setups and setupItems tables to DB schema
- Add Zod schemas for setup create/update/sync
- Add Setup/SetupItem types to shared types
- Add setup tables to test helper
- Write service and route tests (RED - no implementation yet)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
This commit is contained in:
2026-03-15 12:42:15 +01:00
parent 6b773c6f79
commit 1e4e74f8d2
6 changed files with 483 additions and 1 deletions

View File

@@ -58,6 +58,23 @@ export function createTestDb() {
)
`);
sqlite.run(`
CREATE TABLE setups (
id INTEGER PRIMARY KEY AUTOINCREMENT,
name TEXT NOT NULL,
created_at INTEGER NOT NULL DEFAULT (unixepoch()),
updated_at INTEGER NOT NULL DEFAULT (unixepoch())
)
`);
sqlite.run(`
CREATE TABLE setup_items (
id INTEGER PRIMARY KEY AUTOINCREMENT,
setup_id INTEGER NOT NULL REFERENCES setups(id) ON DELETE CASCADE,
item_id INTEGER NOT NULL REFERENCES items(id) ON DELETE CASCADE
)
`);
sqlite.run(`
CREATE TABLE settings (
key TEXT PRIMARY KEY,

229
tests/routes/setups.test.ts Normal file
View File

@@ -0,0 +1,229 @@
import { describe, it, expect, beforeEach } from "bun:test";
import { Hono } from "hono";
import { createTestDb } from "../helpers/db.ts";
import { setupRoutes } from "../../src/server/routes/setups.ts";
import { itemRoutes } from "../../src/server/routes/items.ts";
function createTestApp() {
const db = createTestDb();
const app = new Hono();
app.use("*", async (c, next) => {
c.set("db", db);
await next();
});
app.route("/api/setups", setupRoutes);
app.route("/api/items", itemRoutes);
return { app, db };
}
async function createSetupViaAPI(app: Hono, name: string) {
const res = await app.request("/api/setups", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name }),
});
return res.json();
}
async function createItemViaAPI(app: Hono, data: any) {
const res = await app.request("/api/items", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify(data),
});
return res.json();
}
describe("Setup Routes", () => {
let app: Hono;
beforeEach(() => {
const testApp = createTestApp();
app = testApp.app;
});
describe("POST /api/setups", () => {
it("with valid body returns 201 + setup object", async () => {
const res = await app.request("/api/setups", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name: "Day Hike" }),
});
expect(res.status).toBe(201);
const body = await res.json();
expect(body.name).toBe("Day Hike");
expect(body.id).toBeGreaterThan(0);
});
it("with empty name returns 400", async () => {
const res = await app.request("/api/setups", {
method: "POST",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name: "" }),
});
expect(res.status).toBe(400);
});
});
describe("GET /api/setups", () => {
it("returns array of setups with totals", async () => {
const setup = await createSetupViaAPI(app, "Backpacking");
const item = await createItemViaAPI(app, {
name: "Tent",
categoryId: 1,
weightGrams: 1200,
priceCents: 30000,
});
// Sync items
await app.request(`/api/setups/${setup.id}/items`, {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ itemIds: [item.id] }),
});
const res = await app.request("/api/setups");
expect(res.status).toBe(200);
const body = await res.json();
expect(Array.isArray(body)).toBe(true);
expect(body.length).toBeGreaterThanOrEqual(1);
expect(body[0].itemCount).toBeDefined();
expect(body[0].totalWeight).toBeDefined();
expect(body[0].totalCost).toBeDefined();
});
});
describe("GET /api/setups/:id", () => {
it("returns setup with items", async () => {
const setup = await createSetupViaAPI(app, "Day Hike");
const item = await createItemViaAPI(app, {
name: "Water Bottle",
categoryId: 1,
weightGrams: 200,
priceCents: 2500,
});
await app.request(`/api/setups/${setup.id}/items`, {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ itemIds: [item.id] }),
});
const res = await app.request(`/api/setups/${setup.id}`);
expect(res.status).toBe(200);
const body = await res.json();
expect(body.name).toBe("Day Hike");
expect(body.items).toHaveLength(1);
expect(body.items[0].name).toBe("Water Bottle");
});
it("returns 404 for non-existent setup", async () => {
const res = await app.request("/api/setups/9999");
expect(res.status).toBe(404);
});
});
describe("PUT /api/setups/:id", () => {
it("updates setup name", async () => {
const setup = await createSetupViaAPI(app, "Original");
const res = await app.request(`/api/setups/${setup.id}`, {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name: "Renamed" }),
});
expect(res.status).toBe(200);
const body = await res.json();
expect(body.name).toBe("Renamed");
});
it("returns 404 for non-existent setup", async () => {
const res = await app.request("/api/setups/9999", {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ name: "Ghost" }),
});
expect(res.status).toBe(404);
});
});
describe("DELETE /api/setups/:id", () => {
it("removes setup", async () => {
const setup = await createSetupViaAPI(app, "To Delete");
const res = await app.request(`/api/setups/${setup.id}`, {
method: "DELETE",
});
expect(res.status).toBe(200);
const body = await res.json();
expect(body.success).toBe(true);
// Verify gone
const getRes = await app.request(`/api/setups/${setup.id}`);
expect(getRes.status).toBe(404);
});
it("returns 404 for non-existent setup", async () => {
const res = await app.request("/api/setups/9999", { method: "DELETE" });
expect(res.status).toBe(404);
});
});
describe("PUT /api/setups/:id/items", () => {
it("syncs items to setup", async () => {
const setup = await createSetupViaAPI(app, "Kit");
const item1 = await createItemViaAPI(app, { name: "Item 1", categoryId: 1 });
const item2 = await createItemViaAPI(app, { name: "Item 2", categoryId: 1 });
const res = await app.request(`/api/setups/${setup.id}/items`, {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ itemIds: [item1.id, item2.id] }),
});
expect(res.status).toBe(200);
const body = await res.json();
expect(body.success).toBe(true);
// Verify items
const getRes = await app.request(`/api/setups/${setup.id}`);
const getBody = await getRes.json();
expect(getBody.items).toHaveLength(2);
});
});
describe("DELETE /api/setups/:id/items/:itemId", () => {
it("removes single item from setup", async () => {
const setup = await createSetupViaAPI(app, "Kit");
const item1 = await createItemViaAPI(app, { name: "Item 1", categoryId: 1 });
const item2 = await createItemViaAPI(app, { name: "Item 2", categoryId: 1 });
// Sync both items
await app.request(`/api/setups/${setup.id}/items`, {
method: "PUT",
headers: { "Content-Type": "application/json" },
body: JSON.stringify({ itemIds: [item1.id, item2.id] }),
});
// Remove one
const res = await app.request(`/api/setups/${setup.id}/items/${item1.id}`, {
method: "DELETE",
});
expect(res.status).toBe(200);
// Verify only one remains
const getRes = await app.request(`/api/setups/${setup.id}`);
const getBody = await getRes.json();
expect(getBody.items).toHaveLength(1);
expect(getBody.items[0].name).toBe("Item 2");
});
});
});

View File

@@ -0,0 +1,192 @@
import { describe, it, expect, beforeEach } from "bun:test";
import { createTestDb } from "../helpers/db.ts";
import {
getAllSetups,
getSetupWithItems,
createSetup,
updateSetup,
deleteSetup,
syncSetupItems,
removeSetupItem,
} from "../../src/server/services/setup.service.ts";
import { createItem } from "../../src/server/services/item.service.ts";
describe("Setup Service", () => {
let db: ReturnType<typeof createTestDb>;
beforeEach(() => {
db = createTestDb();
});
describe("createSetup", () => {
it("creates setup with name, returns setup with id/timestamps", () => {
const setup = createSetup(db, { name: "Day Hike" });
expect(setup).toBeDefined();
expect(setup.id).toBeGreaterThan(0);
expect(setup.name).toBe("Day Hike");
expect(setup.createdAt).toBeDefined();
expect(setup.updatedAt).toBeDefined();
});
});
describe("getAllSetups", () => {
it("returns setups with itemCount, totalWeight, totalCost", () => {
const setup = createSetup(db, { name: "Backpacking" });
const item1 = createItem(db, {
name: "Tent",
categoryId: 1,
weightGrams: 1200,
priceCents: 30000,
});
const item2 = createItem(db, {
name: "Sleeping Bag",
categoryId: 1,
weightGrams: 800,
priceCents: 20000,
});
syncSetupItems(db, setup.id, [item1.id, item2.id]);
const setups = getAllSetups(db);
expect(setups).toHaveLength(1);
expect(setups[0].name).toBe("Backpacking");
expect(setups[0].itemCount).toBe(2);
expect(setups[0].totalWeight).toBe(2000);
expect(setups[0].totalCost).toBe(50000);
});
it("returns 0 for weight/cost when setup has no items", () => {
createSetup(db, { name: "Empty Setup" });
const setups = getAllSetups(db);
expect(setups).toHaveLength(1);
expect(setups[0].itemCount).toBe(0);
expect(setups[0].totalWeight).toBe(0);
expect(setups[0].totalCost).toBe(0);
});
});
describe("getSetupWithItems", () => {
it("returns setup with full item details and category info", () => {
const setup = createSetup(db, { name: "Day Hike" });
const item = createItem(db, {
name: "Water Bottle",
categoryId: 1,
weightGrams: 200,
priceCents: 2500,
});
syncSetupItems(db, setup.id, [item.id]);
const result = getSetupWithItems(db, setup.id);
expect(result).toBeDefined();
expect(result!.name).toBe("Day Hike");
expect(result!.items).toHaveLength(1);
expect(result!.items[0].name).toBe("Water Bottle");
expect(result!.items[0].categoryName).toBe("Uncategorized");
expect(result!.items[0].categoryEmoji).toBeDefined();
});
it("returns null for non-existent setup", () => {
const result = getSetupWithItems(db, 9999);
expect(result).toBeNull();
});
});
describe("updateSetup", () => {
it("updates setup name, returns updated setup", () => {
const setup = createSetup(db, { name: "Original" });
const updated = updateSetup(db, setup.id, { name: "Renamed" });
expect(updated).toBeDefined();
expect(updated!.name).toBe("Renamed");
});
it("returns null for non-existent setup", () => {
const result = updateSetup(db, 9999, { name: "Ghost" });
expect(result).toBeNull();
});
});
describe("deleteSetup", () => {
it("removes setup and cascades to setup_items", () => {
const setup = createSetup(db, { name: "To Delete" });
const item = createItem(db, { name: "Item", categoryId: 1 });
syncSetupItems(db, setup.id, [item.id]);
const deleted = deleteSetup(db, setup.id);
expect(deleted).toBe(true);
// Setup gone
const result = getSetupWithItems(db, setup.id);
expect(result).toBeNull();
});
it("returns false for non-existent setup", () => {
const result = deleteSetup(db, 9999);
expect(result).toBe(false);
});
});
describe("syncSetupItems", () => {
it("sets items for a setup (delete-all + re-insert)", () => {
const setup = createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 });
const item2 = createItem(db, { name: "Item 2", categoryId: 1 });
const item3 = createItem(db, { name: "Item 3", categoryId: 1 });
// Initial sync
syncSetupItems(db, setup.id, [item1.id, item2.id]);
let result = getSetupWithItems(db, setup.id);
expect(result!.items).toHaveLength(2);
// Re-sync with different items
syncSetupItems(db, setup.id, [item2.id, item3.id]);
result = getSetupWithItems(db, setup.id);
expect(result!.items).toHaveLength(2);
const names = result!.items.map((i: any) => i.name).sort();
expect(names).toEqual(["Item 2", "Item 3"]);
});
it("syncing with empty array clears all items", () => {
const setup = createSetup(db, { name: "Kit" });
const item = createItem(db, { name: "Item", categoryId: 1 });
syncSetupItems(db, setup.id, [item.id]);
syncSetupItems(db, setup.id, []);
const result = getSetupWithItems(db, setup.id);
expect(result!.items).toHaveLength(0);
});
});
describe("removeSetupItem", () => {
it("removes single item from setup", () => {
const setup = createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 });
const item2 = createItem(db, { name: "Item 2", categoryId: 1 });
syncSetupItems(db, setup.id, [item1.id, item2.id]);
removeSetupItem(db, setup.id, item1.id);
const result = getSetupWithItems(db, setup.id);
expect(result!.items).toHaveLength(1);
expect(result!.items[0].name).toBe("Item 2");
});
});
describe("cascade behavior", () => {
it("deleting a collection item removes it from all setups", () => {
const setup = createSetup(db, { name: "Kit" });
const item1 = createItem(db, { name: "Item 1", categoryId: 1 });
const item2 = createItem(db, { name: "Item 2", categoryId: 1 });
syncSetupItems(db, setup.id, [item1.id, item2.id]);
// Delete item1 from collection (need direct DB access)
const { items: itemsTable } = require("../../src/db/schema.ts");
const { eq } = require("drizzle-orm");
db.delete(itemsTable).where(eq(itemsTable.id, item1.id)).run();
const result = getSetupWithItems(db, setup.id);
expect(result!.items).toHaveLength(1);
expect(result!.items[0].name).toBe("Item 2");
});
});
});