mozilla-central/testing/web-platform/tests/IndexedDB/idbdatabase_createObjectStore.any.js (file symbol)

Source code

Revision control

Copy as Markdown

Other Tools

Test Info:

// META: title=IDBDatabase.createObjectStore()
// META: global=window,worker
// META: script=resources/support.js
'use strict';
async_test(t => {
let db;
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
let store = db.createObjectStore('');
for (let i = 0; i < 5; i++)
store.add({idx: 'object_' + i}, i);
store.createIndex('', 'idx');
store.get(4).onsuccess = t.step_func(function(e) {
assert_equals(e.target.result.idx, 'object_4', 'result');
});
assert_equals(store.indexNames[0], '', 'indexNames[0]');
assert_equals(store.indexNames.length, 1, 'indexNames.length');
};
open_rq.onsuccess = function() {
let store = db.transaction('').objectStore('');
assert_equals(store.indexNames[0], '', 'indexNames[0]');
assert_equals(store.indexNames.length, 1, 'indexNames.length');
store.index('').get('object_4').onsuccess = t.step_func(function(e) {
assert_equals(e.target.result.idx, 'object_4', 'result');
t.done();
});
};
}, 'Both with empty name');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
let objStore = db.createObjectStore('instancetest');
assert_true(
objStore instanceof IDBObjectStore, 'instanceof IDBObjectStore');
};
open_rq.onsuccess = function(e) {
let db = e.target.result;
let objStore =
db.transaction('instancetest', 'readonly').objectStore('instancetest');
assert_true(
objStore instanceof IDBObjectStore, 'instanceof IDBObjectStore');
t.done();
};
}, 'Returns an instance of IDBObjectStore');
async_test(t => {
let db;
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
let store;
let i;
for (i = 0; i < 1000; i++) {
store = db.createObjectStore('object_store_' + i);
store.add('test', 1);
}
store.get(1).onsuccess = t.step_func(function(e) {
assert_equals(e.target.result, 'test');
});
};
open_rq.onsuccess = function(e) {
db.close();
self.indexedDB.deleteDatabase(db.name).onsuccess = function(e) {
t.done();
}
};
}, 'Create 1000 object stores, add one item and delete');
async_test(t => {
let db;
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
db = e.target.result;
let store = db.createObjectStore('');
for (let i = 0; i < 5; i++)
store.add('object_' + i, i);
assert_equals(db.objectStoreNames[0], '', 'db.objectStoreNames[0]');
assert_equals(db.objectStoreNames.length, 1, 'objectStoreNames.length');
};
open_rq.onsuccess = function() {
let store = db.transaction('').objectStore('');
store.get(2).onsuccess = t.step_func(function(e) {
assert_equals(e.target.result, 'object_2');
})
assert_equals(db.objectStoreNames[0], '', 'db.objectStoreNames[0]');
assert_equals(db.objectStoreNames.length, 1, 'objectStoreNames.length');
t.done();
};
}, 'Empty name');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
db.createObjectStore('store');
assert_throws_dom('ConstraintError', function() {
db.createObjectStore('store', {
keyPath: 'key1',
});
});
t.done();
};
}, 'Attempting to create an existing object store with a different keyPath throw ConstraintError ');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
let objStore = db.createObjectStore('prop', {keyPath: 'mykeypath'});
assert_equals(objStore.name, 'prop', 'object store name');
assert_equals(objStore.keyPath, 'mykeypath', 'key path');
assert_equals(objStore.autoIncrement, false, 'auto increment');
};
open_rq.onsuccess = function(e) {
let db = e.target.result;
let objStore = db.transaction('prop', 'readonly').objectStore('prop');
assert_equals(objStore.name, 'prop', 'object store name');
assert_equals(objStore.keyPath, 'mykeypath', 'key path');
assert_equals(objStore.autoIncrement, false, 'auto increment');
t.done();
};
}, 'Object store \'name\' and \'keyPath\' properties are correctly set ');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function() {};
open_rq.onsuccess = function(e) {
let db = e.target.result;
assert_throws_dom('InvalidStateError', function() {
db.createObjectStore('fails')
});
t.done();
};
}, 'Attempt to create an object store outside of a version change transaction ');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
db.createObjectStore('dupe');
assert_throws_dom('ConstraintError', function() {
db.createObjectStore('dupe');
});
// Bonus test creating a new objectstore after the exception
db.createObjectStore('dupe ');
t.done();
};
}, 'Attempt to create an object store that already exists ');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
db.createObjectStore('My cool object store name');
assert_true(
db.objectStoreNames.contains('My cool object store name'),
'objectStoreNames.contains');
};
open_rq.onsuccess = function(e) {
let db = e.target.result;
assert_true(
db.objectStoreNames.contains('My cool object store name'),
'objectStoreNames.contains (in success)');
t.done();
};
}, 'Object store\'s name appears in database\'s list ');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
assert_throws_dom('SyntaxError', function() {
db.createObjectStore('invalidkeypath', {keyPath: 'Invalid Keypath'})
});
assert_throws_dom('SyntaxError', function() {
db.createObjectStore(
'invalidkeypath', {autoIncrement: true, keyPath: 'Invalid Keypath'})
});
t.done();
};
}, 'Attempt to create an object store with an invalid key path ');
async_test(t => {
let open_rq = createdb(t);
open_rq.onupgradeneeded = function(e) {
let db = e.target.result;
db.createObjectStore('with unknown param', {parameter: 0});
t.done();
};
}, 'Create an object store with an unknown optional parameter ');
function optionalParameters(desc, params, t) {
promise_test(t => {
return new Promise((resolve, reject) => {
const request = createdb(t);
request.onupgradeneeded = t.step_func(function(e) {
e.target.result.createObjectStore('store', params);
resolve();
});
});
}, desc);
}
optionalParameters('autoInc true', {autoIncrement: true});
optionalParameters(
'autoInc true, keyPath null', {autoIncrement: true, keyPath: null});
optionalParameters(
'autoInc true, keyPath undefined',
{autoIncrement: true, keyPath: undefined});
optionalParameters(
'autoInc true, keyPath string', {autoIncrement: true, keyPath: 'a'});
optionalParameters(
'autoInc false, keyPath empty', {autoIncrement: false, keyPath: ''});
optionalParameters(
'autoInc false, keyPath array',
{autoIncrement: false, keyPath: ['h', 'j']});
optionalParameters(
'autoInc false, keyPath string', {autoIncrement: false, keyPath: 'abc'});
optionalParameters('keyPath empty', {keyPath: ''});
optionalParameters('keyPath array', {keyPath: ['a', 'b']});
optionalParameters('keyPath string', {keyPath: 'abc'});
optionalParameters('keyPath null', {keyPath: null});
optionalParameters('keyPath undefined', {keyPath: undefined});
function invalid_optionalParameters(
desc, params, exception = 'InvalidAccessError') {
promise_test(t => {
return new Promise((resolve, reject) => {
const request = createdb(t);
request.onupgradeneeded = t.step_func(function(e) {
assert_throws_dom(exception, function() {
e.target.result.createObjectStore('store', params);
});
resolve();
});
});
}, desc);
}
invalid_optionalParameters(
'autoInc and empty keyPath', {autoIncrement: true, keyPath: ''});
invalid_optionalParameters(
'autoInc and keyPath array', {autoIncrement: true, keyPath: []},
'SyntaxError');
invalid_optionalParameters(
'autoInc and keyPath array 2', {autoIncrement: true, keyPath: ['hey']});
invalid_optionalParameters(
'autoInc and keyPath object',
{autoIncrement: true, keyPath: {a: 'hey', b: 2}}, 'SyntaxError');