Sven (AAMOS AI)
335 lines
11 KiB
TypeScript
335 lines
11 KiB
TypeScript
import "./setup-env.js";
|
|
import { describe, expect, it, beforeAll, afterAll } from "vitest";
|
|
import { and, eq, inArray } from "drizzle-orm";
|
|
import { buildServer } from "../src/server.js";
|
|
import { loadConfig } from "../src/config.js";
|
|
import { createDatabase, closeDatabase, schema } from "@app/database";
|
|
|
|
const testDb = createDatabase(process.env.TEST_DATABASE_URL!);
|
|
const config = loadConfig();
|
|
|
|
const emails = {
|
|
patch: "memory-patch@example.invalid",
|
|
consent: "memory-consent@example.invalid",
|
|
privacyA: "memory-privacy-a@example.invalid",
|
|
privacyB: "memory-privacy-b@example.invalid",
|
|
};
|
|
|
|
describe("/v1/me/memory", () => {
|
|
let app: Awaited<ReturnType<typeof buildServer>>;
|
|
|
|
beforeAll(async () => {
|
|
app = await buildServer(config);
|
|
await app.ready();
|
|
await cleanupAll();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await cleanupAll();
|
|
await closeDatabase();
|
|
await app.close();
|
|
});
|
|
|
|
async function cleanupAll() {
|
|
const allEmails = Object.values(emails);
|
|
const existing = await testDb.db
|
|
.select({ id: schema.users.id })
|
|
.from(schema.users)
|
|
.where(inArray(schema.users.email, allEmails));
|
|
for (const u of existing) {
|
|
await testDb.db.delete(schema.memoryItems).where(eq(schema.memoryItems.userId, u.id));
|
|
await testDb.db.delete(schema.tasteSignals).where(eq(schema.tasteSignals.userId, u.id));
|
|
await testDb.db.delete(schema.userConsents).where(eq(schema.userConsents.userId, u.id));
|
|
await testDb.db.delete(schema.userPreferences).where(eq(schema.userPreferences.userId, u.id));
|
|
await testDb.db
|
|
.delete(schema.householdMembers)
|
|
.where(eq(schema.householdMembers.userId, u.id));
|
|
const ownedHouseholds = await testDb.db
|
|
.select({ id: schema.households.id })
|
|
.from(schema.households)
|
|
.innerJoin(
|
|
schema.householdMembers,
|
|
eq(schema.householdMembers.householdId, schema.households.id),
|
|
)
|
|
.where(
|
|
and(eq(schema.householdMembers.userId, u.id), eq(schema.householdMembers.role, "owner")),
|
|
);
|
|
for (const h of ownedHouseholds) {
|
|
await testDb.db
|
|
.delete(schema.storageLocations)
|
|
.where(eq(schema.storageLocations.householdId, h.id));
|
|
await testDb.db.delete(schema.households).where(eq(schema.households.id, h.id));
|
|
}
|
|
await testDb.db.delete(schema.users).where(eq(schema.users.id, u.id));
|
|
}
|
|
}
|
|
|
|
async function registerUser(email: string) {
|
|
const res = await app.inject({
|
|
method: "POST",
|
|
url: "/v1/auth/register",
|
|
payload: { email, password: "Password123!", displayName: "Memory Test" },
|
|
});
|
|
const body = JSON.parse(res.body) as { accessToken: string };
|
|
const token = body.accessToken;
|
|
const userId = (JSON.parse(atob(token.split(".")[1]!)) as { sub: string }).sub;
|
|
await app.inject({
|
|
method: "POST",
|
|
url: "/v1/onboarding/quick-start",
|
|
headers: { authorization: `Bearer ${token}` },
|
|
payload: { goals: ["cook_more"], precisionMode: "simple" },
|
|
});
|
|
return { token, userId };
|
|
}
|
|
|
|
it("PATCH /v1/me/memory/:id ändrar origin till user_stated", async () => {
|
|
const { token, userId } = await registerUser(emails.patch);
|
|
const [item] = await testDb.db
|
|
.insert(schema.memoryItems)
|
|
.values({
|
|
userId,
|
|
kind: "structured_fact",
|
|
key: "likes-pasta",
|
|
summarySv: "Gillar pasta",
|
|
origin: "ai_inferred",
|
|
confidence: 0.5,
|
|
})
|
|
.returning();
|
|
|
|
const patchRes = await app.inject({
|
|
method: "PATCH",
|
|
url: `/v1/me/memory/${item!.id}`,
|
|
headers: { authorization: `Bearer ${token}` },
|
|
payload: { summarySv: "Gillar verkligen pasta" },
|
|
});
|
|
|
|
expect(patchRes.statusCode).toBe(200);
|
|
const body = JSON.parse(patchRes.body) as {
|
|
origin: string;
|
|
confidence: number;
|
|
verifiedByUser: boolean;
|
|
};
|
|
expect(body.origin).toBe("user_stated");
|
|
expect(body.confidence).toBe(1);
|
|
expect(body.verifiedByUser).toBe(true);
|
|
});
|
|
|
|
it("GET /v1/me/memory/:id/impact returnerar tom lista utan personalization-samtycke", async () => {
|
|
const { token, userId } = await registerUser(emails.consent);
|
|
const [item] = await testDb.db
|
|
.insert(schema.memoryItems)
|
|
.values({
|
|
userId,
|
|
kind: "structured_fact",
|
|
key: "favorite-cuisine-thai",
|
|
summarySv: "Gillar thaimat",
|
|
value: { favoriteCuisine: "thai" },
|
|
origin: "user_stated",
|
|
confidence: 1,
|
|
})
|
|
.returning();
|
|
|
|
const res = await app.inject({
|
|
method: "GET",
|
|
url: `/v1/me/memory/${item!.id}/impact`,
|
|
headers: { authorization: `Bearer ${token}` },
|
|
});
|
|
|
|
expect(res.statusCode).toBe(403);
|
|
const body = JSON.parse(res.body) as { error: { code: string } };
|
|
expect(body.error.code).toBe("PERSONALIZATION_CONSENT_REQUIRED");
|
|
});
|
|
|
|
it("impact för användare A returnerar aldrig användare B:s data", async () => {
|
|
const userA = await registerUser(emails.privacyA);
|
|
const userB = await registerUser(emails.privacyB);
|
|
|
|
await testDb.db.insert(schema.userConsents).values([
|
|
{ userId: userA.userId, kind: "personalization", status: "granted" },
|
|
{ userId: userB.userId, kind: "personalization", status: "granted" },
|
|
]);
|
|
|
|
const [itemA] = await testDb.db
|
|
.insert(schema.memoryItems)
|
|
.values({
|
|
userId: userA.userId,
|
|
kind: "structured_fact",
|
|
key: "favorite-cuisine-thai",
|
|
summarySv: "Gillar thaimat",
|
|
value: { favoriteCuisine: "thai" },
|
|
origin: "user_stated",
|
|
confidence: 1,
|
|
})
|
|
.returning();
|
|
|
|
await testDb.db.insert(schema.memoryItems).values({
|
|
userId: userB.userId,
|
|
kind: "structured_fact",
|
|
key: "favorite-cuisine-italian",
|
|
summarySv: "Gillar italienskt",
|
|
value: { favoriteCuisine: "italian" },
|
|
origin: "user_stated",
|
|
confidence: 1,
|
|
});
|
|
|
|
const res = await app.inject({
|
|
method: "GET",
|
|
url: `/v1/me/memory/${itemA!.id}/impact`,
|
|
headers: { authorization: `Bearer ${userA.token}` },
|
|
});
|
|
|
|
expect(res.statusCode).toBe(200);
|
|
const body = JSON.parse(res.body) as {
|
|
memoryItemId: string;
|
|
impacted: Array<{ whySv: string }>;
|
|
};
|
|
expect(body.memoryItemId).toBe(itemA!.id);
|
|
// Varje varat whySv ska vara från befintliga mallar och får inte avslöja B:s data.
|
|
for (const rec of body.impacted) {
|
|
expect(rec.whySv).not.toContain("italian");
|
|
expect(rec.whySv).not.toContain("italienskt");
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("memory i18n parity", () => {
|
|
it("alla 12 språk har origin, paused och guess utan saknade/dubbletter", async () => {
|
|
// Dynamisk import för att slippa cirkulärt beroende i testsetup.
|
|
const { buildMemoryOverview } = await import("@app/memory-client");
|
|
const { SUPPORTED_LANGUAGE_TAGS } = await import("@app/shared-types");
|
|
|
|
const item = {
|
|
id: "m1",
|
|
userId: "u1",
|
|
kind: "structured_fact" as const,
|
|
key: "k1",
|
|
summarySv: "Sammanfattning",
|
|
value: { favoriteCuisine: "thai" },
|
|
origin: "ai_inferred" as const,
|
|
confidence: 0.5,
|
|
verifiedByUser: false,
|
|
paused: true,
|
|
createdAt: "2026-08-01T00:00:00.000Z",
|
|
updatedAt: "2026-08-01T00:00:00.000Z",
|
|
};
|
|
|
|
for (const tag of SUPPORTED_LANGUAGE_TAGS) {
|
|
const overview = buildMemoryOverview([item], tag);
|
|
const rendered = overview.sections[0]!.items[0]!;
|
|
expect(rendered.originLabel.length).toBeGreaterThan(0);
|
|
expect(rendered.pausedLabel).toBeTruthy();
|
|
expect(rendered.guessLabel).toBeTruthy();
|
|
}
|
|
});
|
|
});
|
|
|
|
describe("DELETE /v1/me/memory GDPR-regression", () => {
|
|
let app: Awaited<ReturnType<typeof buildServer>>;
|
|
|
|
beforeAll(async () => {
|
|
app = await buildServer(config);
|
|
await app.ready();
|
|
});
|
|
|
|
afterAll(async () => {
|
|
await app.close();
|
|
});
|
|
|
|
async function cleanup(email: string) {
|
|
const existing = await testDb.db
|
|
.select({ id: schema.users.id })
|
|
.from(schema.users)
|
|
.where(eq(schema.users.email, email));
|
|
for (const u of existing) {
|
|
await testDb.db.delete(schema.memoryItems).where(eq(schema.memoryItems.userId, u.id));
|
|
await testDb.db.delete(schema.tasteSignals).where(eq(schema.tasteSignals.userId, u.id));
|
|
await testDb.db.delete(schema.userConsents).where(eq(schema.userConsents.userId, u.id));
|
|
await testDb.db.delete(schema.userPreferences).where(eq(schema.userPreferences.userId, u.id));
|
|
await testDb.db
|
|
.delete(schema.householdMembers)
|
|
.where(eq(schema.householdMembers.userId, u.id));
|
|
const ownedHouseholds = await testDb.db
|
|
.select({ id: schema.households.id })
|
|
.from(schema.households)
|
|
.innerJoin(
|
|
schema.householdMembers,
|
|
eq(schema.householdMembers.householdId, schema.households.id),
|
|
)
|
|
.where(
|
|
and(eq(schema.householdMembers.userId, u.id), eq(schema.householdMembers.role, "owner")),
|
|
);
|
|
for (const h of ownedHouseholds) {
|
|
await testDb.db
|
|
.delete(schema.storageLocations)
|
|
.where(eq(schema.storageLocations.householdId, h.id));
|
|
await testDb.db.delete(schema.households).where(eq(schema.households.id, h.id));
|
|
}
|
|
await testDb.db.delete(schema.users).where(eq(schema.users.id, u.id));
|
|
}
|
|
}
|
|
|
|
async function registerUser(email: string) {
|
|
await cleanup(email);
|
|
const res = await app.inject({
|
|
method: "POST",
|
|
url: "/v1/auth/register",
|
|
payload: { email, password: "Password123!", displayName: "Memory GDPR Test" },
|
|
});
|
|
const body = JSON.parse(res.body) as { accessToken: string };
|
|
const token = body.accessToken;
|
|
const userId = (JSON.parse(atob(token.split(".")[1]!)) as { sub: string }).sub;
|
|
await app.inject({
|
|
method: "POST",
|
|
url: "/v1/onboarding/quick-start",
|
|
headers: { authorization: `Bearer ${token}` },
|
|
payload: { goals: ["cook_more"], precisionMode: "simple" },
|
|
});
|
|
return { token, userId };
|
|
}
|
|
|
|
it("tömmer memoryItems och tasteSignals", async () => {
|
|
const email = "memory-delete-all@example.invalid";
|
|
const { token, userId } = await registerUser(email);
|
|
|
|
await testDb.db.insert(schema.memoryItems).values({
|
|
userId,
|
|
kind: "structured_fact",
|
|
key: "likes-pasta",
|
|
summarySv: "Gillar pasta",
|
|
value: { favoriteCuisine: "italian" },
|
|
origin: "user_stated",
|
|
confidence: 1,
|
|
});
|
|
|
|
await testDb.db.insert(schema.tasteSignals).values({
|
|
userId,
|
|
axis: "spice",
|
|
direction: 1,
|
|
strength: 0.8,
|
|
origin: "user_stated",
|
|
});
|
|
|
|
const res = await app.inject({
|
|
method: "DELETE",
|
|
url: "/v1/me/memory",
|
|
headers: { authorization: `Bearer ${token}` },
|
|
});
|
|
|
|
expect(res.statusCode).toBe(200);
|
|
|
|
const remainingMemory = await testDb.db
|
|
.select({ id: schema.memoryItems.id })
|
|
.from(schema.memoryItems)
|
|
.where(eq(schema.memoryItems.userId, userId));
|
|
expect(remainingMemory).toHaveLength(0);
|
|
|
|
const remainingSignals = await testDb.db
|
|
.select({ id: schema.tasteSignals.id })
|
|
.from(schema.tasteSignals)
|
|
.where(eq(schema.tasteSignals.userId, userId));
|
|
expect(remainingSignals).toHaveLength(0);
|
|
|
|
await cleanup(email);
|
|
});
|
|
});
|