Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

fix(storage): preserve IndexedDB Map and Set values (#42707)

Yury Semikhatskyd4ce80d1c42e
diff --git a/packages/injected/src/storageScript.ts b/packages/injected/src/storageScript.ts
index aae4653ce4..f7e4d37809 100644
--- a/packages/injected/src/storageScript.ts
+++ b/packages/injected/src/storageScript.ts
@@ -77,7 +77,7 @@ export class StorageScript {
trivial = false;
return { fallThrough: v };
- });
+ }, { extendedSerialization: true });
if (trivial)
return { trivial: value };
return { encoded };
diff --git a/packages/isomorphic/utilityScriptSerializers.ts b/packages/isomorphic/utilityScriptSerializers.ts
index 7e5264e303..7132bc8626 100644
--- a/packages/isomorphic/utilityScriptSerializers.ts
+++ b/packages/isomorphic/utilityScriptSerializers.ts
@@ -33,6 +33,8 @@ export type SerializedValue =
{ r: { p: string, f: string } } |
{ a: SerializedValue[], id: number } |
{ o: { k: string, v: SerializedValue }[], id: number } |
+ { m: { k: SerializedValue, v: SerializedValue }[], id: number } |
+ { s: SerializedValue[], id: number } |
{ ref: number } |
{ h: number } |
{ fn: string } |
@@ -44,6 +46,7 @@ type HandleOrValue = { h: number } | { fn: string } | { fallThrough: any };
type VisitorInfo = {
visited: Map<object, number>;
lastId: number;
+ extendedSerialization?: boolean;
};
function isRegExp(obj: any): obj is RegExp {
@@ -95,6 +98,22 @@ function isArrayBuffer(obj: any): obj is ArrayBuffer {
}
}
+function isMap(obj: any): obj is Map<unknown, unknown> {
+ try {
+ return obj instanceof Map || Object.prototype.toString.call(obj) === '[object Map]';
+ } catch (error) {
+ return false;
+ }
+}
+
+function isSet(obj: any): obj is Set<unknown> {
+ try {
+ return obj instanceof Set || Object.prototype.toString.call(obj) === '[object Set]';
+ } catch (error) {
+ return false;
+ }
+}
+
const typedArrayConstructors: Record<TypedArrayKind, Function> = {
i8: Int8Array,
ui8: Uint8Array,
@@ -183,6 +202,20 @@ export function parseEvaluationResultValue(value: SerializedValue, handles: any[
}
return result;
}
+ if ('m' in value) {
+ const result = new Map();
+ refs.set(value.id, result);
+ for (const { k, v } of value.m)
+ result.set(parseEvaluationResultValue(k, handles, refs), parseEvaluationResultValue(v, handles, refs));
+ return result;
+ }
+ if ('s' in value) {
+ const result = new Set();
+ refs.set(value.id, result);
+ for (const item of value.s)
+ result.add(parseEvaluationResultValue(item, handles, refs));
+ return result;
+ }
if ('h' in value)
return handles[value.h];
if ('fn' in value) {
@@ -198,8 +231,8 @@ export function parseEvaluationResultValue(value: SerializedValue, handles: any[
return value;
}
-export function serializeAsCallArgument(value: any, handleSerializer: (value: any) => HandleOrValue): SerializedValue {
- return serialize(value, handleSerializer, { visited: new Map(), lastId: 0 });
+export function serializeAsCallArgument(value: any, handleSerializer: (value: any) => HandleOrValue, options: { extendedSerialization?: boolean } = {}): SerializedValue {
+ return serialize(value, handleSerializer, { visited: new Map(), lastId: 0, extendedSerialization: options.extendedSerialization });
}
function serialize(value: any, handleSerializer: (value: any) => HandleOrValue, visitorInfo: VisitorInfo): SerializedValue {
@@ -275,6 +308,37 @@ function innerSerialize(value: any, handleSerializer: (value: any) => HandleOrVa
if (id)
return { ref: id };
+ if (visitorInfo.extendedSerialization) {
+ if (isMap(value)) {
+ const m: { k: SerializedValue, v: SerializedValue }[] = [];
+ const id = ++visitorInfo.lastId;
+ visitorInfo.visited.set(value, id);
+ const iterator = value.entries();
+ const next = new Map().entries().next;
+ while (true) {
+ const entry = next.call(iterator);
+ if (entry.done)
+ break;
+ m.push({ k: serialize(entry.value[0], handleSerializer, visitorInfo), v: serialize(entry.value[1], handleSerializer, visitorInfo) });
+ }
+ return { m, id };
+ }
+ if (isSet(value)) {
+ const s: SerializedValue[] = [];
+ const id = ++visitorInfo.lastId;
+ visitorInfo.visited.set(value, id);
+ const iterator = value.values();
+ const next = new Set().values().next;
+ while (true) {
+ const entry = next.call(iterator);
+ if (entry.done)
+ break;
+ s.push(serialize(entry.value, handleSerializer, visitorInfo));
+ }
+ return { s, id };
+ }
+ }
+
if (Array.isArray(value)) {
const a = [];
const id = ++visitorInfo.lastId;
diff --git a/tests/library/browsercontext-storage-state.spec.ts b/tests/library/browsercontext-storage-state.spec.ts
index 5d5724fc7e..d64808bd2e 100644
--- a/tests/library/browsercontext-storage-state.spec.ts
+++ b/tests/library/browsercontext-storage-state.spec.ts
@@ -648,6 +648,66 @@ it('should support IndexedDB', async ({ page, server, contextFactory }) => {
expect(await context.storageState()).toEqual({ cookies: [], origins: [] });
});
+for (const restore of ['newContext', 'setStorageState'] as const) {
+ it(`should roundtrip IndexedDB Map and Set with ${restore}`, { annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/42703' } }, async ({ page, server, contextFactory }, testInfo) => {
+ await page.goto(server.EMPTY_PAGE);
+ await page.evaluate(() => new Promise<void>((resolve, reject) => {
+ const request = indexedDB.open('collections', 1);
+ request.onupgradeneeded = () => request.result.createObjectStore('store');
+ request.onerror = () => reject(request.error);
+ request.onsuccess = () => {
+ const db = request.result;
+ const transaction = db.transaction('store', 'readwrite');
+ const store = transaction.objectStore('store');
+ store.put(new Map([['mk', 'mv']]), 'map');
+ store.put(new Set([1, 2]), 'set');
+ transaction.oncomplete = () => {
+ db.close();
+ resolve();
+ };
+ transaction.onerror = () => reject(transaction.error);
+ };
+ }));
+
+ const path = testInfo.outputPath('storage-state.json');
+ const storageState = await page.context().storageState({ indexedDB: true, path });
+ const context = await contextFactory(restore === 'newContext' ? { storageState: path } : {});
+ if (restore === 'setStorageState')
+ await context.setStorageState(storageState);
+ expect(await context.storageState({ indexedDB: true })).toEqual(storageState);
+
+ const restoredPage = await context.newPage();
+ await restoredPage.goto(server.EMPTY_PAGE);
+ const values = await restoredPage.evaluate(async () => {
+ const db = await new Promise<IDBDatabase>((resolve, reject) => {
+ const request = indexedDB.open('collections', 1);
+ request.onerror = () => reject(request.error);
+ request.onsuccess = () => resolve(request.result);
+ });
+ const transaction = db.transaction('store', 'readonly');
+ const store = transaction.objectStore('store');
+ transaction.oncomplete = () => db.close();
+ const [map, set] = await Promise.all(['map', 'set'].map(key => new Promise<any>((resolve, reject) => {
+ const request = store.get(key);
+ request.onsuccess = () => resolve(request.result);
+ request.onerror = () => reject(request.error);
+ })));
+ return {
+ isMap: map instanceof Map,
+ map: [...map],
+ isSet: set instanceof Set,
+ set: [...set],
+ };
+ });
+ expect(values).toEqual({
+ isMap: true,
+ map: [['mk', 'mv']],
+ isSet: true,
+ set: [1, 2],
+ });
+ });
+}
+
it('should support empty indexedDB', { annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/35760' } }, async ({ page, server, contextFactory }) => {
await page.goto(server.EMPTY_PAGE);
await page.evaluate(() => new Promise<void>(resolve => {
diff --git a/tests/page/page-evaluate.spec.ts b/tests/page/page-evaluate.spec.ts
index 3877fc256f..fcbc9f11b4 100644
--- a/tests/page/page-evaluate.spec.ts
+++ b/tests/page/page-evaluate.spec.ts
@@ -123,6 +123,13 @@ it('should transfer bigint', async ({ page }) => {
it('should transfer maps as empty objects', async ({ page }) => {
const result = await page.evaluate(a => a.x.constructor.name + ' ' + JSON.stringify(a.x), { x: new Map([[1, 2]]) });
expect(result).toBe('Object {}');
+ expect(await page.evaluate(() => new Map([[1, 2]]))).toEqual({});
+});
+
+it('should transfer sets as empty objects', async ({ page }) => {
+ const result = await page.evaluate(a => a.x.constructor.name + ' ' + JSON.stringify(a.x), { x: new Set([1, 2]) });
+ expect(result).toBe('Object {}');
+ expect(await page.evaluate(() => new Set([1, 2]))).toEqual({});
});
it('should modify global environment', async ({ page }) => {