105 lines
9.6 KiB
TypeScript
105 lines
9.6 KiB
TypeScript
import { expect, test } from "bun:test";
|
|
import { and, eq, inArray } from "drizzle-orm";
|
|
import { getDb, user, groups, guests, submissions, photos, events, eventMemberships } from "@album/database";
|
|
import { groupRouter } from "./api/routers/group";
|
|
import { managerRouter } from "./api/routers/manager";
|
|
import type { TrpcContext } from "./api/trpc";
|
|
import { deletePrefix, photoObjectPrefix, headObject, originalObjectKey } from "@album/storage";
|
|
import { runOnce } from "./operation-receipts";
|
|
|
|
test.skipIf(process.env.POLISH_INTEGRATION !== "1")("group ownership and event-scoped submission approval", async () => {
|
|
if (!["localhost", "127.0.0.1"].includes(new URL(process.env.DATABASE_URL!).hostname)) throw new Error("Local database required");
|
|
const db = getDb();
|
|
const id = crypto.randomUUID();
|
|
const people = await db.insert(user).values([0, 1].map(n => ({ id: `${id}-${n}`, name: "Workflow test", email: `${id}-${n}@manyangles.test`, emailVerified: true }))).returning();
|
|
const ctx = (n: number): TrpcContext => ({ session: { user: people[n]!, session: {} } as TrpcContext["session"], cookies: new Map(), activeGroupId: null, requestOrigin: "http://localhost:3000", clientIdentifier: id, guestTokenForEvent: () => null, setCookies: [], appendSetCookie: () => {} });
|
|
let groupId: string | undefined;
|
|
const cleanupUploads: { eventId: string; photoId: string }[] = [];
|
|
try {
|
|
const owner = groupRouter.createCaller(ctx(0));
|
|
const group = await owner.create({ name: "Workflow test" });
|
|
groupId = group.id;
|
|
expect((await owner.get({ groupId })).role).toBe("owner");
|
|
await owner.rename({ groupId, name: "Renamed group" });
|
|
expect((await owner.get({ groupId })).name).toBe("Renamed group");
|
|
await expect(groupRouter.createCaller(ctx(1)).rename({ groupId, name: "Denied" })).rejects.toThrow();
|
|
const [event] = await db.insert(events).values({ groupId, title: "Workflow test", slug: id }).returning();
|
|
await db.insert(eventMemberships).values({ eventId: event!.id, userId: people[0]!.id, role: "owner" });
|
|
const receipt = { userId: people[0]!.id, eventId: event!.id, key: `rollback-${id}` };
|
|
await expect(runOnce(receipt, "same", async tx => { await tx.update(events).set({ title: "Rolled back" }).where(eq(events.id, event!.id)); throw new Error("simulated interruption"); })).rejects.toThrow();
|
|
expect((await db.select().from(events).where(eq(events.id, event!.id)))[0]!.title).toBe("Workflow test");
|
|
let executions = 0;
|
|
const receipts = await Promise.all([0, 1, 2].map(() => runOnce(receipt, "same", async () => { executions++; return { ok: true }; })));
|
|
expect(executions).toBe(1);
|
|
expect(receipts).toEqual([{ ok: true }, { ok: true }, { ok: true }]);
|
|
const [guest] = await db.insert(guests).values({ eventId: event!.id, tokenHash: id }).returning();
|
|
const [submission] = await db.insert(submissions).values({ eventId: event!.id, guestId: guest!.id }).returning();
|
|
await db.insert(photos).values((["ready", "processing"] as const).map(processingStatus => ({ eventId: event!.id, submissionId: submission!.id, originalKey: `test/${id}/${processingStatus}`, contentType: "image/jpeg", processingStatus })));
|
|
const manager = managerRouter.createCaller(ctx(0));
|
|
const input = { eventId: event!.id, submissionId: submission!.id, visibility: "public" as const };
|
|
await expect(managerRouter.createCaller(ctx(1)).moderateSubmission(input)).rejects.toThrow();
|
|
await expect(manager.moderateSubmission({ ...input, eventId: crypto.randomUUID() })).rejects.toThrow();
|
|
expect((await manager.moderateSubmission(input)).updatedCount).toBe(2);
|
|
expect((await manager.moderateSubmission(input)).updatedCount).toBe(0);
|
|
const result = await db.select().from(photos).where(and(eq(photos.eventId, event!.id), eq(photos.submissionId, submission!.id)));
|
|
expect(result.every(photo => photo.visibility === "public")).toBe(true);
|
|
expect(result.find(photo => photo.processingStatus === "processing")).toBeDefined();
|
|
const [privatePhoto] = await db.insert(photos).values({ eventId: event!.id, submissionId: submission!.id, originalKey: `test/${id}/private`, contentType: "image/jpeg", processingStatus: "ready", visibility: "private" }).returning();
|
|
await db.insert(eventMemberships).values({ eventId: event!.id, userId: people[1]!.id, role: "moderator" });
|
|
const moderator = managerRouter.createCaller(ctx(1));
|
|
expect((await moderator.moderateSubmission({ ...input, visibility: "hidden" })).updatedCount).toBe(2);
|
|
const [preserved] = await db.select().from(photos).where(and(eq(photos.eventId, event!.id), eq(photos.id, privatePhoto!.id)));
|
|
expect(preserved!.visibility).toBe("private");
|
|
await expect(moderator.moderateSubmission({ ...input, visibility: "private" })).rejects.toThrow();
|
|
const bulk = { eventId: event!.id, photoIds: [...result.map(photo => photo.id), privatePhoto!.id], action: "public" as const, requestId: crypto.randomUUID() };
|
|
const preview = await moderator.previewBulkPhotos(bulk);
|
|
expect(preview.affected).toBe(2);
|
|
expect(preview.results.find(row => row.photoId === privatePhoto!.id)?.status).toBe("skipped");
|
|
await expect(moderator.bulkPhotos({ ...bulk, confirm: false as true })).rejects.toThrow();
|
|
expect((await moderator.bulkPhotos({ ...bulk, confirm: true })).affected).toBe(2);
|
|
expect((await moderator.bulkPhotos({ ...bulk, confirm: true })).affected).toBe(2);
|
|
await expect(moderator.bulkPhotos({ ...bulk, action: "hidden", confirm: true })).rejects.toThrow("different inputs");
|
|
// A replay cannot undo a later, intentional change.
|
|
await moderator.bulkPhotos({ ...bulk, requestId: crypto.randomUUID(), action: "hidden", confirm: true });
|
|
await moderator.bulkPhotos({ ...bulk, confirm: true });
|
|
expect((await db.select().from(photos).where(and(eq(photos.eventId, event!.id), eq(photos.id, result[0]!.id))))[0]!.visibility).toBe("hidden");
|
|
await expect(moderator.bulkPhotos({ ...bulk, action: "private", confirm: true })).rejects.toThrow();
|
|
const [otherEvent] = await db.insert(events).values({ groupId, title: "Other event", slug: `${id}-other` }).returning();
|
|
await db.insert(eventMemberships).values({ eventId: otherEvent!.id, userId: people[0]!.id, role: "owner" });
|
|
const crossEvent = await manager.previewBulkPhotos({ ...bulk, eventId: otherEvent!.id });
|
|
expect(crossEvent.affected).toBe(0);
|
|
const deletion = await manager.previewBulkPhotos({ ...bulk, action: "delete" });
|
|
expect(deletion.results.find(row => row.photoId === result.find(photo => photo.processingStatus === "processing")!.id)?.status).toBe("skipped");
|
|
await expect(manager.bulkPhotos({ ...bulk, photoIds: [result[0]!.id, result[0]!.id], confirm: true })).rejects.toThrow();
|
|
await expect(moderator.createGalleryPhotos({ eventId: event!.id, requestId: crypto.randomUUID(), files: [{ fileName: "test.png", contentType: "image/png", byteSize: 5 }] })).rejects.toThrow();
|
|
expect((await moderator.photos({ eventId: event!.id, limit: 1, visibility: "private" })).length).toBe(0);
|
|
expect((await manager.photos({ eventId: event!.id, limit: 1 })).length).toBe(1);
|
|
if (process.env.GALLERY_STORAGE_INTEGRATION === "1") {
|
|
if (!["localhost", "127.0.0.1"].includes(new URL(process.env.S3_ENDPOINT!).hostname)) throw new Error("Local object storage required");
|
|
const bytes = Buffer.from("iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+aRZkAAAAASUVORK5CYII=", "base64");
|
|
const createInput = { eventId: event!.id, requestId: crypto.randomUUID(), files: [{ fileName: "test.png", contentType: "image/png" as const, byteSize: bytes.length }] };
|
|
const [uploads, replay] = await Promise.all([manager.createGalleryPhotos(createInput), manager.createGalleryPhotos(createInput)]);
|
|
expect(replay.map(row => row.photoId)).toEqual(uploads.map(row => row.photoId));
|
|
for (const upload of uploads) cleanupUploads.push({ eventId: event!.id, photoId: upload.photoId });
|
|
expect((await fetch(uploads[0]!.uploadUrl!, { method: "PUT", headers: { "Content-Type": "image/png" }, body: bytes })).ok).toBe(true);
|
|
expect((await manager.retryGalleryPhoto({ eventId: event!.id, photoId: uploads[0]!.photoId })).uploadUrl).toBeNull();
|
|
expect((await manager.createGalleryPhotos(createInput))[0]!.uploadUrl).toBeNull();
|
|
await expect(manager.createGalleryPhotos({ ...createInput, files: [{ ...createInput.files[0]!, byteSize: 1 }] })).rejects.toThrow("different inputs");
|
|
const batch = { eventId: event!.id, photoIds: uploads.map(upload => upload.photoId), requestId: crypto.randomUUID() };
|
|
expect((await manager.completeGalleryPhotos(batch))[0]!.status).toBe("processing");
|
|
expect((await manager.completeGalleryPhotos(batch))[0]!.status).toBe("processing");
|
|
expect((await manager.retryGalleryPhoto({ eventId: event!.id, photoId: uploads[0]!.photoId })).uploadUrl).toBeNull();
|
|
expect((await manager.previewBulkPhotos({ ...batch, action: "delete" })).affected).toBe(0);
|
|
// Simulate the worker's terminal state; never modify a real upload.
|
|
await db.update(photos).set({ processingStatus: "ready" }).where(and(eq(photos.eventId, event!.id), eq(photos.id, uploads[0]!.photoId)));
|
|
expect((await manager.bulkPhotos({ ...batch, action: "delete", confirm: true })).affected).toBe(1);
|
|
expect((await manager.bulkPhotos({ ...batch, action: "delete", confirm: true })).affected).toBe(1);
|
|
expect(await headObject(originalObjectKey(event!.id, uploads[0]!.photoId))).toBeNull();
|
|
}
|
|
} finally {
|
|
for (const upload of cleanupUploads) await deletePrefix(photoObjectPrefix(upload.eventId, upload.photoId));
|
|
if (groupId) await db.delete(groups).where(eq(groups.id, groupId));
|
|
await db.delete(user).where(inArray(user.id, people.map(person => person.id)));
|
|
}
|
|
});
|