Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

23.0 KB
Raw Blame
import { S3Bucket, User, Video } from "@cap/web-domain";
import type { SQL } from "drizzle-orm";
import { MySqlDialect } from "drizzle-orm/mysql-core";
import { Effect, Option } from "effect";
import { beforeEach, describe, expect, it, vi } from "vitest";

const mocks = vi.hoisted(() => ({
	getOwnedById: vi.fn(),
	storage: vi.fn(),
	sign: vi.fn(),
	database: vi.fn(),
	prepareReplacement: vi.fn(),
	invalidate: vi.fn(),
	head: vi.fn(),
	queueTranscription: vi.fn(),
	shouldQueueTranscription: vi.fn(),
	complete: vi.fn(),
	create: vi.fn(),
	abort: vi.fn(),
}));
vi.mock("@cap/env", () => ({
	serverEnv: () => ({ NEXTAUTH_SECRET: "test-reupload-secret" }),
	buildEnv: { NEXT_PUBLIC_IS_CAP: true },
}));
vi.mock("@/lib/desktop-reupload", () => ({
	prepareDesktopReupload: mocks.prepareReplacement,
	invalidateReuploadedVideo: mocks.invalidate,
}));
vi.mock("@cap/web-backend", async () => {
	const { Context, Layer } = await import("effect");
	return {
		Database: Context.GenericTag("test/Database"),
		VideosPolicy: Context.GenericTag("test/VideosPolicy"),
		Storage: { getAccessForVideo: mocks.storage },
		makeCurrentUserLayer: () => Layer.empty,
		provideOptionalAuth: (effect: unknown) => effect,
	};
});
vi.mock("@/app/api/utils", () => ({
	withAuth: async (
		c: { set: (key: string, value: unknown) => void },
		next: () => Promise<void>,
	) => {
		c.set("user", { id: "owner" });
		await next();
	},
}));
vi.mock("@/lib/server", async () => {
	const { Effect, Context, Layer } = await import("effect");
	return {
		runPromise: (effect: Effect.Effect<unknown, unknown, unknown>) =>
			Effect.runPromise(
				effect.pipe(
					Effect.provide(
						Layer.succeed(Context.GenericTag("test/VideosPolicy"), {
							getOwnedById: mocks.getOwnedById,
						}),
					),
					Effect.provide(
						Layer.succeed(Context.GenericTag("test/Database"), {
							use: (callback: (client: unknown) => Promise<unknown>) =>
								Effect.tryPromise(() => callback(mocks.database())),
						}),
					),
				) as Effect.Effect<unknown>,
			),
	};
});
vi.mock("@/lib/google-drive-storage-quota", () => ({
	invalidateGoogleDriveStorageQuotaCache: vi.fn(async () => {}),
}));
vi.mock("@/lib/queue-video-transcription", () => ({
	queueVideoTranscription: mocks.queueTranscription,
	shouldQueueTranscriptionAfterMultipartComplete:
		mocks.shouldQueueTranscription,
}));
vi.mock("@/lib/video-processing", () => ({
	startVideoProcessingWorkflow: vi.fn(async () => "started"),
}));

import { app } from "@/app/api/upload/[...route]/multipart";
import {
	assertDesktopReuploadTarget,
	createDesktopReuploadKey,
	createDesktopReuploadToken,
	type DesktopReuploadToken,
	decodeDesktopReuploadToken,
} from "@/lib/desktop-reupload-token";

const request = () =>
	app.request("/presign-part", {
		method: "POST",
		headers: { "Content-Type": "application/json" },
		body: JSON.stringify({
			videoId: "missing-video",
			uploadId: "upload",
			partNumber: 1,
		}),
	});

