idbfactory_open.any.js (14105B)
1 // META: title=IDBFactory.open() 2 // META: global=window,worker 3 // META: script=resources/support.js 4 // @author Microsoft <https://www.microsoft.com> 5 // @author Odin H�rthe Omdal <mailto:odinho@opera.com> 6 7 'use strict'; 8 9 async_test(t => { 10 const open_rq = createdb(t, undefined, 9); 11 12 open_rq.onupgradeneeded = function (e) { }; 13 open_rq.onsuccess = function (e) { 14 assert_equals(e.target.source, null, "source") 15 t.done(); 16 } 17 }, "IDBFactory.open() - request has no source"); 18 19 async_test(t => { 20 let database_name = location + '-database_name'; 21 const open_rq = createdb(t, database_name, 13); 22 23 open_rq.onupgradeneeded = function (e) { }; 24 open_rq.onsuccess = function (e) { 25 let db = e.target.result; 26 assert_equals(db.name, database_name, 'db.name'); 27 assert_equals(db.version, 13, 'db.version'); 28 t.done(); 29 } 30 }, "IDBFactory.open() - database 'name' and 'version' are correctly set"); 31 32 async_test(t => { 33 const open_rq = createdb(t, undefined, 13); 34 let did_upgrade = false; 35 36 open_rq.onupgradeneeded = function () { }; 37 open_rq.onsuccess = function (e) { 38 let db = e.target.result; 39 db.close(); 40 41 let open_rq2 = indexedDB.open(db.name); 42 open_rq2.onsuccess = t.step_func(function (e) { 43 assert_equals(e.target.result.version, 13, "db.version") 44 e.target.result.close(); 45 t.done(); 46 }); 47 open_rq2.onupgradeneeded = fail(t, 'Unexpected upgradeneeded') 48 open_rq2.onerror = fail(t, 'Unexpected error') 49 } 50 }, "IDBFactory.open() - no version opens current database"); 51 52 async_test(t => { 53 const open_rq = createdb(t, self.location + '-database_name_new'); 54 open_rq.onupgradeneeded = function (e) { 55 assert_equals(e.target.result.version, 1, "db.version"); 56 }; 57 open_rq.onsuccess = function (e) { 58 assert_equals(e.target.result.version, 1, "db.version"); 59 t.done(); 60 }; 61 }, "IDBFactory.open() - new database has default version"); 62 63 async_test(t => { 64 const open_rq = createdb(t, self.location + '-database_name'); 65 66 open_rq.onupgradeneeded = function () { }; 67 open_rq.onsuccess = function (e) { 68 assert_equals(e.target.result.objectStoreNames.length, 0, "objectStoreNames.length"); 69 t.done(); 70 }; 71 }, "IDBFactory.open() - new database is empty"); 72 73 async_test(t => { 74 const open_rq = createdb(t, undefined, 13); 75 let did_upgrade = false; 76 let open_rq2; 77 78 open_rq.onupgradeneeded = function () { }; 79 open_rq.onsuccess = function (e) { 80 let db = e.target.result; 81 db.close(); 82 83 open_rq2 = indexedDB.open(db.name, 14); 84 open_rq2.onupgradeneeded = function () { }; 85 open_rq2.onsuccess = t.step_func(open_previous_db); 86 open_rq2.onerror = fail(t, 'Unexpected error') 87 } 88 89 function open_previous_db(e) { 90 let open_rq3 = indexedDB.open(e.target.result.name, 13); 91 open_rq3.onerror = t.step_func(function (e) { 92 assert_equals(e.target.error.name, 'VersionError', 'e.target.error.name') 93 open_rq2.result.close(); 94 t.done(); 95 }); 96 open_rq3.onupgradeneeded = fail(t, 'Unexpected upgradeneeded') 97 open_rq3.onsuccess = fail(t, 'Unexpected success') 98 } 99 }, "IDBFactory.open() - open database with a lower version than current"); 100 101 async_test(t => { 102 const open_rq = createdb(t, undefined, 13); 103 let did_upgrade = false; 104 let open_rq2; 105 106 open_rq.onupgradeneeded = function () { }; 107 open_rq.onsuccess = function (e) { 108 let db = e.target.result; 109 db.close(); 110 111 open_rq2 = indexedDB.open(db.name, 14); 112 open_rq2.onupgradeneeded = function () { 113 did_upgrade = true; 114 }; 115 open_rq2.onsuccess = t.step_func(open_current_db); 116 open_rq2.onerror = fail(t, 'Unexpected error') 117 } 118 119 function open_current_db(e) { 120 let open_rq3 = indexedDB.open(e.target.result.name); 121 open_rq3.onsuccess = t.step_func(function (e) { 122 assert_equals(e.target.result.version, 14, "db.version") 123 open_rq2.result.close(); 124 open_rq3.result.close(); 125 t.done(); 126 }); 127 open_rq3.onupgradeneeded = fail(t, 'Unexpected upgradeneeded') 128 open_rq3.onerror = fail(t, 'Unexpected error') 129 130 assert_true(did_upgrade, 'did upgrade'); 131 } 132 }, "IDBFactory.open() - open database with a higher version than current"); 133 134 async_test(t => { 135 const open_rq = createdb(t, undefined, 13); 136 let did_upgrade = false; 137 let did_db_abort = false; 138 139 open_rq.onupgradeneeded = function (e) { 140 did_upgrade = true; 141 e.target.result.onabort = function () { 142 did_db_abort = true; 143 } 144 e.target.transaction.abort(); 145 }; 146 open_rq.onerror = function (e) { 147 assert_true(did_upgrade); 148 assert_equals(e.target.error.name, 'AbortError', 'target.error'); 149 t.done() 150 }; 151 }, "IDBFactory.open() - error in version change transaction aborts open"); 152 153 function should_throw(val, name) { 154 if (!name) { 155 name = ((typeof val == "object" && val) ? "object" : format_value(val)) 156 } 157 test(function () { 158 assert_throws_js(TypeError, function () { 159 indexedDB.open('test', val); 160 }); 161 }, "Calling open() with version argument " + name + " should throw TypeError.") 162 } 163 164 should_throw(-1) 165 should_throw(-0.5) 166 should_throw(0) 167 should_throw(0.5) 168 should_throw(0.8) 169 should_throw(0x20000000000000) // Number.MAX_SAFE_INTEGER + 1 170 should_throw(NaN) 171 should_throw(Infinity) 172 should_throw(-Infinity) 173 should_throw("foo") 174 should_throw(null) 175 should_throw(false) 176 177 should_throw({ 178 toString: function () { assert_unreached("toString should not be called for ToPrimitive [Number]"); }, 179 valueOf: function () { return 0; } 180 }) 181 should_throw({ 182 toString: function () { return 0; }, 183 valueOf: function () { return {}; } 184 }, 'object (second)') 185 should_throw({ 186 toString: function () { return {}; }, 187 valueOf: function () { return {}; }, 188 }, 'object (third)') 189 190 191 /* Valid */ 192 193 function should_work(val, expected_version) { 194 let name = format_value(val); 195 let dbname = 'test-db-does-not-exist'; 196 async_test(function (t) { 197 indexedDB.deleteDatabase(dbname); 198 let rq = indexedDB.open(dbname, val); 199 rq.onupgradeneeded = t.step_func(function () { 200 let db = rq.result; 201 assert_equals(db.version, expected_version, 'version'); 202 rq.transaction.abort(); 203 }); 204 rq.onsuccess = t.unreached_func("open should fail"); 205 rq.onerror = t.step_func(function () { 206 t.done() 207 }); 208 }, "Calling open() with version argument " + name + " should not throw."); 209 } 210 211 should_work(1.5, 1) 212 should_work(Number.MAX_SAFE_INTEGER, Number.MAX_SAFE_INTEGER) // 0x20000000000000 - 1 213 should_work(undefined, 1); 214 215 async_test(t => { 216 let db, db2; 217 const open_rq = createdb(t, undefined, 9); 218 219 open_rq.onupgradeneeded = function (e) { 220 db = e.target.result; 221 222 let st = db.createObjectStore("store"); 223 st.createIndex("index", "i"); 224 225 assert_equals(db.version, 9, "first db.version"); 226 assert_true(db.objectStoreNames.contains("store"), "objectStoreNames contains store"); 227 assert_true(st.indexNames.contains("index"), "indexNames contains index"); 228 229 st.add({ i: "Joshua" }, 1); 230 st.add({ i: "Jonas" }, 2); 231 }; 232 open_rq.onsuccess = function (e) { 233 db.close(); 234 let open_rq2 = indexedDB.open(db.name, 10); 235 open_rq2.onupgradeneeded = t.step_func(function (e) { 236 db2 = e.target.result; 237 238 db2.createObjectStore("store2"); 239 240 let store = open_rq2.transaction.objectStore("store") 241 store.createIndex("index2", "i"); 242 243 assert_equals(db2.version, 10, "db2.version"); 244 245 assert_true(db2.objectStoreNames.contains("store"), "second objectStoreNames contains store"); 246 assert_true(db2.objectStoreNames.contains("store2"), "second objectStoreNames contains store2"); 247 assert_true(store.indexNames.contains("index"), "second indexNames contains index"); 248 assert_true(store.indexNames.contains("index2"), "second indexNames contains index2"); 249 250 store.add({ i: "Odin" }, 3); 251 store.put({ i: "Sicking" }, 2); 252 253 open_rq2.transaction.abort(); 254 }); 255 open_rq2.onerror = t.step_func(function (e) { 256 assert_equals(db2.version, 9, "db2.version after error"); 257 assert_true(db2.objectStoreNames.contains("store"), "objectStoreNames contains store after error"); 258 assert_false(db2.objectStoreNames.contains("store2"), "objectStoreNames not contains store2 after error"); 259 260 let open_rq3 = indexedDB.open(db.name); 261 open_rq3.onsuccess = t 262 .step_func(function (e) { 263 let db3 = e.target.result; 264 265 assert_true(db3.objectStoreNames.contains("store"), "third objectStoreNames contains store"); 266 assert_false(db3.objectStoreNames.contains("store2"), "third objectStoreNames contains store2"); 267 268 let st = db3.transaction("store", "readonly").objectStore("store"); 269 270 assert_equals(db3.version, 9, "db3.version"); 271 272 assert_true(st.indexNames.contains("index"), "third indexNames contains index"); 273 assert_false(st.indexNames.contains("index2"), "third indexNames contains index2"); 274 275 st.openCursor(null, "prev").onsuccess = t.step_func(function (e) { 276 assert_equals(e.target.result.key, 2, "opencursor(prev) key"); 277 assert_equals(e.target.result.value.i, "Jonas", "opencursor(prev) value"); 278 }); 279 st.get(3).onsuccess = t.step_func(function (e) { 280 assert_equals(e.target.result, undefined, "get(3)"); 281 }); 282 283 let idx = st.index("index"); 284 idx.getKey("Jonas").onsuccess = t.step_func(function (e) { 285 assert_equals(e.target.result, 2, "getKey(Jonas)"); 286 }); 287 idx.getKey("Odin").onsuccess = t.step_func(function (e) { 288 assert_equals(e.target.result, undefined, "getKey(Odin)"); 289 }); 290 idx.getKey("Sicking").onsuccess = t.step_func(function (e) { 291 assert_equals(e.target.result, undefined, "getKey(Sicking)"); 292 293 db3.close(); 294 t.done(); 295 }); 296 }); 297 }); 298 }; 299 }, "IDBFactory.open() - error in upgradeneeded resets db"); 300 301 async_test(t => { 302 let db; 303 let count_done = 0; 304 const open_rq = createdb(t); 305 306 open_rq.onupgradeneeded = function (e) { 307 db = e.target.result; 308 309 db.createObjectStore("store"); 310 assert_true(db.objectStoreNames.contains("store"), "objectStoreNames contains store"); 311 312 let store = e.target.transaction.objectStore("store"); 313 assert_equals(store.name, "store", "store.name"); 314 315 store.add("data", 1); 316 317 store.count().onsuccess = t.step_func(function (e) { 318 assert_equals(e.target.result, 1, "count()"); 319 count_done++; 320 }); 321 322 store.add("data2", 2); 323 }; 324 open_rq.onsuccess = function (e) { 325 let store = db.transaction("store", "readonly").objectStore("store"); 326 assert_equals(store.name, "store", "store.name"); 327 store.count().onsuccess = t.step_func(function (e) { 328 assert_equals(e.target.result, 2, "count()"); 329 count_done++; 330 }); 331 db.close(); 332 333 let open_rq2 = indexedDB.open(db.name, 10); 334 open_rq2.onupgradeneeded = t.step_func(function (e) { 335 let db2 = e.target.result; 336 assert_true(db2.objectStoreNames.contains("store"), "objectStoreNames contains store"); 337 let store = open_rq2.transaction.objectStore("store"); 338 assert_equals(store.name, "store", "store.name"); 339 340 store.add("data3", 3); 341 342 store.count().onsuccess = t.step_func(function (e) { 343 assert_equals(e.target.result, 3, "count()"); 344 count_done++; 345 346 assert_equals(count_done, 3, "count_done"); 347 348 db2.close(); 349 t.done(); 350 }); 351 }); 352 }; 353 }, "IDBFactory.open() - second open's transaction is available to get objectStores"); 354 355 async_test(t => { 356 let db; 357 let open_rq = createdb(t, undefined, 9); 358 let open2_t = t; 359 360 open_rq.onupgradeneeded = function (e) { 361 db = e.target.result; 362 363 assert_true(e instanceof IDBVersionChangeEvent, "e instanceof IDBVersionChangeEvent"); 364 assert_equals(e.oldVersion, 0, "oldVersion"); 365 assert_equals(e.newVersion, 9, "newVersion"); 366 assert_equals(e.type, "upgradeneeded", "event type"); 367 368 assert_equals(db.version, 9, "db.version"); 369 }; 370 open_rq.onsuccess = function (e) { 371 assert_true(e instanceof Event, "e instanceof Event"); 372 assert_false(e instanceof IDBVersionChangeEvent, "e not instanceof IDBVersionChangeEvent"); 373 assert_equals(e.type, "success", "event type"); 374 t.done(); 375 376 377 /** 378 * Second test 379 */ 380 db.onversionchange = function () { db.close(); }; 381 382 let open_rq2 = createdb(open2_t, db.name, 10); 383 open_rq2.onupgradeneeded = function (e) { 384 let db2 = e.target.result; 385 assert_true(e instanceof IDBVersionChangeEvent, "e instanceof IDBVersionChangeEvent"); 386 assert_equals(e.oldVersion, 9, "oldVersion"); 387 assert_equals(e.newVersion, 10, "newVersion"); 388 assert_equals(e.type, "upgradeneeded", "event type"); 389 390 assert_equals(db2.version, 10, "new db.version"); 391 392 t.done(); 393 }; 394 }; 395 }, "IDBFactory.open() - upgradeneeded gets VersionChangeEvent");