mirror of
https://github.com/localForage/localForage.git
synced 2026-01-25 14:44:26 +00:00
1547 lines
57 KiB
JavaScript
1547 lines
57 KiB
JavaScript
/* global after:true, afterEach:true, before:true, beforeEach:true, describe:true, expect:true, it:true, Promise:true */
|
|
var DRIVERS = [
|
|
localforage.INDEXEDDB,
|
|
localforage.LOCALSTORAGE,
|
|
localforage.WEBSQL
|
|
];
|
|
|
|
var SUPPORTED_DRIVERS = DRIVERS.filter(function(driverName) {
|
|
return localforage.supports(driverName);
|
|
});
|
|
|
|
var driverApiMethods = [
|
|
'getItem',
|
|
'setItem',
|
|
'clear',
|
|
'length',
|
|
'removeItem',
|
|
'key',
|
|
'keys'
|
|
];
|
|
|
|
var indexedDB = (indexedDB || window.indexedDB ||
|
|
window.webkitIndexedDB ||
|
|
window.mozIndexedDB || window.OIndexedDB ||
|
|
window.msIndexedDB);
|
|
|
|
describe('localForage API', function() {
|
|
// https://github.com/mozilla/localForage#working-on-localforage
|
|
it('has Promises available', function() {
|
|
expect(Promise).to.be.a('function');
|
|
});
|
|
});
|
|
|
|
describe('localForage', function() {
|
|
var appropriateDriver =
|
|
(localforage.supports(localforage.INDEXEDDB) &&
|
|
localforage.INDEXEDDB) ||
|
|
(localforage.supports(localforage.WEBSQL) &&
|
|
localforage.WEBSQL) ||
|
|
(localforage.supports(localforage.LOCALSTORAGE) &&
|
|
localforage.LOCALSTORAGE);
|
|
|
|
it('automatically selects the most appropriate driver (' +
|
|
appropriateDriver + ')', function(done) {
|
|
this.timeout(10000);
|
|
localforage.ready().then(function() {
|
|
expect(localforage.driver()).to.be(appropriateDriver);
|
|
done();
|
|
}, function(error) {
|
|
expect(error).to.be.an(Error);
|
|
expect(error.message).to
|
|
.be('No available storage method found.');
|
|
expect(localforage.driver()).to.be(null);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('errors when a requested driver is not found [callback]', function(done) {
|
|
localforage.getDriver('UnknownDriver', null, function(error) {
|
|
expect(error).to.be.an(Error);
|
|
expect(error.message).to
|
|
.be('Driver not found.');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('errors when a requested driver is not found [promise]', function(done) {
|
|
localforage.getDriver('UnknownDriver').then(null, function(error) {
|
|
expect(error).to.be.an(Error);
|
|
expect(error.message).to
|
|
.be('Driver not found.');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('retrieves the serializer [callback]', function(done) {
|
|
localforage.getSerializer(function(serializer) {
|
|
expect(serializer).to.be.an('object');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('retrieves the serializer [promise]', function(done) {
|
|
var serializerPromise = localforage.getSerializer();
|
|
expect(serializerPromise).to.be.an('object');
|
|
expect(serializerPromise.then).to.be.a('function');
|
|
|
|
serializerPromise.then(function(serializer) {
|
|
expect(serializer).to.be.an('object');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('does not support object parameter to setDriver', function(done) {
|
|
var driverPreferedOrder = {
|
|
'0': localforage.INDEXEDDB,
|
|
'1': localforage.WEBSQL,
|
|
'2': localforage.LOCALSTORAGE,
|
|
length: 3
|
|
};
|
|
|
|
localforage.setDriver(driverPreferedOrder).then(null, function(error) {
|
|
expect(error).to.be.an(Error);
|
|
expect(error.message).to
|
|
.be('No available storage method found.');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('skips drivers that fail to initilize', function(done) {
|
|
var failingStorageDriver = (function() {
|
|
function driverDummyMethod() {
|
|
return Promise.reject(new Error('Driver Method Failed.'));
|
|
}
|
|
|
|
return {
|
|
_driver: 'failingStorageDriver',
|
|
_initStorage: function _initStorage() {
|
|
return Promise.reject(new Error('Driver Failed to Initialize.'));
|
|
},
|
|
iterate: driverDummyMethod,
|
|
getItem: driverDummyMethod,
|
|
setItem: driverDummyMethod,
|
|
removeItem: driverDummyMethod,
|
|
clear: driverDummyMethod,
|
|
length: driverDummyMethod,
|
|
key: driverDummyMethod,
|
|
keys: driverDummyMethod
|
|
};
|
|
})();
|
|
|
|
var driverPreferedOrder = [
|
|
failingStorageDriver._driver,
|
|
localforage.INDEXEDDB,
|
|
localforage.WEBSQL,
|
|
localforage.LOCALSTORAGE
|
|
];
|
|
|
|
localforage.defineDriver(failingStorageDriver).then(function() {
|
|
return localforage.setDriver(driverPreferedOrder);
|
|
}).then(function() {
|
|
return localforage.ready();
|
|
}).then(function() {
|
|
expect(localforage.driver()).to.be(appropriateDriver);
|
|
done();
|
|
});
|
|
|
|
});
|
|
});
|
|
|
|
SUPPORTED_DRIVERS.forEach(function(driverName) {
|
|
describe(driverName + ' driver', function() {
|
|
'use strict';
|
|
|
|
this.timeout(30000);
|
|
|
|
before(function(done) {
|
|
localforage.setDriver(driverName).then(done);
|
|
});
|
|
|
|
beforeEach(function(done) {
|
|
localStorage.clear();
|
|
localforage.ready().then(function() {
|
|
localforage.clear(done);
|
|
});
|
|
});
|
|
|
|
it('has a localStorage API', function() {
|
|
expect(localforage.getItem).to.be.a('function');
|
|
expect(localforage.setItem).to.be.a('function');
|
|
expect(localforage.clear).to.be.a('function');
|
|
expect(localforage.length).to.be.a('function');
|
|
expect(localforage.removeItem).to.be.a('function');
|
|
expect(localforage.key).to.be.a('function');
|
|
});
|
|
|
|
it('has the localForage API', function() {
|
|
expect(localforage._initStorage).to.be.a('function');
|
|
expect(localforage.config).to.be.a('function');
|
|
expect(localforage.defineDriver).to.be.a('function');
|
|
expect(localforage.driver).to.be.a('function');
|
|
expect(localforage.supports).to.be.a('function');
|
|
expect(localforage.iterate).to.be.a('function');
|
|
expect(localforage.getItem).to.be.a('function');
|
|
expect(localforage.setItem).to.be.a('function');
|
|
expect(localforage.clear).to.be.a('function');
|
|
expect(localforage.length).to.be.a('function');
|
|
expect(localforage.removeItem).to.be.a('function');
|
|
expect(localforage.key).to.be.a('function');
|
|
expect(localforage.getDriver).to.be.a('function');
|
|
expect(localforage.setDriver).to.be.a('function');
|
|
expect(localforage.ready).to.be.a('function');
|
|
expect(localforage.createInstance).to.be.a('function');
|
|
expect(localforage.getSerializer).to.be.a('function');
|
|
expect(localforage.dropInstance).to.be.a('function');
|
|
});
|
|
|
|
// Make sure we don't support bogus drivers.
|
|
it('supports ' + driverName + ' database driver', function() {
|
|
expect(localforage.supports(driverName) === true);
|
|
expect(localforage.supports('I am not a driver') === false);
|
|
});
|
|
|
|
it('sets the right database driver', function() {
|
|
expect(localforage.driver() === driverName);
|
|
});
|
|
|
|
it('has an empty length by default', function(done) {
|
|
localforage.length(function(err, length) {
|
|
expect(length).to.be(0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
if (driverName === localforage.INDEXEDDB) {
|
|
describe('Blob support', function() {
|
|
var transaction;
|
|
var called;
|
|
var db;
|
|
var blob = new Blob([''], {type: 'image/png'});
|
|
|
|
before(function() {
|
|
db = localforage._dbInfo.db;
|
|
transaction = db.transaction;
|
|
db.transaction = function() {
|
|
called += 1;
|
|
return transaction.apply(db, arguments);
|
|
};
|
|
});
|
|
|
|
beforeEach(function() {
|
|
called = 0;
|
|
});
|
|
|
|
it('not check for non Blob', function(done) {
|
|
localforage.setItem('key', {}).then(function() {
|
|
expect(called).to.be(1);
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
it('check for Blob', function(done) {
|
|
localforage.setItem('key', blob).then(function() {
|
|
expect(called).to.be.above(1);
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
it('check for Blob once', function(done) {
|
|
localforage.setItem('key', blob).then(function() {
|
|
expect(called).to.be(1);
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
after(function() {
|
|
localforage._dbInfo.db.transaction = transaction;
|
|
});
|
|
});
|
|
|
|
describe('recover (reconnect) from IDBDatabase InvalidStateError', function() {
|
|
|
|
beforeEach(function(done) {
|
|
Promise.all([
|
|
localforage.setItem('key', 'value1'),
|
|
localforage.setItem('key1', 'value1'),
|
|
localforage.setItem('key2', 'value2'),
|
|
localforage.setItem('key3', 'value3')
|
|
]).then(function() {
|
|
localforage._dbInfo.db.close();
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
it('retrieves an item from the storage', function(done) {
|
|
localforage.getItem('key').then(function(value) {
|
|
expect(value).to.be('value1');
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
it('retrieves more than one items from the storage', function(done) {
|
|
Promise.all([
|
|
localforage.getItem('key1'),
|
|
localforage.getItem('key2'),
|
|
localforage.getItem('key3')
|
|
]).then(function(values) {
|
|
expect(values).to.eql([
|
|
'value1',
|
|
'value2',
|
|
'value3'
|
|
]);
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
it('stores and retrieves an item from the storage', function(done) {
|
|
localforage.setItem('key', 'value1b').then(function() {
|
|
return localforage.getItem('key');
|
|
}).then(function(value) {
|
|
expect(value).to.be('value1b');
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
it('stores and retrieves more than one items from the storage', function(done) {
|
|
Promise.all([
|
|
localforage.setItem('key1', 'value1b'),
|
|
localforage.setItem('key2', 'value2b'),
|
|
localforage.setItem('key3', 'value3b')
|
|
]).then(function() {
|
|
return Promise.all([
|
|
localforage.getItem('key1'),
|
|
localforage.getItem('key2'),
|
|
localforage.getItem('key3')
|
|
]);
|
|
}).then(function(values) {
|
|
expect(values).to.eql([
|
|
'value1b',
|
|
'value2b',
|
|
'value3b'
|
|
]);
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
});
|
|
}
|
|
|
|
if (driverName === localforage.WEBSQL) {
|
|
describe('on QUOTA ERROR', function() {
|
|
var transaction;
|
|
var called;
|
|
var db;
|
|
|
|
function getQuotaErrorCode(transaction) {
|
|
return new Promise(function(resolve) {
|
|
transaction(function(t) {
|
|
t.executeSql('');
|
|
}, function(err) {
|
|
resolve(err.QUOTA_ERR);
|
|
});
|
|
}).catch(function(err) {
|
|
return err.QUOTA_ERR;
|
|
});
|
|
}
|
|
|
|
beforeEach(function() {
|
|
called = 0;
|
|
db = localforage._dbInfo.db;
|
|
transaction = db.transaction;
|
|
|
|
db.transaction = function(fn, errFn) {
|
|
called += 1;
|
|
// restore the normal transaction,
|
|
// so that subsequent operations work
|
|
db.transaction = transaction;
|
|
|
|
getQuotaErrorCode(transaction).then(function(QUOTA_ERR) {
|
|
var error = new Error();
|
|
error.code = QUOTA_ERR;
|
|
errFn(error);
|
|
});
|
|
};
|
|
});
|
|
|
|
it('should retry setItem', function(done) {
|
|
localforage.setItem('key', {}).then(function() {
|
|
expect(called).to.be(1);
|
|
done();
|
|
}, function(error) {
|
|
done(error || 'error');
|
|
});
|
|
});
|
|
|
|
after(function() {
|
|
db.transaction = transaction || db.transaction;
|
|
});
|
|
});
|
|
}
|
|
|
|
it('should iterate [callback]', function(done) {
|
|
localforage.setItem('officeX', 'InitechX', function(err, setValue) {
|
|
expect(setValue).to.be('InitechX');
|
|
|
|
localforage.getItem('officeX', function(err, value) {
|
|
expect(value).to.be(setValue);
|
|
|
|
localforage.setItem('officeY', 'InitechY',
|
|
function(err, setValue) {
|
|
expect(setValue).to.be('InitechY');
|
|
|
|
localforage.getItem('officeY', function(err, value) {
|
|
expect(value).to.be(setValue);
|
|
|
|
var accumulator = {};
|
|
var iterationNumbers = [];
|
|
|
|
localforage.iterate(function(value, key, iterationNumber) {
|
|
accumulator[key] = value;
|
|
iterationNumbers.push(iterationNumber);
|
|
}, function() {
|
|
try {
|
|
expect(accumulator.officeX).to.be('InitechX');
|
|
expect(accumulator.officeY).to.be('InitechY');
|
|
expect(iterationNumbers).to.eql([1, 2]);
|
|
done();
|
|
} catch (e) {
|
|
done(e);
|
|
}
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should iterate [promise]', function(done) {
|
|
var accumulator = {};
|
|
var iterationNumbers = [];
|
|
|
|
return localforage.setItem('officeX',
|
|
'InitechX').then(function(setValue) {
|
|
expect(setValue).to.be('InitechX');
|
|
return localforage.getItem('officeX');
|
|
}).then(function(value) {
|
|
expect(value).to.be('InitechX');
|
|
return localforage.setItem('officeY', 'InitechY');
|
|
}).then(function(setValue) {
|
|
expect(setValue).to.be('InitechY');
|
|
return localforage.getItem('officeY');
|
|
}).then(function(value) {
|
|
expect(value).to.be('InitechY');
|
|
|
|
return localforage.iterate(function(value, key,
|
|
iterationNumber) {
|
|
accumulator[key] = value;
|
|
iterationNumbers.push(iterationNumber);
|
|
});
|
|
}).then(function() {
|
|
expect(accumulator.officeX).to.be('InitechX');
|
|
expect(accumulator.officeY).to.be('InitechY');
|
|
expect(iterationNumbers).to.eql([1, 2]);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should break iteration with defined return value [callback]',
|
|
function(done) {
|
|
var breakCondition = 'Some value!';
|
|
|
|
localforage.setItem('officeX', 'InitechX', function(err, setValue) {
|
|
expect(setValue).to.be('InitechX');
|
|
|
|
localforage.getItem('officeX', function(err, value) {
|
|
expect(value).to.be(setValue);
|
|
|
|
localforage.setItem('officeY', 'InitechY',
|
|
function(err, setValue) {
|
|
expect(setValue).to.be('InitechY');
|
|
|
|
localforage.getItem('officeY', function(err, value) {
|
|
expect(value).to.be(setValue);
|
|
|
|
// Loop is broken within first iteration.
|
|
localforage.iterate(function() {
|
|
// Returning defined value will break the cycle.
|
|
return breakCondition;
|
|
}, function(err, loopResult) {
|
|
// The value that broken the cycle is returned
|
|
// as a result.
|
|
expect(loopResult).to.be(breakCondition);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
it('should break iteration with defined return value [promise]',
|
|
function(done) {
|
|
var breakCondition = 'Some value!';
|
|
|
|
localforage.setItem('officeX', 'InitechX').then(function(setValue) {
|
|
expect(setValue).to.be('InitechX');
|
|
return localforage.getItem('officeX');
|
|
}).then(function(value) {
|
|
expect(value).to.be('InitechX');
|
|
return localforage.setItem('officeY', 'InitechY');
|
|
}).then(function(setValue) {
|
|
expect(setValue).to.be('InitechY');
|
|
return localforage.getItem('officeY');
|
|
}).then(function(value) {
|
|
expect(value).to.be('InitechY');
|
|
return localforage.iterate(function() {
|
|
return breakCondition;
|
|
});
|
|
}).then(function(result) {
|
|
expect(result).to.be(breakCondition);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('should iterate() through only its own keys/values', function(done) {
|
|
localStorage.setItem('local', 'forage');
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.setItem('name', 'Bob');
|
|
}).then(function() {
|
|
// Loop through all key/value pairs; {local: 'forage'} set
|
|
// manually should not be returned.
|
|
var numberOfItems = 0;
|
|
var iterationNumberConcat = '';
|
|
|
|
localStorage.setItem('locals', 'forages');
|
|
|
|
localforage.iterate(function(value, key, iterationNumber) {
|
|
expect(key).to.not.be('local');
|
|
expect(value).to.not.be('forage');
|
|
numberOfItems++;
|
|
iterationNumberConcat += iterationNumber;
|
|
}, function(err) {
|
|
if (!err) {
|
|
// While there are 4 items in localStorage,
|
|
// only 2 items were set using localForage.
|
|
expect(numberOfItems).to.be(2);
|
|
|
|
// Only 2 items were set using localForage,
|
|
// so we should get '12' and not '1234'
|
|
expect(iterationNumberConcat).to.be('12');
|
|
|
|
done();
|
|
}
|
|
});
|
|
});
|
|
});
|
|
|
|
// Test for https://github.com/mozilla/localForage/issues/175
|
|
it('nested getItem inside clear works [callback]', function(done) {
|
|
localforage.setItem('hello', 'Hello World !', function() {
|
|
localforage.clear(function() {
|
|
localforage.getItem('hello', function(secondValue) {
|
|
expect(secondValue).to.be(null);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
it('nested getItem inside clear works [promise]', function(done) {
|
|
localforage.setItem('hello', 'Hello World !').then(function() {
|
|
return localforage.clear();
|
|
}).then(function() {
|
|
return localforage.getItem('hello');
|
|
}).then(function(secondValue) {
|
|
expect(secondValue).to.be(null);
|
|
done();
|
|
});
|
|
});
|
|
|
|
// Because localStorage doesn't support saving the `undefined` type, we
|
|
// always return `null` so that localForage is consistent across
|
|
// browsers.
|
|
// https://github.com/mozilla/localForage/pull/42
|
|
it('returns null for undefined key [callback]', function(done) {
|
|
localforage.getItem('key', function(err, value) {
|
|
expect(value).to.be(null);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns null for undefined key [promise]', function(done) {
|
|
localforage.getItem('key').then(function(value) {
|
|
expect(value).to.be(null);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('saves an item [callback]', function(done) {
|
|
localforage.setItem('office', 'Initech', function(err, setValue) {
|
|
expect(setValue).to.be('Initech');
|
|
|
|
localforage.getItem('office', function(err, value) {
|
|
expect(value).to.be(setValue);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
it('saves an item [promise]', function(done) {
|
|
localforage.setItem('office', 'Initech').then(function(setValue) {
|
|
expect(setValue).to.be('Initech');
|
|
|
|
return localforage.getItem('office');
|
|
}).then(function(value) {
|
|
expect(value).to.be('Initech');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('saves an item over an existing key [callback]', function(done) {
|
|
localforage.setItem('4th floor', 'Mozilla',
|
|
function(err, setValue) {
|
|
expect(setValue).to.be('Mozilla');
|
|
|
|
localforage.setItem('4th floor', 'Quora',
|
|
function(err, newValue) {
|
|
expect(newValue).to.not.be(setValue);
|
|
expect(newValue).to.be('Quora');
|
|
|
|
localforage.getItem('4th floor', function(err, value) {
|
|
expect(value).to.not.be(setValue);
|
|
expect(value).to.be(newValue);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
it('saves an item over an existing key [promise]', function(done) {
|
|
localforage.setItem('4e', 'Mozilla').then(function(setValue) {
|
|
expect(setValue).to.be('Mozilla');
|
|
|
|
return localforage.setItem('4e', 'Quora');
|
|
}).then(function(newValue) {
|
|
expect(newValue).to.not.be('Mozilla');
|
|
expect(newValue).to.be('Quora');
|
|
|
|
return localforage.getItem('4e');
|
|
}).then(function(value) {
|
|
expect(value).to.not.be('Mozilla');
|
|
expect(value).to.be('Quora');
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns null when saving undefined [callback]', function(done) {
|
|
localforage.setItem('undef', undefined, function(err, setValue) {
|
|
expect(setValue).to.be(null);
|
|
|
|
done();
|
|
});
|
|
});
|
|
it('returns null when saving undefined [promise]', function(done) {
|
|
localforage.setItem('undef', undefined).then(function(setValue) {
|
|
expect(setValue).to.be(null);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns null for a non-existant key [callback]', function(done) {
|
|
localforage.getItem('undef', function(err, value) {
|
|
expect(value).to.be(null);
|
|
|
|
done();
|
|
});
|
|
});
|
|
it('returns null for a non-existant key [promise]', function(done) {
|
|
localforage.getItem('undef').then(function(value) {
|
|
expect(value).to.be(null);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
// github.com/mozilla/localforage/pull/24#discussion-diff-9389662R158
|
|
// localStorage's method API (`localStorage.getItem('foo')`) returns
|
|
// `null` for undefined keys, even though its getter/setter API
|
|
// (`localStorage.foo`) returns `undefined` for the same key. Gaia's
|
|
// asyncStorage API, which is based on localStorage and upon which
|
|
// localforage is based, ALSO returns `null`. BLARG! So for now, we
|
|
// just return null, because there's no way to know from localStorage
|
|
// if the key is ACTUALLY `null` or undefined but returning `null`.
|
|
// And returning `undefined` here would break compatibility with
|
|
// localStorage fallback. Maybe in the future we won't care...
|
|
it('returns null from an undefined key [callback]', function(done) {
|
|
localforage.key(0, function(err, key) {
|
|
expect(key).to.be(null);
|
|
|
|
done();
|
|
});
|
|
});
|
|
it('returns null from an undefined key [promise]', function(done) {
|
|
localforage.key(0).then(function(key) {
|
|
expect(key).to.be(null);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns key name [callback]', function(done) {
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
localforage.key(0, function(err, key) {
|
|
expect(key).to.be('office');
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
it('returns key name [promise]', function(done) {
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.key(0);
|
|
}).then(function(key) {
|
|
expect(key).to.be('office');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('removes an item [callback]', function(done) {
|
|
localforage.setItem('office', 'Initech', function() {
|
|
localforage.setItem('otherOffice', 'Initrode', function() {
|
|
localforage.removeItem('office', function() {
|
|
localforage.getItem('office',
|
|
function(err, emptyValue) {
|
|
expect(emptyValue).to.be(null);
|
|
|
|
localforage.getItem('otherOffice',
|
|
function(err, value) {
|
|
expect(value).to.be('Initrode');
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
it('removes an item [promise]', function(done) {
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.setItem('otherOffice', 'Initrode');
|
|
}).then(function() {
|
|
return localforage.removeItem('office');
|
|
}).then(function() {
|
|
return localforage.getItem('office');
|
|
}).then(function(emptyValue) {
|
|
expect(emptyValue).to.be(null);
|
|
|
|
return localforage.getItem('otherOffice');
|
|
}).then(function(value) {
|
|
expect(value).to.be('Initrode');
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('removes all items [callback]', function(done) {
|
|
localforage.setItem('office', 'Initech', function() {
|
|
localforage.setItem('otherOffice', 'Initrode', function() {
|
|
localforage.length(function(err, length) {
|
|
expect(length).to.be(2);
|
|
|
|
localforage.clear(function() {
|
|
localforage.getItem('office', function(err, value) {
|
|
expect(value).to.be(null);
|
|
|
|
localforage.length(function(err, length) {
|
|
expect(length).to.be(0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
it('removes all items [promise]', function(done) {
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.setItem('otherOffice', 'Initrode');
|
|
}).then(function() {
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(2);
|
|
|
|
return localforage.clear();
|
|
}).then(function() {
|
|
return localforage.getItem('office');
|
|
}).then(function(value) {
|
|
expect(value).to.be(null);
|
|
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(0);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
if (driverName === localforage.LOCALSTORAGE) {
|
|
it('removes only own items upon clear', function(done) {
|
|
localStorage.setItem('local', 'forage');
|
|
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.clear();
|
|
}).then(function() {
|
|
expect(localStorage.getItem('local')).to.be('forage');
|
|
|
|
localStorage.clear();
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('returns only its own keys from keys()', function(done) {
|
|
localStorage.setItem('local', 'forage');
|
|
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.keys();
|
|
}).then(function(keys) {
|
|
expect(keys).to.eql(['office']);
|
|
|
|
localStorage.clear();
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('counts only its own items with length()', function(done) {
|
|
localStorage.setItem('local', 'forage');
|
|
localStorage.setItem('another', 'value');
|
|
|
|
localforage.setItem('office', 'Initech').then(function() {
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(1);
|
|
|
|
localStorage.clear();
|
|
|
|
done();
|
|
});
|
|
});
|
|
}
|
|
|
|
it('has a length after saving an item [callback]', function(done) {
|
|
localforage.length(function(err, length) {
|
|
expect(length).to.be(0);
|
|
localforage.setItem('rapper', 'Black Thought', function() {
|
|
localforage.length(function(err, length) {
|
|
expect(length).to.be(1);
|
|
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
it('has a length after saving an item [promise]', function(done) {
|
|
localforage.length().then(function(length) {
|
|
expect(length).to.be(0);
|
|
|
|
return localforage.setItem('lame rapper', 'Vanilla Ice');
|
|
}).then(function() {
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(1);
|
|
|
|
done();
|
|
});
|
|
});
|
|
|
|
// Deal with non-string keys, see issue #250
|
|
// https://github.com/mozilla/localForage/issues/250
|
|
it('casts an undefined key to a String', function(done) {
|
|
localforage.setItem(undefined, 'goodness!').then(function(value) {
|
|
expect(value).to.be('goodness!');
|
|
|
|
return localforage.getItem(undefined);
|
|
}).then(function(value) {
|
|
expect(value).to.be('goodness!');
|
|
|
|
return localforage.removeItem(undefined);
|
|
}).then(function() {
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('casts a null key to a String', function(done) {
|
|
localforage.setItem(null, 'goodness!').then(function(value) {
|
|
expect(value).to.be('goodness!');
|
|
|
|
return localforage.getItem(null);
|
|
}).then(function(value) {
|
|
expect(value).to.be('goodness!');
|
|
|
|
return localforage.removeItem(null);
|
|
}).then(function() {
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('casts a float key to a String', function(done) {
|
|
localforage.setItem(537.35737, 'goodness!').then(function(value) {
|
|
expect(value).to.be('goodness!');
|
|
|
|
return localforage.getItem(537.35737);
|
|
}).then(function(value) {
|
|
expect(value).to.be('goodness!');
|
|
|
|
return localforage.removeItem(537.35737);
|
|
}).then(function() {
|
|
return localforage.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(0);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('is retrieved by getDriver [callback]', function(done) {
|
|
localforage.getDriver(driverName, function(driver) {
|
|
expect(typeof driver).to.be('object');
|
|
driverApiMethods.concat('_initStorage').forEach(function(methodName) {
|
|
expect(typeof driver[methodName]).to.be('function');
|
|
});
|
|
expect(driver._driver).to.be(driverName);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('is retrieved by getDriver [promise]', function(done) {
|
|
localforage.getDriver(driverName).then(function(driver) {
|
|
expect(typeof driver).to.be('object');
|
|
driverApiMethods.concat('_initStorage').forEach(function(methodName) {
|
|
expect(typeof driver[methodName]).to.be('function');
|
|
});
|
|
expect(driver._driver).to.be(driverName);
|
|
done();
|
|
});
|
|
});
|
|
|
|
if (driverName === localforage.WEBSQL ||
|
|
driverName === localforage.LOCALSTORAGE) {
|
|
it('exposes the serializer on the dbInfo object', function(done) {
|
|
localforage.ready().then(function() {
|
|
expect(localforage._dbInfo.serializer).to.be.an('object');
|
|
done();
|
|
});
|
|
});
|
|
}
|
|
});
|
|
|
|
function prepareStorage(storageName) {
|
|
// Delete IndexedDB storages (start from scratch)
|
|
// Refers to issue #492 - https://github.com/mozilla/localForage/issues/492
|
|
if (driverName === localforage.INDEXEDDB) {
|
|
return new Promise(function(resolve) {
|
|
indexedDB.deleteDatabase(storageName).onsuccess = resolve;
|
|
});
|
|
}
|
|
|
|
// Otherwise, do nothing
|
|
return Promise.resolve();
|
|
}
|
|
|
|
describe(driverName + ' driver multiple instances', function() {
|
|
'use strict';
|
|
|
|
this.timeout(30000);
|
|
|
|
var localforage2 = null;
|
|
var localforage3 = null;
|
|
|
|
before(function(done) {
|
|
|
|
prepareStorage('storage2').then(function() {
|
|
localforage2 = localforage.createInstance({
|
|
name: 'storage2',
|
|
// We need a small value here
|
|
// otherwise local PhantomJS test
|
|
// will fail with SECURITY_ERR.
|
|
// TravisCI seem to work fine though.
|
|
size: 1024,
|
|
storeName: 'storagename2'
|
|
});
|
|
|
|
// Same name, but different storeName since this has been
|
|
// malfunctioning before w/ IndexedDB.
|
|
localforage3 = localforage.createInstance({
|
|
name: 'storage2',
|
|
// We need a small value here
|
|
// otherwise local PhantomJS test
|
|
// will fail with SECURITY_ERR.
|
|
// TravisCI seem to work fine though.
|
|
size: 1024,
|
|
storeName: 'storagename3'
|
|
});
|
|
|
|
Promise.all([
|
|
localforage.setDriver(driverName),
|
|
localforage2.setDriver(driverName),
|
|
localforage3.setDriver(driverName)
|
|
]).then(function() {
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
beforeEach(function(done) {
|
|
Promise.all([
|
|
localforage.clear(),
|
|
localforage2.clear(),
|
|
localforage3.clear()
|
|
]).then(function() {
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('is not be able to access values of other instances', function(done) {
|
|
Promise.all([
|
|
localforage.setItem('key1', 'value1a'),
|
|
localforage2.setItem('key2', 'value2a'),
|
|
localforage3.setItem('key3', 'value3a')
|
|
]).then(function() {
|
|
return Promise.all([
|
|
localforage.getItem('key2').then(function(value) {
|
|
expect(value).to.be(null);
|
|
}),
|
|
localforage2.getItem('key1').then(function(value) {
|
|
expect(value).to.be(null);
|
|
}),
|
|
localforage2.getItem('key3').then(function(value) {
|
|
expect(value).to.be(null);
|
|
}),
|
|
localforage3.getItem('key2').then(function(value) {
|
|
expect(value).to.be(null);
|
|
})
|
|
]);
|
|
}).then(function() {
|
|
done();
|
|
}, function(errors) {
|
|
done(new Error(errors));
|
|
});
|
|
});
|
|
|
|
it('retrieves the proper value when using the same key with other instances', function(done) {
|
|
Promise.all([
|
|
localforage.setItem('key', 'value1'),
|
|
localforage2.setItem('key', 'value2'),
|
|
localforage3.setItem('key', 'value3')
|
|
]).then(function() {
|
|
return Promise.all([
|
|
localforage.getItem('key').then(function(value) {
|
|
expect(value).to.be('value1');
|
|
}),
|
|
localforage2.getItem('key').then(function(value) {
|
|
expect(value).to.be('value2');
|
|
}),
|
|
localforage3.getItem('key').then(function(value) {
|
|
expect(value).to.be('value3');
|
|
})
|
|
]);
|
|
}).then(function() {
|
|
done();
|
|
}, function(errors) {
|
|
done(new Error(errors));
|
|
});
|
|
});
|
|
});
|
|
|
|
// Refers to issue #492 - https://github.com/mozilla/localForage/issues/492
|
|
describe(driverName + ' driver multiple instances (concurrent on same database)', function() {
|
|
|
|
'use strict';
|
|
|
|
this.timeout(30000);
|
|
|
|
it('chains operation on multiple stores', function(done) {
|
|
|
|
prepareStorage('storage3').then(function() {
|
|
var localforage1 = localforage.createInstance({
|
|
name: 'storage3',
|
|
storeName: 'store1',
|
|
size: 1024
|
|
});
|
|
|
|
var localforage2 = localforage.createInstance({
|
|
name: 'storage3',
|
|
storeName: 'store2',
|
|
size: 1024
|
|
});
|
|
|
|
var localforage3 = localforage.createInstance({
|
|
name: 'storage3',
|
|
storeName: 'store3',
|
|
size: 1024
|
|
});
|
|
|
|
var promise1 = localforage1.setItem('key', 'value1').then(function() {
|
|
return localforage1.getItem('key');
|
|
}).then(function(value) {
|
|
expect(value).to.be('value1');
|
|
});
|
|
|
|
var promise2 = localforage2.setItem('key', 'value2').then(function() {
|
|
return localforage2.getItem('key');
|
|
}).then(function(value) {
|
|
expect(value).to.be('value2');
|
|
});
|
|
|
|
var promise3 = localforage3.setItem('key', 'value3').then(function() {
|
|
return localforage3.getItem('key');
|
|
}).then(function(value) {
|
|
expect(value).to.be('value3');
|
|
});
|
|
|
|
Promise.all([
|
|
promise1,
|
|
promise2,
|
|
promise3
|
|
]).then(function() {
|
|
done();
|
|
}).catch(function(errors) {
|
|
done(new Error(errors));
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
describe(driverName + ' driver', function() {
|
|
'use strict';
|
|
|
|
var driverPreferedOrder;
|
|
|
|
before(function() {
|
|
// add some unsupported drivers before
|
|
// and after the target driver
|
|
driverPreferedOrder = ['I am a not supported driver'];
|
|
|
|
if (!localforage.supports(localforage.WEBSQL)) {
|
|
driverPreferedOrder.push(localforage.WEBSQL);
|
|
}
|
|
if (!localforage.supports(localforage.INDEXEDDB)) {
|
|
driverPreferedOrder.push(localforage.INDEXEDDB);
|
|
}
|
|
if (!localforage.supports(localforage.LOCALSTORAGE)) {
|
|
driverPreferedOrder.push(localforage.localStorage);
|
|
}
|
|
|
|
driverPreferedOrder.push(driverName);
|
|
|
|
driverPreferedOrder.push('I am another not supported driver');
|
|
});
|
|
|
|
it('is used according to setDriver preference order', function(done) {
|
|
localforage.setDriver(driverPreferedOrder).then(function() {
|
|
expect(localforage.driver()).to.be(driverName);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe(driverName + ' driver when the callback throws an Error', function() {
|
|
'use strict';
|
|
|
|
var testObj = {
|
|
throwFunc: function() {
|
|
testObj.throwFuncCalls++;
|
|
throw new Error('Thrown test error');
|
|
},
|
|
throwFuncCalls: 0
|
|
};
|
|
|
|
beforeEach(function(done) {
|
|
testObj.throwFuncCalls = 0;
|
|
done();
|
|
});
|
|
|
|
it('resolves the promise of getItem()', function(done) {
|
|
localforage.getItem('key', testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves the promise of setItem()', function(done) {
|
|
localforage.setItem('key', 'test', testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves the promise of clear()', function(done) {
|
|
localforage.clear(testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves the promise of length()', function(done) {
|
|
localforage.length(testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves the promise of removeItem()', function(done) {
|
|
localforage.removeItem('key', testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves the promise of key()', function(done) {
|
|
localforage.key('key', testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
|
|
it('resolves the promise of keys()', function(done) {
|
|
localforage.keys(testObj.throwFunc).then(function() {
|
|
expect(testObj.throwFuncCalls).to.be(1);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
|
|
describe(driverName + ' driver when ready() gets rejected', function() {
|
|
'use strict';
|
|
|
|
this.timeout(30000);
|
|
|
|
var _oldReady;
|
|
|
|
beforeEach(function(done) {
|
|
_oldReady = localforage.ready;
|
|
localforage.ready = function() {
|
|
return Promise.reject();
|
|
};
|
|
done();
|
|
});
|
|
|
|
afterEach(function(done) {
|
|
localforage.ready = _oldReady;
|
|
_oldReady = null;
|
|
done();
|
|
});
|
|
|
|
driverApiMethods.forEach(function(methodName) {
|
|
it('rejects ' + methodName + '() promise', function(done) {
|
|
localforage[methodName]().then(null, function(/*err*/) {
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
DRIVERS.forEach(function(driverName) {
|
|
describe(driverName + ' driver instance', function() {
|
|
it('creates a new instance and sets the driver', function(done) {
|
|
var localforage2 = localforage.createInstance({
|
|
name: 'storage2',
|
|
driver: driverName,
|
|
// We need a small value here
|
|
// otherwise local PhantomJS test
|
|
// will fail with SECURITY_ERR.
|
|
// TravisCI seem to work fine though.
|
|
size: 1024,
|
|
storeName: 'storagename2'
|
|
});
|
|
|
|
// since config actually uses setDriver which is async,
|
|
// and since driver() and supports() are not defered (are sync),
|
|
// we have to wait till an async method returns
|
|
localforage2.length().then(function() {
|
|
expect(localforage2.driver()).to.be(driverName);
|
|
done();
|
|
}, function() {
|
|
expect(localforage2.driver()).to.be(null);
|
|
done();
|
|
});
|
|
});
|
|
});
|
|
});
|
|
|
|
SUPPORTED_DRIVERS.forEach(function(driverName) {
|
|
describe(driverName + ' driver dropInstance', function() {
|
|
|
|
this.timeout(30000);
|
|
|
|
var nodropInstance;
|
|
var nodropInstanceOptions = {
|
|
name: 'dropStoreDb',
|
|
driver: driverName,
|
|
size: 1024,
|
|
storeName: 'nodropStore'
|
|
};
|
|
|
|
var dropStoreInstance1;
|
|
var dropStoreInstance1Options = {
|
|
name: 'dropStoreDb',
|
|
driver: driverName,
|
|
size: 1024,
|
|
storeName: 'dropStore'
|
|
};
|
|
|
|
var dropStoreInstance2;
|
|
var dropStoreInstance2Options = {
|
|
name: 'dropStoreDb',
|
|
driver: driverName,
|
|
size: 1024,
|
|
storeName: 'dropStore2'
|
|
};
|
|
|
|
var dropStoreInstance3;
|
|
var dropStoreInstance3Options = {
|
|
name: 'dropStoreDb',
|
|
driver: driverName,
|
|
size: 1024,
|
|
storeName: 'dropStore3'
|
|
};
|
|
|
|
var dropDbInstance;
|
|
var dropDbInstanceOptions = {
|
|
name: 'dropDb',
|
|
driver: driverName,
|
|
size: 1024,
|
|
storeName: 'dropStore'
|
|
};
|
|
|
|
var dropDb2Instance;
|
|
var dropDb2InstanceOptions = {
|
|
name: 'dropDb2',
|
|
driver: driverName,
|
|
size: 1024,
|
|
storeName: 'dropStore'
|
|
};
|
|
|
|
before(function() {
|
|
nodropInstance = localforage.createInstance(nodropInstanceOptions);
|
|
dropStoreInstance1 = localforage.createInstance(dropStoreInstance1Options);
|
|
dropStoreInstance2 = localforage.createInstance(dropStoreInstance2Options);
|
|
dropStoreInstance3 = localforage.createInstance(dropStoreInstance2Options);
|
|
dropDbInstance = localforage.createInstance(dropDbInstanceOptions);
|
|
dropDb2Instance = localforage.createInstance(dropDb2InstanceOptions);
|
|
return Promise.resolve().then(function() {
|
|
return nodropInstance.setItem('key1', 'value0');
|
|
}).then(function() {
|
|
return dropStoreInstance1.setItem('key1', 'value1');
|
|
}).then(function() {
|
|
return dropStoreInstance2.setItem('key1', 'value2');
|
|
}).then(function() {
|
|
return dropStoreInstance3.setItem('key1', 'value3');
|
|
}).then(function() {
|
|
return dropDbInstance.setItem('key1', 'value3');
|
|
}).then(function() {
|
|
return dropDb2Instance.setItem('key1', 'value3');
|
|
});
|
|
});
|
|
|
|
function expectStoreToNotExistAsync(options) {
|
|
return new Promise(function(resolve, reject) {
|
|
if (driverName === localforage.INDEXEDDB) {
|
|
var req = indexedDB.open(options.name);
|
|
req.onsuccess = function() {
|
|
var db = req.result;
|
|
if (!db) {
|
|
reject();
|
|
return;
|
|
}
|
|
expect(db.objectStoreNames.contains(options.storeName)).to.be(false);
|
|
db.close();
|
|
resolve();
|
|
};
|
|
req.onerror = req.onblocked = reject;
|
|
} else if (driverName === localforage.WEBSQL) {
|
|
var db = openDatabase(options.name, '', '', 0);
|
|
db.transaction(function(t) {
|
|
t.executeSql(
|
|
"SELECT name FROM sqlite_master WHERE type='table' AND name = ?",
|
|
[options.storeName],
|
|
function(t, results) {
|
|
expect(results.rows.length).to.be(0);
|
|
resolve();
|
|
},
|
|
reject
|
|
);
|
|
}, reject);
|
|
} else if (driverName === localforage.LOCALSTORAGE) {
|
|
var keyPrefix = (function _getKeyPrefix(options, defaultConfig) {
|
|
var keyPrefix = options.name + '/';
|
|
|
|
if (options.storeName !== defaultConfig.storeName) {
|
|
keyPrefix += options.storeName + '/';
|
|
}
|
|
return keyPrefix;
|
|
})(options, {
|
|
name: 'localforage',
|
|
storeName: 'keyvaluepairs'
|
|
});
|
|
|
|
var foundLocalStorageKey = false;
|
|
for (var i = 0, length = localStorage.length; i < length; i++) {
|
|
if (localStorage.key(i).indexOf(keyPrefix) === 0) {
|
|
foundLocalStorageKey = true;
|
|
break;
|
|
}
|
|
}
|
|
expect(foundLocalStorageKey).to.be(false);
|
|
resolve();
|
|
} else {
|
|
throw new Error('Not Implemented Exception');
|
|
}
|
|
});
|
|
}
|
|
|
|
it('drops the current instance without affecting the rest', function() {
|
|
return dropStoreInstance1.dropInstance().then(function() {
|
|
return nodropInstance.getItem('key1');
|
|
}).then(function(value) {
|
|
expect(value).to.be('value0');
|
|
});
|
|
});
|
|
|
|
it('can recreate and set values to previously dropped instances', function() {
|
|
return dropStoreInstance1.dropInstance().then(function() {
|
|
return dropStoreInstance1.getItem('key1');
|
|
}).then(function(value) {
|
|
expect(value).to.be(null);
|
|
return dropStoreInstance1.length();
|
|
}).then(function(length) {
|
|
expect(length).to.be(0);
|
|
}).then(function() {
|
|
return dropStoreInstance1.setItem('key1', 'newvalue2');
|
|
}).then(function() {
|
|
return dropStoreInstance1.getItem('key1');
|
|
}).then(function(value) {
|
|
expect(value).to.be('newvalue2');
|
|
});
|
|
});
|
|
|
|
it('drops an other instance without affecting the rest', function() {
|
|
var opts = {
|
|
name: dropStoreInstance2Options.name,
|
|
storeName: dropStoreInstance2Options.storeName
|
|
};
|
|
return nodropInstance.dropInstance(opts).then(function() {
|
|
return nodropInstance.getItem('key1');
|
|
}).then(function(value) {
|
|
expect(value).to.be('value0');
|
|
});
|
|
});
|
|
|
|
it('the dropped instance is completely removed', function() {
|
|
var opts = {
|
|
name: dropStoreInstance3Options.name,
|
|
storeName: dropStoreInstance3Options.storeName
|
|
};
|
|
return dropStoreInstance3.dropInstance().then(function() {
|
|
return expectStoreToNotExistAsync(opts);
|
|
});
|
|
});
|
|
|
|
function expectDBToNotExistAsync(options) {
|
|
return new Promise(function(resolve, reject) {
|
|
if (driverName === localforage.INDEXEDDB) {
|
|
var req = indexedDB.open(options.name);
|
|
req.onsuccess = function() {
|
|
var db = req.result;
|
|
if (!db) {
|
|
reject();
|
|
return;
|
|
}
|
|
expect(db.objectStoreNames.length).to.be(0);
|
|
db.close();
|
|
resolve();
|
|
};
|
|
req.onerror = req.onblocked = reject;
|
|
} else if (driverName === localforage.WEBSQL) {
|
|
var db = openDatabase(options.name, '', '', 0);
|
|
db.transaction(function(t) {
|
|
t.executeSql(
|
|
"SELECT name FROM sqlite_master WHERE type='table'",
|
|
[],
|
|
function(t, results) {
|
|
var stores = Array.prototype.filter.call(results.rows, function(obj) {
|
|
return obj && obj.name && obj.name.indexOf('__') !== 0;
|
|
});
|
|
expect(stores.length).to.be(0);
|
|
resolve();
|
|
},
|
|
reject
|
|
);
|
|
}, reject);
|
|
} else if (driverName === localforage.LOCALSTORAGE) {
|
|
var keyPrefix = (function _getKeyPrefix(options) {
|
|
return options.name + '/';
|
|
})(options);
|
|
|
|
var foundLocalStorageKey = false;
|
|
for (var i = 0, length = localStorage.length; i < length; i++) {
|
|
if (localStorage.key(i).indexOf(keyPrefix) === 0) {
|
|
foundLocalStorageKey = true;
|
|
break;
|
|
}
|
|
}
|
|
expect(foundLocalStorageKey).to.be(false);
|
|
resolve();
|
|
} else {
|
|
throw new Error('Not Implemented Exception');
|
|
}
|
|
});
|
|
}
|
|
|
|
it('the dropped "DB" can be recreated', function() {
|
|
var opts = {
|
|
name: dropDbInstanceOptions.name
|
|
};
|
|
return dropDbInstance.dropInstance(opts).then(function() {
|
|
return dropDbInstance.getItem('key1');
|
|
}).then(function(value) {
|
|
expect(value).to.be(null);
|
|
});
|
|
});
|
|
|
|
it('the dropped "DB" is completely removed', function() {
|
|
var opts = {
|
|
name: dropDb2InstanceOptions.name
|
|
};
|
|
return dropDb2Instance.dropInstance(opts).then(function() {
|
|
return expectDBToNotExistAsync(opts);
|
|
});
|
|
});
|
|
});
|
|
});
|