describe("multipart presign ownership failures", () => {
	it("returns 404 without accessing storage for a missing or unowned video", async () => {
		mocks.getOwnedById.mockReturnValue(Effect.succeed(Option.none()));
		const response = await request();
		expect(response.status).toBe(404);
		expect(await response.json()).toEqual({
			error: "Video not found",
			code: "VIDEO_NOT_FOUND",
		});
		expect(mocks.storage).not.toHaveBeenCalled();
	});

	it("does not reveal or sign a recording owned by someone else", async () => {
		mocks.getOwnedById.mockReturnValue(Effect.fail({ _tag: "PolicyDenied" }));
		const response = await request();
		expect(response.status).toBe(404);
		expect(mocks.storage).not.toHaveBeenCalled();
	});

	it("still signs a part for its owner", async () => {
		mocks.getOwnedById.mockReturnValue(
			Effect.succeed(Option.some([{ id: "missing-video" }])),
		);
		mocks.sign.mockReturnValue(Effect.succeed("https://uploads.example/part"));
		mocks.storage.mockReturnValue(
			Effect.succeed([
				{
					provider: "s3",
					multipart: { getPresignedUploadPartUrl: mocks.sign },
				},
			]),
		);
		const response = await request();
		expect(response.status).toBe(200);
		expect(await response.json()).toEqual({
			provider: "s3",
			presignedUrl: "https://uploads.example/part",
		});
	});
});

