mirror of
https://github.com/MBombeck/HealthLog.git
synced 2026-11-16 07:13:29 +00:00
merge: forward-port v1.33.2 into release/v1.34.0
This commit is contained in:
commit
81825ce23b
7 files changed
+298
-236
No files matched your search
@@ -0,0 +1,214 @@
|
||||
/**
|
||||
* The seam between the backup writer and the backup reader.
|
||||
*
|
||||
* Custom cycle symptoms had a green test on every end and shipped broken
|
||||
* anyway. `buildCycleBackupSection` returned them, `backupPayloadSchema`
|
||||
* declared them, `restoreCycleData` read them, and each of those three was
|
||||
* covered. What nothing covered was the assembly in between: the payload was
|
||||
* built as an object literal that copied section keys out one at a time, and
|
||||
* `customSymptoms` was never on that list. Every backup written carried an
|
||||
* empty array, so an account whose day-log referenced a symptom it had created
|
||||
* itself could not be restored at all — the restore threw on a key nothing had
|
||||
* written back and the route answered 500.
|
||||
*
|
||||
* So this test asserts on ROWS, never on the payload object. Asserting the
|
||||
* payload carries `customSymptoms` would re-test the writer, which was already
|
||||
* passing while production was broken. The account is populated, the REAL
|
||||
* `buildFullBackupPayload` produces the file, the file is serialised and parsed
|
||||
* back through the REAL `parseBackupPayload`, the account's own symptom row is
|
||||
* removed so the file is the only place it survives, and the REAL admin restore
|
||||
* has to put the row and its day-log link back.
|
||||
*
|
||||
* Removing the symptom row before restoring is the point, not a contrivance:
|
||||
* `restoreCycleData` wipes day-logs, cycles, and the profile, but never the
|
||||
* symptom catalogue. Restore onto the same instance and the row is still
|
||||
* sitting there to resolve against, which is exactly why the older round-trip
|
||||
* test stayed green. The file has to carry the symptom for the case the
|
||||
* `customSymptoms` field exists for: a restore onto an instance that never had
|
||||
* it.
|
||||
*
|
||||
* Mutation check: hand-pick the cycle section's keys in
|
||||
* `buildFullBackupPayload` instead of spreading it, and this test reproduces
|
||||
* the production failure — restore answers 500 on
|
||||
* `Unknown cycle symptom keys: custom:sacroiliac-ache`.
|
||||
*/
|
||||
import { beforeEach, describe, expect, it, vi } from "vitest";
|
||||
|
||||
process.env.ENCRYPTION_KEY =
|
||||
"0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
|
||||
|
||||
import { decrypt, encrypt } from "@/lib/crypto";
|
||||
import { buildFullBackupPayload } from "@/lib/export/full-backup-payload";
|
||||
import { parseBackupPayload } from "@/lib/validations/backup";
|
||||
import { POST } from "@/app/api/admin/backups/[id]/restore/route";
|
||||
import { invalidateUserData } from "@/lib/cache/invalidate";
|
||||
|
||||
import { cookieJar, headerJar } from "./mock-next-headers";
|
||||
import { getPrismaClient, truncateAllTables } from "./setup";
|
||||
|
||||
vi.mock("next/headers", async () => {
|
||||
const { cookieJar, headerJar } = await import("./mock-next-headers");
|
||||
return {
|
||||
headers: vi.fn(async () => ({
|
||||
get: (name: string) => headerJar.get(name.toLowerCase()) ?? null,
|
||||
})),
|
||||
cookies: vi.fn(async () => ({
|
||||
get: (name: string) => {
|
||||
const value = cookieJar.get(name);
|
||||
return value ? { name, value } : undefined;
|
||||
},
|
||||
set: (name: string, value: string) => cookieJar.set(name, value),
|
||||
delete: (name: string) => cookieJar.delete(name),
|
||||
})),
|
||||
};
|
||||
});
|
||||
|
||||
vi.mock("@/lib/db-compat", () => ({
|
||||
ensureDbCompatibility: vi.fn().mockResolvedValue(undefined),
|
||||
}));
|
||||
|
||||
vi.mock("@/lib/cache/invalidate", () => ({
|
||||
invalidateUserData: vi.fn(),
|
||||
}));
|
||||
|
||||
/** The user's own words for the symptom, as they are held at rest. */
|
||||
const SYMPTOM_LABEL = "Sacroiliac ache";
|
||||
const SYMPTOM_KEY = "custom:sacroiliac-ache";
|
||||
|
||||
beforeEach(async () => {
|
||||
await truncateAllTables(getPrismaClient());
|
||||
cookieJar.clear();
|
||||
headerJar.clear();
|
||||
vi.mocked(invalidateUserData).mockClear();
|
||||
});
|
||||
|
||||
function makeRequest(id: string) {
|
||||
return new Request(`http://localhost/api/admin/backups/${id}/restore`, {
|
||||
method: "POST",
|
||||
headers: { "content-type": "application/json" },
|
||||
body: JSON.stringify({ confirm: "RESTORE" }),
|
||||
});
|
||||
}
|
||||
|
||||
describe("a backup of an account with its own cycle symptom", () => {
|
||||
it("restores the symptom and its day-log link onto an instance without it", async () => {
|
||||
const prisma = getPrismaClient();
|
||||
|
||||
// The restore writes into the backup's owner, and the route refuses a
|
||||
// payload whose declared owner differs from the backup row. Owner and
|
||||
// operator are the same account here so the fixture stays about the
|
||||
// symptom rather than about the ownership guard.
|
||||
const owner = await prisma.user.create({
|
||||
data: {
|
||||
username: "cycle-symptom-owner",
|
||||
email: "cycle-symptom-owner@example.test",
|
||||
role: "ADMIN",
|
||||
},
|
||||
});
|
||||
const session = await prisma.session.create({
|
||||
data: { userId: owner.id, expiresAt: new Date(Date.now() + 60_000) },
|
||||
});
|
||||
cookieJar.set("healthlog_session", session.id);
|
||||
|
||||
const category = await prisma.cycleSymptomCategory.findFirstOrThrow();
|
||||
const symptom = await prisma.cycleSymptom.create({
|
||||
data: {
|
||||
userId: owner.id,
|
||||
categoryId: category.id,
|
||||
key: SYMPTOM_KEY,
|
||||
labelKey: "cycle.symptom.custom",
|
||||
labelEncrypted: encrypt(SYMPTOM_LABEL),
|
||||
sortOrder: 3,
|
||||
},
|
||||
});
|
||||
await prisma.cycleProfile.create({
|
||||
data: {
|
||||
userId: owner.id,
|
||||
goal: "GENERAL_HEALTH",
|
||||
cycleTrackingEnabled: true,
|
||||
typicalCycleLength: 29,
|
||||
},
|
||||
});
|
||||
const cycle = await prisma.menstrualCycle.create({
|
||||
data: {
|
||||
userId: owner.id,
|
||||
startDate: "2026-07-01",
|
||||
periodEndDate: "2026-07-05",
|
||||
tz: "Europe/Berlin",
|
||||
},
|
||||
});
|
||||
const dayLog = await prisma.cycleDayLog.create({
|
||||
data: {
|
||||
userId: owner.id,
|
||||
cycleId: cycle.id,
|
||||
date: "2026-07-03",
|
||||
flow: "MEDIUM",
|
||||
source: "MANUAL",
|
||||
tz: "Europe/Berlin",
|
||||
symptomLinks: { create: { symptomId: symptom.id } },
|
||||
},
|
||||
});
|
||||
|
||||
// The real writer, the real wire format, the real reader. Nothing is
|
||||
// asserted about `built` — the writer was green through the whole defect.
|
||||
const { payload: built } = await buildFullBackupPayload(prisma, owner.id, {
|
||||
purpose: "disaster-recovery",
|
||||
});
|
||||
const parsed = parseBackupPayload(JSON.stringify(built));
|
||||
const backup = await prisma.dataBackup.create({
|
||||
data: {
|
||||
userId: owner.id,
|
||||
type: "CUSTOM_CYCLE_SYMPTOM_ROUND_TRIP",
|
||||
data: encrypt(JSON.stringify(parsed)),
|
||||
},
|
||||
});
|
||||
|
||||
// Model the instance the `customSymptoms` field exists for: one that never
|
||||
// had this account's own symptom. The restore clears day-logs, cycles, and
|
||||
// the profile itself, but never the symptom catalogue, so the row has to go
|
||||
// before the restore runs or the file is not what resolves the link.
|
||||
await prisma.cycleDayLog.deleteMany({ where: { userId: owner.id } });
|
||||
await prisma.menstrualCycle.deleteMany({ where: { userId: owner.id } });
|
||||
await prisma.cycleProfile.deleteMany({ where: { userId: owner.id } });
|
||||
await prisma.cycleSymptom.deleteMany({ where: { userId: owner.id } });
|
||||
expect(
|
||||
await prisma.cycleSymptom.count({ where: { key: SYMPTOM_KEY } }),
|
||||
).toBe(0);
|
||||
|
||||
const response = await POST(
|
||||
makeRequest(backup.id) as unknown as Parameters<typeof POST>[0],
|
||||
{ params: Promise.resolve({ id: backup.id }) },
|
||||
);
|
||||
|
||||
expect(response.status).toBe(200);
|
||||
|
||||
// Rows, not payload keys.
|
||||
const restoredSymptom = await prisma.cycleSymptom.findUniqueOrThrow({
|
||||
where: { key: SYMPTOM_KEY },
|
||||
});
|
||||
expect(restoredSymptom).toEqual(
|
||||
expect.objectContaining({
|
||||
userId: owner.id,
|
||||
categoryId: category.id,
|
||||
labelKey: "cycle.symptom.custom",
|
||||
sortOrder: 3,
|
||||
isActive: true,
|
||||
}),
|
||||
);
|
||||
// The label is ciphertext on the wire and stays readable after the trip:
|
||||
// a restored symptom whose label came back empty is the same lost data in
|
||||
// a quieter form.
|
||||
expect(decrypt(restoredSymptom.labelEncrypted!)).toBe(SYMPTOM_LABEL);
|
||||
|
||||
const restoredDayLog = await prisma.cycleDayLog.findUniqueOrThrow({
|
||||
where: { id: dayLog.id },
|
||||
});
|
||||
expect(restoredDayLog.date).toBe("2026-07-03");
|
||||
expect(
|
||||
await prisma.cycleSymptomLink.findMany({
|
||||
where: { dayLogId: restoredDayLog.id },
|
||||
select: { symptomId: true },
|
||||
}),
|
||||
).toEqual([{ symptomId: restoredSymptom.id }]);
|
||||
});
|
||||
});
|
||||
Reference in new issue
Block a user