114 lines
5.7 KiB
TypeScript
114 lines
5.7 KiB
TypeScript
import { expect, test } from "@playwright/test";
|
|
import fs from "node:fs";
|
|
import path from "node:path";
|
|
|
|
const catalog = JSON.parse(fs.readFileSync(
|
|
path.resolve(import.meta.dirname, "../../../tests/golden/M12-01D/catalog-v2.json"),
|
|
"utf8",
|
|
)) as Record<string, unknown>;
|
|
const identity = JSON.parse(fs.readFileSync(
|
|
path.resolve(import.meta.dirname, "../../../tests/golden/M12-02B/identity.json"),
|
|
"utf8",
|
|
)) as Record<string, unknown>;
|
|
const preview = fs.readFileSync(path.resolve(import.meta.dirname, "../../../tests/golden/M12-02B/preview.png"));
|
|
|
|
test("M12-02E deduplicates preview content without merging asset metadata", async ({ page }) => {
|
|
await page.goto("/");
|
|
const result = await page.evaluate(async ({ sourceCatalog, sourceIdentity, bytes }) => {
|
|
const storage = await import("/src/storage/asset-preview-opfs-commit.ts");
|
|
const encoded = new Uint8Array(bytes).buffer;
|
|
const base = await storage.parseAssetCatalogManifestV2({
|
|
...sourceCatalog,
|
|
assets: (sourceCatalog.assets as Array<Record<string, unknown>>).map((asset) => ({ ...asset, preview: null })),
|
|
});
|
|
const identities = [];
|
|
for (const asset of base.assets) {
|
|
const input = { ...sourceIdentity, assetId: asset.assetId } as Record<string, unknown>;
|
|
delete input.identitySha256;
|
|
identities.push(await storage.createAssetPreviewIdentity(input as never));
|
|
}
|
|
const databaseName = `m12-02e-${crypto.randomUUID()}`;
|
|
const projectId = `m12-02e-${crypto.randomUUID()}`;
|
|
const open = (): Promise<IDBDatabase> => new Promise((resolve, reject) => {
|
|
const request = indexedDB.open(databaseName, 1);
|
|
request.onupgradeneeded = () => request.result.createObjectStore("setting", { keyPath: "id" });
|
|
request.onsuccess = () => resolve(request.result);
|
|
request.onerror = () => reject(request.error);
|
|
});
|
|
const complete = (transaction: IDBTransaction): Promise<void> => new Promise((resolve, reject) => {
|
|
transaction.oncomplete = () => resolve();
|
|
transaction.onerror = () => reject(transaction.error);
|
|
transaction.onabort = () => reject(transaction.error);
|
|
});
|
|
let database = await open();
|
|
const seed = database.transaction("setting", "readwrite");
|
|
seed.objectStore("setting").put({ id: "asset-catalog:index:v2", value: base });
|
|
await complete(seed);
|
|
const first = await storage.commitAssetPreviewToOPFS(database, projectId, 7, identities[0], encoded.slice(0));
|
|
const second = await storage.commitAssetPreviewToOPFS(database, projectId, 8, identities[1], encoded.slice(0));
|
|
database.close();
|
|
database = await open();
|
|
const reopened = await storage.loadCommittedAssetPreviewCatalog(database);
|
|
|
|
const root = await navigator.storage.getDirectory();
|
|
let contentDirectory = root;
|
|
for (const segment of ["projects", projectId, "assets", "sha256", identities[0].content.sha256.slice(0, 2)]) {
|
|
contentDirectory = await contentDirectory.getDirectoryHandle(segment);
|
|
}
|
|
const files: string[] = [];
|
|
for await (const [name, handle] of (contentDirectory as unknown as { entries: () => AsyncIterable<[string, FileSystemHandle]> }).entries()) {
|
|
if (handle.kind === "file") files.push(name);
|
|
}
|
|
files.sort();
|
|
const stored = await (await contentDirectory.getFileHandle(identities[0].content.sha256)).getFile();
|
|
const storedBytes = await stored.arrayBuffer();
|
|
const storedSha256 = Array.from(new Uint8Array(await crypto.subtle.digest("SHA-256", storedBytes)),
|
|
(byte) => byte.toString(16).padStart(2, "0")).join("");
|
|
const withoutPreview = (asset: Record<string, unknown>) => {
|
|
const copy = { ...asset };
|
|
delete copy.preview;
|
|
return copy;
|
|
};
|
|
const resultValue = {
|
|
first: { revision: first.manifest.revision, deduplicated: first.deduplicated, identity: identities[0].identitySha256 },
|
|
second: { revision: second.manifest.revision, deduplicated: second.deduplicated, identity: identities[1].identitySha256 },
|
|
contentSha256: identities[0].content.sha256,
|
|
files,
|
|
storedBytes: stored.size,
|
|
storedSha256,
|
|
baseMetadata: base.assets.map((asset) => withoutPreview(asset as unknown as Record<string, unknown>)),
|
|
committedMetadata: second.manifest.assets.map((asset) => withoutPreview(asset as unknown as Record<string, unknown>)),
|
|
previews: second.manifest.assets.map((asset) => asset.preview),
|
|
reopened: {
|
|
revision: reopened.manifest.revision,
|
|
receiptAssetId: reopened.receipt.assetId,
|
|
preview: reopened.preview,
|
|
},
|
|
assetIds: base.assets.map((asset) => asset.assetId),
|
|
};
|
|
database.close();
|
|
indexedDB.deleteDatabase(databaseName);
|
|
const projects = await root.getDirectoryHandle("projects");
|
|
await projects.removeEntry(projectId, { recursive: true });
|
|
return resultValue;
|
|
}, { sourceCatalog: catalog, sourceIdentity: identity, bytes: [...preview] });
|
|
|
|
expect(result.first).toMatchObject({ revision: 8, deduplicated: false });
|
|
expect(result.second).toMatchObject({ revision: 9, deduplicated: true });
|
|
expect(result.first.identity).not.toBe(result.second.identity);
|
|
expect(result.files).toEqual([result.contentSha256]);
|
|
expect(result.storedBytes).toBe(513);
|
|
expect(result.storedSha256).toBe(result.contentSha256);
|
|
expect(result.committedMetadata).toEqual(result.baseMetadata);
|
|
expect(result.committedMetadata[0]).not.toEqual(result.committedMetadata[1]);
|
|
expect(result.previews).toEqual([
|
|
{ sha256: result.contentSha256, mimeType: "image/png", width: 8, height: 8, byteLength: 513 },
|
|
{ sha256: result.contentSha256, mimeType: "image/png", width: 8, height: 8, byteLength: 513 },
|
|
]);
|
|
expect(result.reopened).toEqual({
|
|
revision: 9,
|
|
receiptAssetId: result.assetIds[1],
|
|
preview: result.previews[1],
|
|
});
|
|
});
|