describe("desktop reupload completion", () => {
	const oldKey = "owner/video/.recording/outputs/original/result.mp4";
	let events: string[];
	let updates: Record<string, unknown>[];
	let objects: Map<string, { ETag: string; ContentLength: number }>;
	let video: {
		id: Video.VideoId;
		ownerId: User.UserId;
		source: { type: "desktopMP4"; outputKey: string };
		bucketId: Video.Video["bucketId"];
		storageIntegrationId: Video.Video["storageIntegrationId"];
	};
	let outputKey: string;
	let token: string;
	let uploadKey: string | null;
	let rejectCommit: boolean;
	let provider: "s3" | "googleDrive";
	let uploadState: Record<string, unknown>;
	const dialect = new MySqlDialect();
	const mintToken = () => {
		outputKey = createDesktopReuploadKey(video);
		token = createDesktopReuploadToken(video, {
			uploadId: "backend-upload",
			provider,
			outputKey,
		});
		uploadKey = outputKey;
	};
	beforeEach(() => {
		vi.clearAllMocks();
		events = [];
		updates = [];
		objects = new Map([[oldKey, { ETag: "original", ContentLength: 90 }]]);
		provider = "s3";
		rejectCommit = false;
		uploadState = {
			phase: "error",
			processingError: "recoverable",
			uploaded: 90,
			total: 90,
		};
		video = {
			id: Video.VideoId.make("video"),
			ownerId: User.UserId.make("owner"),
			source: { type: "desktopMP4", outputKey: oldKey },
			bucketId: Option.none(),
			storageIntegrationId: Option.none(),
		};
		mintToken();
		const client = {
			select: () => ({
				from: () => ({
					innerJoin: () => ({
						where: () => ({
							limit: async () => [
								{
									stripeSubscriptionStatus: null,
									thirdPartyStripeSubscriptionId: null,
								},
							],
						}),
					}),
				}),
			}),
			transaction: async (run: (tx: unknown) => Promise<void>) => {
				const pending: Record<string, unknown>[] = [];
				let removeUpload = false;
				await run({
					update: () => ({
						set: (values: Record<string, unknown>) => ({
							where: async () => {
								pending.push(values);
								events.push("publish");
							},
						}),
					}),
					delete: () => ({
						where: async (filter: SQL) => {
							events.push("delete-upload");
							const params = dialect.sqlToQuery(filter).params;
							removeUpload = params.length === 1 || params.includes(uploadKey);
						},
					}),
				});
				if (rejectCommit) throw new Error("Database commit failed");
				for (const values of pending) {
					updates.push(values);
					if (values.source)
						video.source = values.source as typeof video.source;
				}
				if (removeUpload) uploadKey = null;
			},
			insert: () => ({
				values: (values: { rawFileKey?: string | null }) => ({
					onDuplicateKeyUpdate: async ({
						set,
					}: {
						set: Record<string, unknown>;
					}) => {
						Object.assign(uploadState, set);
						uploadKey = values.rawFileKey ?? null;
					},
				}),
			}),
			delete: () => ({
				where: async (filter: SQL) => {
					if (dialect.sqlToQuery(filter).params.includes(uploadKey))
						uploadKey = null;
				},
			}),
		};
		mocks.database.mockReturnValue(client);
		mocks.getOwnedById.mockImplementation(() =>
			Effect.sync(() =>
				Option.some([{ ...video, source: { ...video.source } }]),
			),
		);
		mocks.complete.mockImplementation((key: string) =>
			Effect.sync(() => {
				events.push("complete");
				objects.set(key, { ETag: "new-video", ContentLength: 100 });
				return { ETag: "new-video" };
			}),
		);
		mocks.create.mockReturnValue(
			Effect.succeed({ UploadId: "backend-upload" }),
		);
		mocks.abort.mockReturnValue(Effect.succeed({}));
		mocks.head.mockImplementation((key: string) => {
			const value = objects.get(key);
			return value
				? Effect.succeed(value)
				: Effect.fail(new Error("Object missing"));
		});
		mocks.storage.mockImplementation(() =>
			Effect.succeed([
				{
					provider,
					bucketName: "bucket",
					multipart: {
						complete: mocks.complete,
						create: mocks.create,
						abort: mocks.abort,
						getPresignedUploadPartUrl: mocks.sign,
					},
					headObject: (key: string) => Effect.suspend(() => mocks.head(key)),
					copyObject: () =>
						Effect.succeed({ CopyObjectResult: { ETag: "new-video" } }),
				},
			]),
		);
		mocks.sign.mockReturnValue(Effect.succeed("https://uploads.example/part"));
		mocks.prepareReplacement.mockImplementation(
			async (
				_tx: unknown,
				_snapshot: unknown,
				replacement: DesktopReuploadToken,
			) => {
				assertDesktopReuploadTarget(
					replacement,
					video,
					"owner/video/result.mp4",
					provider,
				);
				if (video.source.outputKey === replacement.outputKey) return null;
				if (uploadKey !== replacement.outputKey)
					throw new Error("Replacement upload was canceled or superseded");
				events.push("retire");
				return {
					source: { type: "desktopMP4", outputKey: replacement.outputKey },
					transcriptionStatus: null,
				};
			},
		);
		mocks.invalidate.mockImplementation(async () => {
			events.push("invalidate");
		});
		mocks.shouldQueueTranscription.mockReturnValue(false);
		mocks.queueTranscription.mockResolvedValue({ success: true });
	});
	const complete = (
		replaceExisting?: boolean,
		uploadId = token,
		durationInSecs = 5,
	) =>
		app.request("/complete", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({
				videoId: "video",
				uploadId,
				parts: [{ partNumber: 1, etag: "part", size: 100 }],
				durationInSecs,
				replaceExisting,
			}),
		});
	const abort = () =>
		app.request("/abort", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({ videoId: "video", uploadId: token }),
		});
	it.each(["s3", "googleDrive"] as const)(
		"initiates isolated %s replacement uploads",
		async (storageProvider) => {
			provider = storageProvider;
			const response = await app.request("/initiate", {
				method: "POST",
				headers: { "Content-Type": "application/json" },
				body: JSON.stringify({
					videoId: "video",
					contentType: "video/mp4",
					replaceExisting: true,
				}),
			});
			expect(response.status).toBe(200);
			const body = await response.json();
			const decoded = decodeDesktopReuploadToken(body.uploadId);
			expect(decoded).toMatchObject({
				provider,
				uploadId: "backend-upload",
				videoId: "video",
			});
			expect(decoded?.outputKey).not.toBe(oldKey);
			expect(mocks.create).toHaveBeenCalledWith(
				decoded?.outputKey,
				expect.objectContaining({ ContentType: "video/mp4" }),
			);
			expect(uploadKey).toBe(decoded?.outputKey);
			expect(uploadState).toMatchObject({
				phase: "uploading",
				uploaded: 0,
				total: 0,
				processingProgress: 0,
				processingError: null,
				processingMessage: null,
			});
			expect(video.source.outputKey).toBe(oldKey);
		},
	);
	it("publishes verified replacement bytes without overwriting current playback", async () => {
		const response = await complete();
		expect(response.status).toBe(200);
		expect(await response.json()).toMatchObject({
			success: true,
			fileKey: outputKey,
			objectIdentity: "new-video",
		});
		expect(events).toEqual([
			"complete",
			"retire",
			"publish",
			"delete-upload",
			"invalidate",
		]);
		expect(mocks.complete).toHaveBeenCalledWith(
			outputKey,
			"backend-upload",
			expect.anything(),
		);
		expect(video.source.outputKey).toBe(outputKey);
		expect(objects.get(oldKey)).toEqual({
			ETag: "original",
			ContentLength: 90,
		});
	});
	it("uses a new playback key even when CDN invalidation fails", async () => {
		mocks.invalidate.mockRejectedValueOnce(new Error("CloudFront unavailable"));
		const response = await complete();
		expect(response.status).toBe(200);
		expect(video.source.outputKey).toBe(outputKey);
		expect(video.source.outputKey).not.toBe(oldKey);
		expect(objects.get(oldKey)?.ETag).toBe("original");
	});
	it.each([false, undefined])(
		"keeps ordinary uploads on their existing path: %s",
		async (replacementFlag) => {
			const response = await complete(replacementFlag, "legacy-upload");
			expect(response.status).toBe(200);
			expect(mocks.prepareReplacement).not.toHaveBeenCalled();
			expect(mocks.invalidate).not.toHaveBeenCalled();
			expect(updates[0]).not.toHaveProperty("source");
		},
	);
	it("rejects unsafe legacy replacement completion before storage writes", async () => {
		const response = await complete(true, "legacy-upload");
		expect(response.status).toBe(409);
		expect(mocks.complete).not.toHaveBeenCalled();
		expect(video.source.outputKey).toBe(oldKey);
	});
	it("leaves original bytes and publication intact when storage completion fails", async () => {
		mocks.complete.mockReturnValueOnce(Effect.fail(new Error("Upload failed")));
		expect((await complete()).status).toBe(500);
		expect(video.source.outputKey).toBe(oldKey);
		expect(objects.get(oldKey)?.ETag).toBe("original");
		expect(mocks.prepareReplacement).not.toHaveBeenCalled();
	});
	it("does not publish a mismatched or empty uploaded object", async () => {
		mocks.head.mockReturnValue(
			Effect.succeed({ ETag: "new-video", ContentLength: 0 }),
		);
		expect((await complete()).status).toBe(500);
		expect(video.source.outputKey).toBe(oldKey);
		expect(mocks.prepareReplacement).not.toHaveBeenCalled();
	});
	it("preserves old playback and permits retry after database commit failure", async () => {
		rejectCommit = true;
		expect((await complete()).status).toBe(500);
		expect(video.source.outputKey).toBe(oldKey);
		expect(objects.get(oldKey)?.ETag).toBe("original");
		expect(objects.get(outputKey)?.ETag).toBe("new-video");
		rejectCommit = false;
		mocks.complete.mockReturnValueOnce(Effect.fail(new Error("NoSuchUpload")));
		expect((await complete()).status).toBe(200);
		expect(video.source.outputKey).toBe(outputKey);
	});
	it("rejects storage changes after upload without overwriting the old media", async () => {
		mocks.complete.mockImplementationOnce((key: string) =>
			Effect.sync(() => {
				objects.set(key, { ETag: "new-video", ContentLength: 100 });
				video.bucketId = Option.some(
					S3Bucket.S3BucketId.make("different-storage"),
				);
				return { ETag: "new-video" };
			}),
		);
		expect((await complete()).status).toBe(500);
		expect(video.source.outputKey).toBe(oldKey);
		expect(objects.get(oldKey)?.ETag).toBe("original");
		expect(updates).toEqual([]);
	});
	it("completes repeated publication requests without recompleting or retiring again", async () => {
		expect((await complete()).status).toBe(200);
		expect((await complete()).status).toBe(200);
		expect(mocks.complete).toHaveBeenCalledTimes(1);
		expect(mocks.prepareReplacement).toHaveBeenCalledTimes(1);
	});
	it("rejects competing replacements after another operation publishes", async () => {
		const competing = createDesktopReuploadToken(video, {
			uploadId: "competing",
			provider,
			outputKey: createDesktopReuploadKey(video),
		});
		expect((await complete()).status).toBe(200);
		expect((await complete(true, competing)).status).toBe(500);
		expect(video.source.outputKey).toBe(outputKey);
		expect(mocks.complete).toHaveBeenCalledTimes(1);
	});
	it("preserves newer upload bookkeeping when an older replacement completes", async () => {
		uploadKey = "newer-operation";
		expect((await complete()).status).toBe(500);
		expect(video.source.outputKey).toBe(oldKey);
		expect(uploadKey).toBe("newer-operation");
	});
	it("does not delete published Drive mappings on a late abort", async () => {
		provider = "googleDrive";
		mintToken();
		expect((await complete()).status).toBe(200);
		expect((await abort()).status).toBe(200);
		expect(mocks.abort).not.toHaveBeenCalled();
		expect(video.source.outputKey).toBe(outputKey);
	});
	it("preserves Drive mappings when abort races with publication", async () => {
		provider = "googleDrive";
		mintToken();
		expect((await abort()).status).toBe(200);
		expect(mocks.abort).not.toHaveBeenCalled();
	});
	it.each(["s3", "googleDrive"] as const)(
		"cancels %s replacement after storage completion and database failure",
		async (storageProvider) => {
			provider = storageProvider;
			mintToken();
			rejectCommit = true;
			expect((await complete()).status).toBe(500);
			mocks.abort.mockReturnValue(Effect.fail(new Error("NoSuchUpload")));
			expect((await abort()).status).toBe(200);
			expect(uploadKey).toBeNull();
			rejectCommit = false;
			mocks.complete.mockReturnValue(Effect.fail(new Error("NoSuchUpload")));
			expect((await complete()).status).toBe(500);
			expect(video.source.outputKey).toBe(oldKey);
			expect(objects.get(oldKey)?.ETag).toBe("original");
		},
	);
	it.each(["s3", "googleDrive"] as const)(
		"rejects over-limit %s replacement without changing original playback",
		async (storageProvider) => {
			provider = storageProvider;
			mintToken();
			expect(
				(
					await complete(
						true,
						token,
						Video.FREE_PLAN_MAX_RECORDING_SECONDS + 100,
					)
				).status,
			).toBe(403);
			expect(uploadKey).toBeNull();
			expect(video.source.outputKey).toBe(oldKey);
			expect(objects.get(oldKey)?.ETag).toBe("original");
			if (provider === "googleDrive")
				expect(mocks.abort).not.toHaveBeenCalled();
			else
				expect(mocks.abort).toHaveBeenCalledWith(outputKey, "backend-upload");
		},
	);
	it("preserves a newer upload when rejecting an older over-limit replacement", async () => {
		uploadKey = "newer-operation";
		expect(
			(await complete(true, token, Video.FREE_PLAN_MAX_RECORDING_SECONDS + 100))
				.status,
		).toBe(403);
		expect(uploadKey).toBe("newer-operation");
	});
	it("restarts a legacy session without completing its canonical object", async () => {
		const initiate = (replaceExisting: boolean) =>
			app.request("/initiate", {
				method: "POST",
				headers: { "Content-Type": "application/json" },
				body: JSON.stringify({
					videoId: "video",
					contentType: "video/mp4",
					replaceExisting,
				}),
			});
		const legacy = await initiate(false);
		expect(legacy.status).toBe(200);
		const { uploadId: legacyId } = await legacy.json();
		const rejected = await complete(true, legacyId);
		expect(rejected.status).toBe(409);
		expect(await rejected.json()).toMatchObject({
			code: "REPLACEMENT_RESTART_REQUIRED",
		});
		expect(mocks.complete).not.toHaveBeenCalled();
		expect(video.source.outputKey).toBe(oldKey);
		const retry = await initiate(true);
		expect(retry.status).toBe(200);
		const { uploadId: replacementId } = await retry.json();
		const replacement = decodeDesktopReuploadToken(replacementId);
		expect(replacement).not.toBeNull();
		expect((await complete(true, replacementId)).status).toBe(200);
		expect(video.source.outputKey).toBe(replacement?.outputKey);
		expect(objects.get(oldKey)?.ETag).toBe("original");
		expect(mocks.complete).toHaveBeenCalledTimes(1);
	});
	it("signs only the authenticated replacement key and backend session", async () => {
		const response = await app.request("/presign-part", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({
				videoId: "video",
				uploadId: token,
				partNumber: 1,
			}),
		});
		expect(response.status).toBe(200);
		expect(mocks.sign).toHaveBeenCalledWith(
			outputKey,
			"backend-upload",
			1,
			expect.anything(),
		);
	});
	it("rejects tampered replacement sessions without presigning storage", async () => {
		const tampered = `${token.slice(0, -3)}bad`;
		const response = await app.request("/presign-part", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({
				videoId: "video",
				uploadId: tampered,
				partNumber: 1,
			}),
		});
		expect(response.status).toBe(500);
		expect(mocks.sign).not.toHaveBeenCalled();
	});
});

