зеркало из https://github.com/mozilla/gecko-dev.git
273 строки
9.4 KiB
HTML
273 строки
9.4 KiB
HTML
<!doctype html>
|
|
<meta charset=utf-8>
|
|
<title>IndexedDB: Exceptions in extracting keys from values (ES bindings)</title>
|
|
<meta name="help" href="https://w3c.github.io/IndexedDB/#extract-key-from-value">
|
|
<script src="/resources/testharness.js"></script>
|
|
<script src="/resources/testharnessreport.js"></script>
|
|
<script src="support.js"></script>
|
|
<script>
|
|
|
|
indexeddb_test(
|
|
(t, db) => {
|
|
db.createObjectStore('store', {autoIncrement: true, keyPath: 'a.b.c'});
|
|
},
|
|
(t, db) => {
|
|
const tx = db.transaction('store', 'readwrite');
|
|
assert_throws({name: 'DataError'}, () => {
|
|
tx.objectStore('store').put({a: {b: "foo"}});
|
|
}, 'Put should throw if key can not be inserted at key path location.');
|
|
t.done();
|
|
},
|
|
'The last element of keypath is validated'
|
|
);
|
|
|
|
function throws(name) {
|
|
return () => {
|
|
const err = Error();
|
|
err.name = name;
|
|
throw err;
|
|
};
|
|
}
|
|
|
|
indexeddb_test(
|
|
function(t, db) {
|
|
const o = {};
|
|
Object.defineProperty(o, 'throws', {get: throws('getter'),
|
|
enumerable: false, configurable: true});
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no such property, so key path evaluation
|
|
// will fail.
|
|
const s1 = db.createObjectStore('s1', {keyPath: 'throws'});
|
|
assert_throws('DataError', () => {
|
|
s1.put(o);
|
|
}, 'Key path failing to resolve should throw');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no such property, so key path evaluation
|
|
// will fail.
|
|
const s2 = db.createObjectStore('s2', {keyPath: 'throws.x'});
|
|
assert_throws('DataError', () => {
|
|
s2.put(o);
|
|
}, 'Key path failing to resolve should throw');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no such property, so generated key can be
|
|
// inserted.
|
|
const s3 = db.createObjectStore('s3',
|
|
{keyPath: 'throws', autoIncrement: true});
|
|
assert_class_string(s3.put(o), 'IDBRequest',
|
|
'Key injectability test at throwing getter should succeed');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no such property, so intermediate object
|
|
// and generated key can be inserted.
|
|
const s4 = db.createObjectStore('s4',
|
|
{keyPath: 'throws.x', autoIncrement: true});
|
|
assert_class_string(s4.put(o), 'IDBRequest',
|
|
'Key injectability test past throwing getter should succeed');
|
|
},
|
|
(t, db) => {
|
|
t.done();
|
|
},
|
|
'Key path evaluation: Exceptions from non-enumerable getters'
|
|
);
|
|
|
|
indexeddb_test(
|
|
function(t, db) {
|
|
const o = {};
|
|
Object.defineProperty(o, 'throws', {get: throws('getter'),
|
|
enumerable: true, configurable: true});
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and enumerable getter will rethrow.
|
|
const s1 = db.createObjectStore('s1', {keyPath: 'throws'});
|
|
assert_throws({name: 'getter'}, () => {
|
|
s1.put(o);
|
|
}, 'Key path resolving to throwing getter rethrows');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and enumerable getter will rethrow.
|
|
const s2 = db.createObjectStore('s2', {keyPath: 'throws.x'});
|
|
assert_throws({name: 'getter'}, () => {
|
|
s2.put(o);
|
|
}, 'Key path resolving past throwing getter rethrows');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and enumerable getter will rethrow.
|
|
const s3 = db.createObjectStore('s3',
|
|
{keyPath: 'throws', autoIncrement: true});
|
|
assert_throws({name: 'getter'}, () => {
|
|
s3.put(o);
|
|
}, 'Key injectability test at throwing getter should rethrow');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and enumerable getter will rethrow.
|
|
const s4 = db.createObjectStore('s4',
|
|
{keyPath: 'throws.x', autoIncrement: true});
|
|
assert_throws({name: 'getter'}, () => {
|
|
s4.put(o);
|
|
}, 'Key injectability test past throwing getter should rethrow');
|
|
},
|
|
(t, db) => {
|
|
t.done();
|
|
},
|
|
'Key path evaluation: Exceptions from enumerable getters'
|
|
);
|
|
|
|
indexeddb_test(
|
|
(t, db) => {
|
|
// Implemented as function wrapper to clean up
|
|
// immediately after use, otherwise it may
|
|
// interfere with the test harness.
|
|
function with_proto_getter(f) {
|
|
return function() {
|
|
Object.defineProperty(Object.prototype, 'throws', {
|
|
get: throws('getter'),
|
|
enumerable: false, configurable: true
|
|
});
|
|
try {
|
|
f();
|
|
} finally {
|
|
delete Object.prototype['throws'];
|
|
}
|
|
};
|
|
}
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no own property, so key path evaluation will
|
|
// fail and DataError should be thrown.
|
|
const s1 = db.createObjectStore('s1', {keyPath: 'throws'});
|
|
assert_throws('DataError', with_proto_getter(function() {
|
|
s1.put({});
|
|
}), 'Key path resolving to no own property throws DataError');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no own property, so key path evaluation will
|
|
// fail and DataError should be thrown.
|
|
const s2 = db.createObjectStore('s2', {keyPath: 'throws.x'});
|
|
assert_throws('DataError', with_proto_getter(function() {
|
|
s2.put({});
|
|
}), 'Key path resolving past no own property throws DataError');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no own property, so key path evaluation will
|
|
// fail and injection can succeed.
|
|
const s3 = db.createObjectStore('s3',
|
|
{keyPath: 'throws', autoIncrement: true});
|
|
assert_equals(s3.put({}).readyState, 'pending',
|
|
'put should not throw due to inherited property');
|
|
|
|
// Value should be cloned before key path is evaluated,
|
|
// and non-enumerable getter will be ignored. The clone
|
|
// will have no own property, so key path evaluation will
|
|
// fail and injection can succeed.
|
|
const s4 = db.createObjectStore('s4',
|
|
{keyPath: 'throws.x', autoIncrement: true});
|
|
assert_equals(s4.put({}).readyState, 'pending',
|
|
'put should not throw due to inherited property');
|
|
},
|
|
(t, db) => {
|
|
t.done();
|
|
},
|
|
'Key path evaluation: Exceptions from non-enumerable getters on prototype'
|
|
);
|
|
|
|
indexeddb_test(
|
|
(t, db) => {
|
|
// Implemented as function wrapper to clean up
|
|
// immediately after use, otherwise it may
|
|
// interfere with the test harness.
|
|
function with_proto_getter(f) {
|
|
return () => {
|
|
Object.defineProperty(Object.prototype, 'throws', {
|
|
get: throws('getter'),
|
|
enumerable: true, configurable: true
|
|
});
|
|
try {
|
|
f();
|
|
} finally {
|
|
delete Object.prototype['throws'];
|
|
}
|
|
};
|
|
}
|
|
|
|
// Value should be cloned before key path is evaluated.
|
|
// The clone will have no own property, so key path
|
|
// evaluation will fail and DataError should be thrown.
|
|
const s1 = db.createObjectStore('s1', {keyPath: 'throws'});
|
|
assert_throws('DataError', with_proto_getter(function() {
|
|
s1.put({});
|
|
}), 'Key path resolving to no own property throws DataError');
|
|
|
|
// Value should be cloned before key path is evaluated.
|
|
// The clone will have no own property, so key path
|
|
// evaluation will fail and DataError should be thrown.
|
|
const s2 = db.createObjectStore('s2', {keyPath: 'throws.x'});
|
|
assert_throws('DataError', with_proto_getter(function() {
|
|
s2.put({});
|
|
}), 'Key path resolving past throwing getter rethrows');
|
|
|
|
// Value should be cloned before key path is evaluated.
|
|
// The clone will have no own property, so key path
|
|
// evaluation will fail and injection can succeed.
|
|
var s3 = db.createObjectStore('s3',
|
|
{keyPath: 'throws', autoIncrement: true});
|
|
assert_equals(s3.put({}).readyState, 'pending',
|
|
'put should not throw due to inherited property');
|
|
|
|
// Value should be cloned before key path is evaluated.
|
|
// The clone will have no own property, so key path
|
|
// evaluation will fail and injection can succeed.
|
|
var s4 = db.createObjectStore('s4',
|
|
{keyPath: 'throws.x', autoIncrement: true});
|
|
assert_equals(s4.put({}).readyState, 'pending',
|
|
'put should not throw due to inherited property');
|
|
},
|
|
(t, db) => {
|
|
t.done();
|
|
},
|
|
'Key path evaluation: Exceptions from enumerable getters on prototype'
|
|
);
|
|
|
|
indexeddb_test(
|
|
(t, db) => {
|
|
const store = db.createObjectStore('store');
|
|
store.createIndex('index', 'index0');
|
|
},
|
|
(t, db) => {
|
|
const tx = db.transaction('store', 'readwrite');
|
|
|
|
const array = [];
|
|
array[99] = 1;
|
|
|
|
let getter_called = 0;
|
|
const prop = '50';
|
|
Object.defineProperty(Object.prototype, prop, {
|
|
enumerable: true, configurable: true,
|
|
get: () => {
|
|
++getter_called;
|
|
return 'foo';
|
|
},
|
|
});
|
|
|
|
const request = tx.objectStore('store').put({index0: array}, 'key');
|
|
request.onerror = t.unreached_func('put should not fail');
|
|
request.onsuccess = t.step_func(function() {
|
|
assert_equals(getter_called, 0, 'Prototype getter should not be called');
|
|
delete Object.prototype[prop];
|
|
t.done();
|
|
});
|
|
},
|
|
'Array key conversion should not invoke prototype getters'
|
|
);
|
|
|
|
</script>
|