mirror of
https://github.com/lexmount/moli.git
synced 2026-11-21 00:03:15 +00:00
fix(indexeddb): store native DOMException payloads
This commit is contained in:
@@ -1,4 +1,9 @@
|
||||
use super::*;
|
||||
use crate::structured_clone::{
|
||||
HOST_OBJECT_TAG_DOM_EXCEPTION, HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR,
|
||||
read_dom_exception_payload, read_quota_exceeded_error_payload, write_dom_exception_payload,
|
||||
write_quota_exceeded_error_payload,
|
||||
};
|
||||
use crate::{
|
||||
context_bootstrap::{
|
||||
FileSystemHandleDurablePayload, build_file_system_handle_from_durable_payload,
|
||||
@@ -51,6 +56,16 @@ impl v8::ValueSerializerImpl for IndexedDbStructuredCloneSerializer {
|
||||
serializer: &dyn v8::ValueSerializerHelper,
|
||||
) -> Option<bool> {
|
||||
match moli_webapi_declare::web_api_object_type(scope, object).map(|kind| kind.name()) {
|
||||
Some("DOMException")
|
||||
if write_dom_exception_payload(scope, object, serializer).is_some() =>
|
||||
{
|
||||
return Some(true);
|
||||
}
|
||||
Some("QuotaExceededError")
|
||||
if write_quota_exceeded_error_payload(scope, object, serializer).is_some() =>
|
||||
{
|
||||
return Some(true);
|
||||
}
|
||||
Some("EncodedVideoChunk") => {
|
||||
let exception = dom_exception_value(
|
||||
scope,
|
||||
@@ -180,6 +195,10 @@ impl v8::ValueDeserializerImpl for IndexedDbStructuredCloneDeserializer {
|
||||
return None;
|
||||
}
|
||||
match tag {
|
||||
HOST_OBJECT_TAG_DOM_EXCEPTION => read_dom_exception_payload(scope, deserializer),
|
||||
HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR => {
|
||||
read_quota_exceeded_error_payload(scope, deserializer)
|
||||
}
|
||||
HOST_OBJECT_TAG_IMAGE_DATA => read_image_data_payload(scope, deserializer),
|
||||
HOST_OBJECT_TAG_CRYPTO_KEY => {
|
||||
read_crypto_key_payload(scope, deserializer).or_else(|| {
|
||||
|
||||
@@ -6595,3 +6595,101 @@ navigator.storageBuckets.open('limited', {quota: 16}).then(bucket => {
|
||||
r#"["abort:QuotaExceededError:0:0:true","open-error:AbortError:true","deleted"]"#
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn indexed_db_roundtrips_native_exception_data_without_author_access() {
|
||||
let mut vm = new_storage_page_task_executor_test_vm("https://indexeddb-exception-data.test/");
|
||||
vm.eval(&format!(
|
||||
"{}\nglobalThis.exceptionPayloadResult = 'pending'; indexedDBExceptionPayloadProbe(globalThis).then(result => {{ exceptionPayloadResult = JSON.stringify(result); }}, error => {{ exceptionPayloadResult = JSON.stringify({{error: error.name + ':' + error.message}}); }});",
|
||||
include_str!("../../../tests/fixtures/indexeddb-exception-payloads.js"),
|
||||
))
|
||||
.expect("IndexedDB exception data probe should schedule");
|
||||
let result = vm
|
||||
.eval_after_selected_page_tasks("String(exceptionPayloadResult)")
|
||||
.expect("IndexedDB exception data probe should complete");
|
||||
let result: serde_json::Value = serde_json::from_str(&result).unwrap();
|
||||
assert_eq!(result["failures"], serde_json::json!([]), "{result}");
|
||||
assert_eq!(result["rows"].as_array().unwrap().len(), 225, "{result}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn indexed_db_native_exception_data_survives_profile_restart() {
|
||||
let root = indexed_db_test_root("exception-data-profile-restart");
|
||||
let page_url = "https://indexeddb-exception-profile.test/";
|
||||
for phase in ["write", "read"] {
|
||||
let manager = crate::new_indexed_db_manager(Some(root.clone()))
|
||||
.expect("durable IndexedDB manager should initialize");
|
||||
let mut vm = new_storage_page_task_executor_test_vm(page_url);
|
||||
vm.set_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager)));
|
||||
vm.eval(&format!("globalThis.exceptionPayloadPhase = {phase:?};"))
|
||||
.unwrap();
|
||||
vm.eval(
|
||||
r#"
|
||||
globalThis.exceptionPayloadRestart = 'pending';
|
||||
(async () => {
|
||||
const request = value => new Promise((resolve, reject) => {
|
||||
value.onsuccess = () => resolve(value.result);
|
||||
value.onerror = () => reject(value.error);
|
||||
});
|
||||
const done = tx => new Promise((resolve, reject) => {
|
||||
tx.oncomplete = resolve; tx.onabort = () => reject(tx.error);
|
||||
});
|
||||
const open = indexedDB.open('durable-exceptions', 1);
|
||||
open.onupgradeneeded = () => open.result.createObjectStore('values');
|
||||
const db = await request(open);
|
||||
try {
|
||||
if (exceptionPayloadPhase === 'write') {
|
||||
const error = new DOMException('stored\u0000\ud83d\ude00', 'AbortError');
|
||||
const quota = new QuotaExceededError('full', {quota:0, requested:12.5});
|
||||
const value = {error, alias:error, quota}; value.self = value;
|
||||
const tx = db.transaction('values','readwrite'), complete = done(tx);
|
||||
tx.objectStore('values').put(value, 'record'); await complete;
|
||||
exceptionPayloadRestart = 'stored';
|
||||
} else {
|
||||
const tx = db.transaction('values'), complete = done(tx);
|
||||
const value = await request(tx.objectStore('values').get('record'));
|
||||
await complete;
|
||||
exceptionPayloadRestart = JSON.stringify([
|
||||
value.self === value, value.error === value.alias,
|
||||
Object.getPrototypeOf(value.error) === DOMException.prototype,
|
||||
value.error.name, value.error.message, value.error.code,
|
||||
Object.getPrototypeOf(value.quota) === QuotaExceededError.prototype,
|
||||
value.quota.name, value.quota.message, value.quota.code,
|
||||
value.quota.quota, value.quota.requested,
|
||||
!Object.hasOwn(value.error,'stack'), !Object.hasOwn(value.quota,'stack')
|
||||
]);
|
||||
}
|
||||
} finally { db.close(); }
|
||||
})().catch(error => { exceptionPayloadRestart = error.name+':'+error.message; });
|
||||
"#,
|
||||
)
|
||||
.expect("durable exception data workflow should schedule");
|
||||
let result = vm
|
||||
.eval_after_selected_page_tasks("String(exceptionPayloadRestart)")
|
||||
.expect("durable exception data workflow should complete");
|
||||
if phase == "write" {
|
||||
assert_eq!(result, "stored");
|
||||
} else {
|
||||
assert_eq!(
|
||||
serde_json::from_str::<serde_json::Value>(&result).unwrap(),
|
||||
serde_json::json!([
|
||||
true,
|
||||
true,
|
||||
true,
|
||||
"AbortError",
|
||||
"stored\0😀",
|
||||
20,
|
||||
true,
|
||||
"QuotaExceededError",
|
||||
"full",
|
||||
22,
|
||||
0,
|
||||
12.5,
|
||||
true,
|
||||
true
|
||||
])
|
||||
);
|
||||
}
|
||||
}
|
||||
let _ = std::fs::remove_dir_all(root);
|
||||
}
|
||||
|
||||
@@ -43,9 +43,9 @@ pub(crate) const HOST_OBJECT_TAG_IMAGE_DATA: u32 = 2;
|
||||
pub(crate) const HOST_OBJECT_TAG_CRYPTO_KEY: u32 = 3;
|
||||
const HOST_OBJECT_TAG_READABLE_STREAM: u32 = 4;
|
||||
pub(crate) const HOST_OBJECT_TAG_BLOB: u32 = 5;
|
||||
const HOST_OBJECT_TAG_DOM_EXCEPTION: u32 = 6;
|
||||
pub(crate) const HOST_OBJECT_TAG_DOM_EXCEPTION: u32 = 6;
|
||||
pub(crate) const HOST_OBJECT_TAG_FILE_SYSTEM_HANDLE: u32 = 7;
|
||||
const HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR: u32 = 8;
|
||||
pub(crate) const HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR: u32 = 8;
|
||||
const HOST_OBJECT_TAG_WRITABLE_STREAM: u32 = 9;
|
||||
const HOST_OBJECT_TAG_TRANSFORM_STREAM: u32 = 10;
|
||||
const HOST_OBJECT_TAG_ENCODED_VIDEO_CHUNK: u32 = 13;
|
||||
@@ -532,24 +532,15 @@ impl v8::ValueSerializerImpl for WireSerializer {
|
||||
return Some(true);
|
||||
}
|
||||
}
|
||||
Some("QuotaExceededError") => {
|
||||
if let Some((message, quota, requested)) =
|
||||
quota_exceeded_error_clone_fields(scope, object)
|
||||
{
|
||||
serializer.write_uint32(HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR);
|
||||
write_string(serializer, &message);
|
||||
write_optional_double(serializer, quota);
|
||||
write_optional_double(serializer, requested);
|
||||
return Some(true);
|
||||
}
|
||||
Some("QuotaExceededError")
|
||||
if write_quota_exceeded_error_payload(scope, object, serializer).is_some() =>
|
||||
{
|
||||
return Some(true);
|
||||
}
|
||||
Some("DOMException") => {
|
||||
if let Some((message, name)) = dom_exception_clone_fields(scope, object) {
|
||||
serializer.write_uint32(HOST_OBJECT_TAG_DOM_EXCEPTION);
|
||||
write_string(serializer, &message);
|
||||
write_string(serializer, &name);
|
||||
return Some(true);
|
||||
}
|
||||
Some("DOMException")
|
||||
if write_dom_exception_payload(scope, object, serializer).is_some() =>
|
||||
{
|
||||
return Some(true);
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
@@ -783,18 +774,9 @@ impl v8::ValueDeserializerImpl for WireDeserializer {
|
||||
None
|
||||
})
|
||||
}
|
||||
HOST_OBJECT_TAG_DOM_EXCEPTION => {
|
||||
let message = read_string(deserializer)?;
|
||||
let name = read_string(deserializer)?;
|
||||
Some(build_dom_exception_object(scope, &message, &name))
|
||||
}
|
||||
HOST_OBJECT_TAG_DOM_EXCEPTION => read_dom_exception_payload(scope, deserializer),
|
||||
HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR => {
|
||||
let message = read_string(deserializer)?;
|
||||
let quota = read_optional_double(deserializer)?;
|
||||
let requested = read_optional_double(deserializer)?;
|
||||
Some(build_quota_exceeded_error_object(
|
||||
scope, &message, quota, requested,
|
||||
))
|
||||
read_quota_exceeded_error_payload(scope, deserializer)
|
||||
}
|
||||
_ => {
|
||||
throw_data_clone_exception(scope, "Unsupported structured clone host object.");
|
||||
@@ -989,6 +971,52 @@ pub(crate) fn read_crypto_key_payload<'s>(
|
||||
)
|
||||
}
|
||||
|
||||
pub(crate) fn write_dom_exception_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
serializer: &dyn v8::ValueSerializerHelper,
|
||||
) -> Option<()> {
|
||||
let (message, name) = dom_exception_clone_fields(scope, object)?;
|
||||
serializer.write_uint32(HOST_OBJECT_TAG_DOM_EXCEPTION);
|
||||
write_string(serializer, &message);
|
||||
write_string(serializer, &name);
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub(crate) fn read_dom_exception_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
deserializer: &dyn v8::ValueDeserializerHelper,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let message = read_string(deserializer)?;
|
||||
let name = read_string(deserializer)?;
|
||||
Some(build_dom_exception_object(scope, &message, &name))
|
||||
}
|
||||
|
||||
pub(crate) fn write_quota_exceeded_error_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
object: v8::Local<'s, v8::Object>,
|
||||
serializer: &dyn v8::ValueSerializerHelper,
|
||||
) -> Option<()> {
|
||||
let (message, quota, requested) = quota_exceeded_error_clone_fields(scope, object)?;
|
||||
serializer.write_uint32(HOST_OBJECT_TAG_QUOTA_EXCEEDED_ERROR);
|
||||
write_string(serializer, &message);
|
||||
write_optional_double(serializer, quota);
|
||||
write_optional_double(serializer, requested);
|
||||
Some(())
|
||||
}
|
||||
|
||||
pub(crate) fn read_quota_exceeded_error_payload<'s>(
|
||||
scope: &mut v8::PinScope<'s, '_>,
|
||||
deserializer: &dyn v8::ValueDeserializerHelper,
|
||||
) -> Option<v8::Local<'s, v8::Object>> {
|
||||
let message = read_string(deserializer)?;
|
||||
let quota = read_optional_double(deserializer)?;
|
||||
let requested = read_optional_double(deserializer)?;
|
||||
Some(build_quota_exceeded_error_object(
|
||||
scope, &message, quota, requested,
|
||||
))
|
||||
}
|
||||
|
||||
fn write_string(serializer: &dyn v8::ValueSerializerHelper, value: &str) {
|
||||
write_raw_vec(serializer, value.as_bytes());
|
||||
}
|
||||
|
||||
@@ -60,3 +60,67 @@ async fn indexed_db_global_attribute_preserves_receivers_and_identity_across_wor
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn indexed_db_preserves_native_exception_data_across_worker_kinds() {
|
||||
ensure_v8();
|
||||
let manager = crate::new_indexed_db_manager(None).unwrap();
|
||||
let storage_key = moli_storage_key::MoliStorageKey::new(
|
||||
"https://indexeddb-exception-data.test".to_owned(),
|
||||
"https://indexeddb-exception-data.test".to_owned(),
|
||||
None,
|
||||
moli_storage_key::StoragePartitionRelation::FirstParty,
|
||||
);
|
||||
for (kind, script_kind) in [
|
||||
(
|
||||
WorkerGlobalKind::Dedicated {
|
||||
name: String::new(),
|
||||
},
|
||||
WorkerScriptKind::Classic,
|
||||
),
|
||||
(
|
||||
WorkerGlobalKind::Dedicated {
|
||||
name: String::new(),
|
||||
},
|
||||
WorkerScriptKind::Module,
|
||||
),
|
||||
(
|
||||
WorkerGlobalKind::Shared {
|
||||
name: "exceptions".to_owned(),
|
||||
storage_key,
|
||||
},
|
||||
WorkerScriptKind::Classic,
|
||||
),
|
||||
(
|
||||
WorkerGlobalKind::Service {
|
||||
registration_id: ServiceWorkerRegistrationId::from_u64_for_test(1),
|
||||
version_id: ServiceWorkerVersionId::from_u64_for_test(1),
|
||||
scope_url: url::Url::parse("https://indexeddb-exception-data.test/").unwrap(),
|
||||
},
|
||||
WorkerScriptKind::Classic,
|
||||
),
|
||||
] {
|
||||
let source = format!(
|
||||
"{}\nindexedDBExceptionPayloadProbe(globalThis).then(result => console.log(JSON.stringify(result)), error => console.log(JSON.stringify({{error: error.name + ':' + error.message}})));",
|
||||
include_str!("../../../../tests/fixtures/indexeddb-exception-payloads.js"),
|
||||
);
|
||||
let mut handle = spawn_test_worker_with_options(
|
||||
WorkerSpawnOptions::new(
|
||||
source,
|
||||
"https://indexeddb-exception-data.test/worker.js".to_owned(),
|
||||
)
|
||||
.with_global_kind(kind)
|
||||
.with_script_kind(script_kind)
|
||||
.with_indexed_db_manager(Some(crate::downgrade_indexed_db_manager(&manager))),
|
||||
);
|
||||
let message = timeout(TIMEOUT, handle.recv()).await.unwrap().unwrap();
|
||||
handle.terminate_and_join();
|
||||
let WorkerToParentMessage::Console(console) = message else {
|
||||
panic!("expected the completed exception data probe, got {message:?}");
|
||||
};
|
||||
let result: serde_json::Value =
|
||||
serde_json::from_str(console.message.strip_prefix("log: ").unwrap()).unwrap();
|
||||
assert_eq!(result["failures"], serde_json::json!([]), "{result}");
|
||||
assert_eq!(result["rows"].as_array().unwrap().len(), 225, "{result}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -0,0 +1,124 @@
|
||||
async function indexedDBExceptionPayloadProbe(global) {
|
||||
const rows = [], failures = [];
|
||||
const check = (name, pass) => {
|
||||
rows.push({name, pass: !!pass});
|
||||
if (!pass) failures.push(name);
|
||||
};
|
||||
const request = value => new Promise((resolve, reject) => {
|
||||
value.onsuccess = () => resolve(value.result);
|
||||
value.onerror = () => reject(value.error);
|
||||
});
|
||||
const completion = tx => new Promise((resolve, reject) => {
|
||||
tx.oncomplete = resolve;
|
||||
tx.onabort = () => reject(tx.error || new Error('transaction aborted'));
|
||||
});
|
||||
const DOM = global.DOMException, Quota = global.QuotaExceededError;
|
||||
const domDescriptor = Object.getOwnPropertyDescriptor(global, 'DOMException');
|
||||
const quotaDescriptor = Object.getOwnPropertyDescriptor(global, 'QuotaExceededError');
|
||||
const message = 'stored\u0000\ud83d\ude00';
|
||||
class Derived extends DOM {}
|
||||
let native;
|
||||
try { global.structuredClone(() => {}); } catch (error) { native = error; }
|
||||
const cases = [
|
||||
{label:'abort', error:new DOM(message, 'AbortError'), ctor:DOM, name:'AbortError', message, code:20},
|
||||
{label:'default', error:new DOM(), ctor:DOM, name:'Error', message:'', code:0},
|
||||
{label:'custom', error:new DOM(message, 'CustomError'), ctor:DOM, name:'CustomError', message, code:0},
|
||||
{label:'base-quota-name', error:new DOM(message, 'QuotaExceededError'), ctor:DOM, name:'QuotaExceededError', message, code:22},
|
||||
{label:'subclass', error:new Derived(message, 'NotFoundError'), ctor:DOM, name:'NotFoundError', message, code:8},
|
||||
{label:'native', error:native, ctor:DOM, name:'DataCloneError', message:native.message, code:25},
|
||||
...[
|
||||
['empty', {}], ['quota', {quota:10}], ['requested', {requested:12}],
|
||||
['zero', {quota:0, requested:0}], ['fraction', {quota:10.25, requested:12.5}]
|
||||
].map(([label, options]) => ({label:'quota-'+label, error:new Quota(message, options),
|
||||
ctor:Quota, name:'QuotaExceededError', message, code:22,
|
||||
quota:options.quota ?? null, requested:options.requested ?? null}))
|
||||
];
|
||||
check('native API exception retains its diagnostic stack', typeof native.stack === 'string');
|
||||
const ordinary = new TypeError('ordinary', {cause:cases[0].error});
|
||||
const ordinaryStack = ordinary.stack;
|
||||
let authorReads = 0;
|
||||
const poison = () => { ++authorReads; throw new Error('author getter must not run'); };
|
||||
for (const entry of cases) {
|
||||
Object.setPrototypeOf(entry.error, null);
|
||||
for (const name of ['message', 'name', 'code', 'quota', 'requested', 'stack', 'expando']) {
|
||||
Object.defineProperty(entry.error, name, {enumerable:true, get:poison});
|
||||
}
|
||||
}
|
||||
const value = {kind:'original', errors:cases.map(entry => entry.error), ordinary};
|
||||
value.alias = value.errors[0]; value.self = value;
|
||||
value.map = new Map([[value.errors[0], value.errors[1]]]);
|
||||
value.set = new Set([value.errors[0]]);
|
||||
const inspect = (label, copy) => {
|
||||
check(label+': fresh graph with cycles and aliases', copy !== value && copy.self === copy && copy.alias === copy.errors[0]);
|
||||
check(label+': Map and Set preserve native-object identity', copy.map.get(copy.errors[0]) === copy.errors[1] && copy.set.has(copy.errors[0]));
|
||||
check(label+': ordinary Error keeps prototype, cause and stack', Object.getPrototypeOf(copy.ordinary) === TypeError.prototype && copy.ordinary.cause === copy.errors[0] && copy.ordinary.stack === ordinaryStack);
|
||||
check(label+': exception count', copy.errors.length === cases.length);
|
||||
for (let i=0; i<cases.length; ++i) {
|
||||
const entry=cases[i], error=copy.errors[i], name=label+': '+entry.label;
|
||||
check(name+': native prototype and independent identity', Object.getPrototypeOf(error) === entry.ctor.prototype && error !== entry.error && error instanceof DOM);
|
||||
check(name+': data fields', error.name === entry.name && error.message === entry.message && error.code === entry.code);
|
||||
if (entry.ctor === Quota) check(name+': nullable quota data', Object.is(error.quota, entry.quota) && Object.is(error.requested, entry.requested));
|
||||
check(name+': no authored properties or invented stack', Object.keys(error).length === 0 && !Object.hasOwn(error,'stack') && error.expando === undefined);
|
||||
}
|
||||
};
|
||||
const dbName = 'exception-payloads-'+Date.now()+'-'+Math.random();
|
||||
let db;
|
||||
try {
|
||||
const open = global.indexedDB.open(dbName, 1);
|
||||
open.onupgradeneeded = () => open.result.createObjectStore('values').createIndex('kind','kind');
|
||||
db = await request(open);
|
||||
const tx = db.transaction('values','readwrite'), done = completion(tx), store = tx.objectStore('values');
|
||||
for (const entry of cases) {
|
||||
let error;
|
||||
try { store.put(new Proxy(entry.error, {}), 'proxy-'+entry.label); } catch (caught) { error = caught; }
|
||||
check(entry.label+': author Proxy rejected', error instanceof DOM && error.name === 'DataCloneError');
|
||||
}
|
||||
let serialized = true;
|
||||
try { store.add(value,'add'); store.put(value,'put'); } catch (error) {
|
||||
serialized = false;
|
||||
check('native exception data can be stored: '+error.name, false);
|
||||
}
|
||||
await done;
|
||||
check('native exception records accepted', serialized);
|
||||
if (serialized) {
|
||||
Object.defineProperty(global,'DOMException',{configurable:true,get:poison});
|
||||
Object.defineProperty(global,'QuotaExceededError',{configurable:true,get:poison});
|
||||
const read = db.transaction('values');
|
||||
const readDone = completion(read), values = read.objectStore('values');
|
||||
const one = request(values.get('add'));
|
||||
const many = request(values.getAll());
|
||||
const indexed = request(values.index('kind').get('original'));
|
||||
const [copy, copies, indexCopy] = await Promise.all([one,many,indexed]);
|
||||
await readDone;
|
||||
inspect('get',copy);
|
||||
check('getAll returns both records',copies.length === 2);
|
||||
for (let i=0;i<copies.length;++i) inspect('getAll['+i+']',copies[i]);
|
||||
inspect('index.get',indexCopy);
|
||||
value.kind='updated';
|
||||
const update=db.transaction('values','readwrite'), updateDone=completion(update);
|
||||
const cursor=update.objectStore('values').openCursor();
|
||||
const changed = new Promise((resolve,reject) => {
|
||||
cursor.onerror=() => reject(cursor.error);
|
||||
cursor.onsuccess=() => {
|
||||
const change=cursor.result.update(value);
|
||||
change.onsuccess=resolve; change.onerror=() => reject(change.error);
|
||||
};
|
||||
});
|
||||
await changed; await updateDone;
|
||||
db.close(); db=await request(global.indexedDB.open(dbName));
|
||||
const reopened=db.transaction('values'), reopenedDone=completion(reopened);
|
||||
const saved=await request(reopened.objectStore('values').index('kind').get('updated'));
|
||||
await reopenedDone;
|
||||
inspect('cursor.update after reopening',saved);
|
||||
}
|
||||
check('native data serialization never reads author getters',authorReads === 0);
|
||||
} catch(error) {
|
||||
check('probe completes without '+error.name+': '+error.message,false);
|
||||
} finally {
|
||||
Object.defineProperty(global,'DOMException',domDescriptor);
|
||||
Object.defineProperty(global,'QuotaExceededError',quotaDescriptor);
|
||||
if (db) db.close();
|
||||
await request(global.indexedDB.deleteDatabase(dbName));
|
||||
}
|
||||
return {rows,failures};
|
||||
}
|
||||
Reference in New Issue
Block a user