describe("raw recording completion integrity", () => {
	const firstPart = {
		partNumber: 1,
		etag: "7fc56270e7a70fa81a5935b72eacbe29",
		size: 1,
	};
	const secondPart = {
		partNumber: 2,
		etag: "9d5ed678fe57bcca610140957afab571",
		size: 1,
	};
	const parts = [firstPart, secondPart];
	const etag = '"938e9f75e9874032440e416d025877f8-2"';
	const complete = (submittedParts = parts) =>
		app.request("/complete", {
			method: "POST",
			headers: { "Content-Type": "application/json" },
			body: JSON.stringify({
				videoId: "video",
				uploadId: "same-upload",
				subpath: "raw-upload.webm",
				durationInSecs: 1,
				parts: submittedParts,
			}),
		});

	beforeEach(() => {
		vi.clearAllMocks();
		mocks.getOwnedById.mockReturnValue(
			Effect.succeed(
				Option.some([
					{
						id: Video.VideoId.make("video"),
						ownerId: User.UserId.make("owner"),
						source: { type: "webMP4" },
						bucketId: Option.none(),
						storageIntegrationId: Option.none(),
					},
				]),
			),
		);
		mocks.database.mockReturnValue({
			update: () => ({ set: () => ({ where: async () => {} }) }),
		});
		mocks.complete.mockReturnValue(Effect.succeed({ ETag: etag }));
		mocks.head.mockReturnValue(
			Effect.succeed({ ETag: etag, ContentLength: 2 }),
		);
		mocks.storage.mockReturnValue(
			Effect.succeed([
				{
					provider: "s3",
					multipart: { complete: mocks.complete },
					headObject: mocks.head,
				},
			]),
		);
	});

	it("acknowledges only the assembled recording with matching size", async () => {
		const response = await complete();
		expect(response.status).toBe(200);
		expect(await response.json()).toMatchObject({
			success: true,
			processingStarted: true,
		});
		expect(mocks.head).toHaveBeenCalledWith("owner/video/raw-upload.webm");
	});

	it("reconciles a lost completion response using all part identities and object size", async () => {
		mocks.complete.mockReturnValue(Effect.fail(new Error("NoSuchUpload")));
		const response = await complete([...parts].reverse());
		expect(response.status).toBe(200);
		expect(await response.json()).toMatchObject({
			success: true,
			objectIdentity: etag,
		});
		expect(mocks.abort).not.toHaveBeenCalled();
	});

	it.each([
		{ ETag: '"different"', ContentLength: 2 },
		{ ETag: etag, ContentLength: 1 },
		{ ETag: "provider-specific", ContentLength: 2 },
	])(
		"does not accept a different or unverifiable object after completion fails",
		async (head) => {
			mocks.complete.mockReturnValue(Effect.fail(new Error("NoSuchUpload")));
			mocks.head.mockReturnValue(Effect.succeed(head));
			const response = await complete();
			expect(response.status).toBe(500);
			const { startVideoProcessingWorkflow } = await import(
				"@/lib/video-processing"
			);
			expect(startVideoProcessingWorkflow).not.toHaveBeenCalled();
		},
	);

	it("does not acknowledge success if provider verification finds missing bytes", async () => {
		mocks.head.mockReturnValue(
			Effect.succeed({ ETag: etag, ContentLength: 1 }),
		);
		expect((await complete()).status).toBe(500);
		const { startVideoProcessingWorkflow } = await import(
			"@/lib/video-processing"
		);
		expect(startVideoProcessingWorkflow).not.toHaveBeenCalled();
	});

	it.each([
		{ invalid: [] },
		{ invalid: [secondPart] },
		{ invalid: [firstPart, firstPart] },
		{ invalid: [{ ...firstPart, size: 0 }] },
		{ invalid: [{ ...firstPart, size: 1.5 }] },
	])(
		"rejects incomplete or invalid part lists before completing storage",
		async ({ invalid }) => {
			expect((await complete(invalid)).status).toBe(400);
			expect(mocks.complete).not.toHaveBeenCalled();
		},
	);
});