@browser-storage/core/dist-src/browser-storage.test.js

Browser storage core

import { BrowserStorage, EVENT_KEY } from './browser-storage';
function makeOptions(drivers = [], crossTabNotification) {
    return {
        name: 'testName',
        storeName: 'testStoreName',
        version: 1,
        drivers,
        crossTabNotification
    };
}
class SupportedDriver {
    constructor() {
        this.isSupported = true;
    }
    async clear() {
        return undefined;
    }
    async getItem(key) {
        return JSON.parse(localStorage.getItem(key) || 'null');
    }
    async hasItem(key) {
        return localStorage.hasOwnProperty(key);
    }
    async init(dbOptions) {
        return undefined;
    }
    async iterate(iterator) {
        return undefined;
    }
    async key(index) {
        return '';
    }
    async keys() {
        return [];
    }
    async length() {
        return 0;
    }
    async ready() {
        return true;
    }
    async removeItem(key) {
        return undefined;
    }
    async setItem(key, item) {
        localStorage.setItem(key, JSON.stringify(item));
        return item;
    }
    async destroy() {
        return undefined;
    }
}
class UnsupportedDriver extends SupportedDriver {
    constructor() {
        super(...arguments);
        this.isSupported = false;
    }
}
describe('BrowserStorage', () => {
    test('#isSupported', async () => {
        const bs1 = new BrowserStorage(makeOptions([new SupportedDriver(), new UnsupportedDriver()]));
        const bs2 = new BrowserStorage(makeOptions([new UnsupportedDriver(), new SupportedDriver()]));
        const bs3 = new BrowserStorage(makeOptions(new UnsupportedDriver()));
        expect(bs1.isSupported).toBe(new SupportedDriver().isSupported);
        expect(bs1.isSupported).toBeTruthy();
        expect(bs2.isSupported).toBe(new SupportedDriver().isSupported);
        expect(bs3.isSupported).toBeFalsy();
    });
    test('#getDriver', async () => {
        const supportedDriver = new SupportedDriver();
        const unsupportedDriver = new UnsupportedDriver();
        const bs = new BrowserStorage(makeOptions([unsupportedDriver, supportedDriver]));
        expect(await bs.getDriver()).toEqual(supportedDriver);
    });
    test('#events', async () => {
        const supportedDriver = new SupportedDriver();
        const bs = new BrowserStorage(makeOptions(supportedDriver, true));
        const KEY = 'boolean';
        function handle1(event) {
            const options = makeOptions();
            expect(event.name).toEqual(options.name);
            expect(event.storeName).toEqual(options.storeName);
            expect(event.version).toEqual(options.version);
            expect(event.key).toEqual(KEY);
            expect(event.oldValue).toBeUndefined();
            expect(event.newValue).toBeTruthy();
        }
        bs.addEventListener(handle1);
        await bs.setItem(KEY, true);
        bs.removeEventListener(handle1);
        function handle2(event) {
            const options = makeOptions();
            expect(event.name).toEqual(options.name);
            expect(event.storeName).toEqual(options.storeName);
            expect(event.version).toEqual(options.version);
            expect(event.key).toEqual(KEY);
            expect(event.oldValue).toBeTruthy();
            expect(event.newValue).toBeFalsy();
        }
        bs.addEventListener(handle2);
        await bs.setItem(KEY, false);
        const fakeEvent = {
            key: EVENT_KEY,
            newValue: '',
            oldValue: '',
            storageArea: null,
            url: ''
        };
        await bs._storageChange(fakeEvent);
        const otherEvent = {
            key: 'otherEvent',
            newValue: '',
            oldValue: '',
            storageArea: null,
            url: ''
        };
        await bs._storageChange(otherEvent);
        await bs.destroy();
    });
});