idbdatabase_createObjectStore.any.js (8677B)
1 // META: title=IDBDatabase.createObjectStore() 2 // META: global=window,worker 3 // META: script=resources/support.js 4 5 // Spec: https://w3c.github.io/IndexedDB/#dom-idbdatabase-createobjectstore 6 7 'use strict'; 8 9 async_test(t => { 10 let db; 11 let open_rq = createdb(t); 12 open_rq.onupgradeneeded = function(e) { 13 db = e.target.result; 14 let store = db.createObjectStore(''); 15 16 for (let i = 0; i < 5; i++) 17 store.add({idx: 'object_' + i}, i); 18 19 store.createIndex('', 'idx'); 20 21 store.get(4).onsuccess = t.step_func(function(e) { 22 assert_equals(e.target.result.idx, 'object_4', 'result'); 23 }); 24 assert_equals(store.indexNames[0], '', 'indexNames[0]'); 25 assert_equals(store.indexNames.length, 1, 'indexNames.length'); 26 }; 27 28 open_rq.onsuccess = function() { 29 let store = db.transaction('').objectStore(''); 30 31 assert_equals(store.indexNames[0], '', 'indexNames[0]'); 32 assert_equals(store.indexNames.length, 1, 'indexNames.length'); 33 34 store.index('').get('object_4').onsuccess = t.step_func(function(e) { 35 assert_equals(e.target.result.idx, 'object_4', 'result'); 36 t.done(); 37 }); 38 }; 39 }, 'Both with empty name'); 40 41 async_test(t => { 42 let open_rq = createdb(t); 43 44 open_rq.onupgradeneeded = function(e) { 45 let db = e.target.result; 46 let objStore = db.createObjectStore('instancetest'); 47 48 assert_true( 49 objStore instanceof IDBObjectStore, 'instanceof IDBObjectStore'); 50 }; 51 52 open_rq.onsuccess = function(e) { 53 let db = e.target.result; 54 let objStore = 55 db.transaction('instancetest', 'readonly').objectStore('instancetest'); 56 57 assert_true( 58 objStore instanceof IDBObjectStore, 'instanceof IDBObjectStore'); 59 t.done(); 60 }; 61 }, 'Returns an instance of IDBObjectStore'); 62 63 async_test(t => { 64 let db; 65 let open_rq = createdb(t); 66 67 open_rq.onupgradeneeded = function(e) { 68 db = e.target.result; 69 let store; 70 let i; 71 for (i = 0; i < 1000; i++) { 72 store = db.createObjectStore('object_store_' + i); 73 store.add('test', 1); 74 } 75 76 store.get(1).onsuccess = t.step_func(function(e) { 77 assert_equals(e.target.result, 'test'); 78 }); 79 }; 80 open_rq.onsuccess = function(e) { 81 db.close(); 82 self.indexedDB.deleteDatabase(db.name).onsuccess = function(e) { 83 t.done(); 84 } 85 }; 86 }, 'Create 1000 object stores, add one item and delete'); 87 88 async_test(t => { 89 let db; 90 let open_rq = createdb(t); 91 open_rq.onupgradeneeded = function(e) { 92 db = e.target.result; 93 let store = db.createObjectStore(''); 94 95 for (let i = 0; i < 5; i++) 96 store.add('object_' + i, i); 97 98 assert_equals(db.objectStoreNames[0], '', 'db.objectStoreNames[0]'); 99 assert_equals(db.objectStoreNames.length, 1, 'objectStoreNames.length'); 100 }; 101 102 open_rq.onsuccess = function() { 103 let store = db.transaction('').objectStore(''); 104 105 store.get(2).onsuccess = t.step_func(function(e) { 106 assert_equals(e.target.result, 'object_2'); 107 }) 108 109 assert_equals(db.objectStoreNames[0], '', 'db.objectStoreNames[0]'); 110 assert_equals(db.objectStoreNames.length, 1, 'objectStoreNames.length'); 111 112 t.done(); 113 }; 114 }, 'Empty name'); 115 116 async_test(t => { 117 let open_rq = createdb(t); 118 119 open_rq.onupgradeneeded = function(e) { 120 let db = e.target.result; 121 db.createObjectStore('store'); 122 assert_throws_dom('ConstraintError', function() { 123 db.createObjectStore('store', { 124 keyPath: 'key1', 125 }); 126 }); 127 t.done(); 128 }; 129 }, 'Attempting to create an existing object store with a different keyPath throw ConstraintError '); 130 131 async_test(t => { 132 let open_rq = createdb(t); 133 134 open_rq.onupgradeneeded = function(e) { 135 let db = e.target.result; 136 let objStore = db.createObjectStore('prop', {keyPath: 'mykeypath'}); 137 138 assert_equals(objStore.name, 'prop', 'object store name'); 139 assert_equals(objStore.keyPath, 'mykeypath', 'key path'); 140 assert_equals(objStore.autoIncrement, false, 'auto increment'); 141 }; 142 143 open_rq.onsuccess = function(e) { 144 let db = e.target.result; 145 let objStore = db.transaction('prop', 'readonly').objectStore('prop'); 146 147 assert_equals(objStore.name, 'prop', 'object store name'); 148 assert_equals(objStore.keyPath, 'mykeypath', 'key path'); 149 assert_equals(objStore.autoIncrement, false, 'auto increment'); 150 t.done(); 151 }; 152 }, 'Object store \'name\' and \'keyPath\' properties are correctly set '); 153 154 async_test(t => { 155 let open_rq = createdb(t); 156 open_rq.onupgradeneeded = function() {}; 157 open_rq.onsuccess = function(e) { 158 let db = e.target.result; 159 assert_throws_dom('InvalidStateError', function() { 160 db.createObjectStore('fails') 161 }); 162 t.done(); 163 }; 164 }, 'Attempt to create an object store outside of a version change transaction '); 165 166 async_test(t => { 167 let open_rq = createdb(t); 168 169 open_rq.onupgradeneeded = function(e) { 170 let db = e.target.result; 171 db.createObjectStore('dupe'); 172 assert_throws_dom('ConstraintError', function() { 173 db.createObjectStore('dupe'); 174 }); 175 176 // Bonus test creating a new objectstore after the exception 177 db.createObjectStore('dupe '); 178 t.done(); 179 }; 180 }, 'Attempt to create an object store that already exists '); 181 182 async_test(t => { 183 let open_rq = createdb(t); 184 185 open_rq.onupgradeneeded = function(e) { 186 let db = e.target.result; 187 188 db.createObjectStore('My cool object store name'); 189 assert_true( 190 db.objectStoreNames.contains('My cool object store name'), 191 'objectStoreNames.contains'); 192 }; 193 194 open_rq.onsuccess = function(e) { 195 let db = e.target.result; 196 197 assert_true( 198 db.objectStoreNames.contains('My cool object store name'), 199 'objectStoreNames.contains (in success)'); 200 t.done(); 201 }; 202 }, 'Object store\'s name appears in database\'s list '); 203 204 async_test(t => { 205 let open_rq = createdb(t); 206 207 open_rq.onupgradeneeded = function(e) { 208 let db = e.target.result; 209 210 assert_throws_dom('SyntaxError', function() { 211 db.createObjectStore('invalidkeypath', {keyPath: 'Invalid Keypath'}) 212 }); 213 214 assert_throws_dom('SyntaxError', function() { 215 db.createObjectStore( 216 'invalidkeypath', {autoIncrement: true, keyPath: 'Invalid Keypath'}) 217 }); 218 219 t.done(); 220 }; 221 }, 'Attempt to create an object store with an invalid key path '); 222 223 async_test(t => { 224 let open_rq = createdb(t); 225 226 open_rq.onupgradeneeded = function(e) { 227 let db = e.target.result; 228 db.createObjectStore('with unknown param', {parameter: 0}); 229 230 t.done(); 231 }; 232 }, 'Create an object store with an unknown optional parameter '); 233 234 function optionalParameters(desc, params, t) { 235 promise_test(t => { 236 return new Promise((resolve, reject) => { 237 const request = createdb(t); 238 request.onupgradeneeded = t.step_func(function(e) { 239 e.target.result.createObjectStore('store', params); 240 resolve(); 241 }); 242 }); 243 }, desc); 244 } 245 246 optionalParameters('autoInc true', {autoIncrement: true}); 247 248 optionalParameters( 249 'autoInc true, keyPath null', {autoIncrement: true, keyPath: null}); 250 251 optionalParameters( 252 'autoInc true, keyPath undefined', 253 {autoIncrement: true, keyPath: undefined}); 254 255 optionalParameters( 256 'autoInc true, keyPath string', {autoIncrement: true, keyPath: 'a'}); 257 258 optionalParameters( 259 'autoInc false, keyPath empty', {autoIncrement: false, keyPath: ''}); 260 261 optionalParameters( 262 'autoInc false, keyPath array', 263 {autoIncrement: false, keyPath: ['h', 'j']}); 264 265 optionalParameters( 266 'autoInc false, keyPath string', {autoIncrement: false, keyPath: 'abc'}); 267 268 optionalParameters('keyPath empty', {keyPath: ''}); 269 270 optionalParameters('keyPath array', {keyPath: ['a', 'b']}); 271 272 optionalParameters('keyPath string', {keyPath: 'abc'}); 273 274 optionalParameters('keyPath null', {keyPath: null}); 275 276 optionalParameters('keyPath undefined', {keyPath: undefined}); 277 278 function invalid_optionalParameters( 279 desc, params, exception = 'InvalidAccessError') { 280 promise_test(t => { 281 return new Promise((resolve, reject) => { 282 const request = createdb(t); 283 request.onupgradeneeded = t.step_func(function(e) { 284 assert_throws_dom(exception, function() { 285 e.target.result.createObjectStore('store', params); 286 }); 287 resolve(); 288 }); 289 }); 290 }, desc); 291 } 292 293 invalid_optionalParameters( 294 'autoInc and empty keyPath', {autoIncrement: true, keyPath: ''}); 295 296 invalid_optionalParameters( 297 'autoInc and keyPath array', {autoIncrement: true, keyPath: []}, 298 'SyntaxError'); 299 300 invalid_optionalParameters( 301 'autoInc and keyPath array 2', {autoIncrement: true, keyPath: ['hey']}); 302 303 invalid_optionalParameters( 304 'autoInc and keyPath object', 305 {autoIncrement: true, keyPath: {a: 'hey', b: 2}}, 'SyntaxError');