chore: Make tests compatible with localforage

- Use async/await

Author: intercepted16

test/localStorageStore.test.ts

@@ -1,16 +1,22 @@
 import { persisted, writable } from '../index'
 import { get } from 'svelte/store'
 import { expect, vi, beforeEach, describe, test, it } from 'vitest'
+import localforage from 'localforage'
 
-beforeEach(() => localStorage.clear())
+beforeEach(async () => {
+  await localforage.clear();
+  /* Set the driver to localStorage, overriding the default IndexedDB,
+     since localStorage is used in all but the final two tests. */
+  await localforage.setDriver(localforage.LOCALSTORAGE);
+})
 
 describe('writable()', () => {
-  test('it works, but raises deprecation warning', () => {
+  test('it works, but raises deprecation warning', async () => {
     console.warn = vi.fn()
 
-    localStorage.setItem('myKey2', '"existing"')
+    await localforage.setItem('myKey2', '"existing"')
 
-    const store = writable('myKey2', 'initial')
+    const store = await writable('myKey2', 'initial')
     const value = get(store)
 
     expect(value).toEqual('existing')
@@ -19,120 +25,120 @@ describe('writable()', () => {
 })
 
 describe('persisted()', () => {
-  test('uses initial value if nothing in local storage', () => {
-    const store = persisted('myKey', 123)
+  test('uses initial value if nothing in local storage', async () => {
+    const store = await persisted('myKey', 123)
     const value = get(store)
 
     expect(value).toEqual(123)
-    expect(localStorage.myKey).toBeUndefined()
+    expect(await localforage.getItem("myKey")).toBeNull()
   })
 
-  test('uses existing value if data already in local storage', () => {
-    localStorage.setItem('myKey2', '"existing"')
+  test('uses existing value if data already in local storage', async () => {
+    await localforage.setItem('myKey2', '"existing"')
 
-    const store = persisted('myKey2', 'initial')
+    const store = await persisted('myKey2', 'initial')
     const value = get(store)
 
     expect(value).toEqual('existing')
   })
 
   describe('set()', () => {
-    test('replaces old value', () => {
-      localStorage.setItem('myKey3', '"existing"')
+    test('replaces old value', async () => {
+      await localforage.setItem('myKey3', '"existing"')
 
-      const store = persisted('myKey3', '')
-      store.set('new-value')
+      const store = await persisted('myKey3', '')
+      await store.set('new-value')
       const value = get(store)
 
-      expect(localStorage.myKey3).toEqual('"new-value"')
+      expect(await localforage.getItem("myKey3")).toEqual('"new-value"')
       expect(value).toEqual('new-value')
     })
 
-    test('adds new value', () => {
-      const store = persisted('myKey4', '')
-      store.set('new-value')
+    test('adds new value', async () => {
+      const store = await persisted('myKey4', '')
+      await store.set('new-value')
       const value = get(store)
 
-      expect(localStorage.myKey4).toEqual('"new-value"')
+      expect(await localforage.getItem("myKey4")).toEqual('"new-value"')
       expect(value).toEqual('new-value')
     })
   })
 
   describe('update()', () => {
-    test('replaces old value', () => {
-      const store = persisted('myKey5', 123)
+    test('replaces old value', async () => {
+      const store = await persisted('myKey5', 123)
       store.update(n => n + 1)
       const value = get(store)
 
-      expect(localStorage.myKey5).toEqual('124')
+      expect(await (await localforage.getItem("myKey5"))).toEqual('124')
       expect(value).toEqual(124)
     })
 
-    test('adds new value', () => {
-      const store = persisted('myKey6', 123)
-      store.update(n => n + 1)
+    test('adds new value', async () => {
+      const store = await persisted('myKey6', 123)
+      await store.update(n => n + 1)
       const value = get(store)
 
-      expect(localStorage.myKey6).toEqual('124')
+      expect(await localforage.getItem("myKey6")).toEqual('124')
       expect(value).toEqual(124)
     })
 
-    test("BUG: update should use existing value", () => {
-      localStorage.setItem('myKey6b', '12345')
-      const store = persisted('myKey6b', 123)
-      store.update(n => { n += 1; return n })
+    test("BUG: update should use existing value", async () => {
+      await localforage.setItem('myKey6b', '12345')
+      const store = await persisted('myKey6b', 123)
+      await store.update(n => { n += 1; return n })
 
-      expect(localStorage.myKey6b).toEqual('12346')
+      expect(await localforage.getItem("myKey6b")).toEqual('12346')
     })
   })
 
   describe('reset', () => {
-    it('resets to initial value', () => {
-      const store = persisted('myKey14', 123);
-      store.set(456);
-      store.reset();
+    it('resets to initial value', async () => {
+      const store = await persisted('myKey14', 123);
+      await store.set(456);
+      await store.reset();
       const value = get(store);
 
       expect(value).toEqual(123);
-      expect(localStorage.myKey14).toEqual('123');
+      expect(await localforage.getItem("myKey14")).toEqual('123');
       });
     });
 
   describe('subscribe()', () => {
-    it('publishes updates', () => {
-      const store = persisted('myKey7', 123)
+    it('publishes updates', async () => {
+      const store = await persisted('myKey7', 123)
       const values: number[] = []
       const unsub = store.subscribe((value: number) => {
         if (value !== undefined) values.push(value)
       })
-      store.set(456)
-      store.set(999)
+      await store.set(456)
+      await store.set(999)
 
       expect(values).toEqual([123, 456, 999])
 
       unsub()
     })
   })
 
-  it('handles duplicate stores with the same key', () => {
-    const store1 = persisted('same-key', 1)
+  it('handles duplicate stores with the same key', async () => {
+    const store1 = await persisted('same-key', 1)
     const values1: number[] = []
 
-    const unsub1 = store1.subscribe(value => {
+    const unsub1 = (await store1).subscribe(value => {
       values1.push(value)
     })
 
-    store1.set(2)
+  await store1.set(2)
 
-    const store2 = persisted('same-key', 99)
+    const store2 = await persisted('same-key', 99)
     const values2: number[] = []
 
-    const unsub2 = store2.subscribe(value => {
+    const unsub2 = (await store2).subscribe(value => {
       values2.push(value)
     })
 
-    store1.set(3)
-    store2.set(4)
+    await store1.set(3)
+    await store2.set(4)
 
     expect(values1).toEqual([1, 2, 3, 4])
     expect(values2).toEqual([2, 3, 4])
@@ -145,13 +151,13 @@ describe('persisted()', () => {
   })
 
   describe("beforeRead and beforeWrite", () => {
-    it("allows modifying initial value before reading", () => {
-      localStorage.setItem("beforeRead-init-test", JSON.stringify(2))
-      const store = persisted("beforeRead-init-test", 0, { beforeRead: (v: number) => v * 2 })
+    it("allows modifying initial value before reading", async () => {
+      await localforage.setItem("beforeRead-init-test", JSON.stringify(2))
+      const store = await persisted("beforeRead-init-test", 0, { beforeRead: (v: number) => v * 2 })
       expect(get(store)).toEqual(4)
     })
-    it("allows modifying value before reading upon event", () => {
-      const store = persisted("beforeRead-test", 0, { beforeRead: (v: number) => v * 2 })
+    it("allows modifying value before reading upon event", async () => {
+      const store = await persisted("beforeRead-test", 0, { beforeRead: (v: number) => v * 2 })
       const values: number[] = []
 
       const unsub = store.subscribe((val: number) => {
@@ -166,19 +172,19 @@ describe('persisted()', () => {
       unsub()
     })
 
-    it("allows modifying value before writing", () => {
-      const store = persisted("beforeWrite-test", 0, { beforeWrite: (v) => v * 2 })
-      store.set(2)
+    it("allows modifying value before writing", async () => {
+      const store = await persisted("beforeWrite-test", 0, { beforeWrite: (v) => v * 2 })
+      await store.set(2)
 
-      expect(JSON.parse(localStorage.getItem("beforeWrite-test") as string)).toEqual(4)
+      expect(JSON.parse(await localforage.getItem("beforeWrite-test") as string)).toEqual(4)
     })
   })
 
   describe('handles window.storage event', () => {
     type NumberDict = { [key: string]: number }
 
-    it('sets storage when key matches', () => {
-      const store = persisted('myKey8', { a: 1 })
+    it('sets storage when key matches', async () => {
+      const store = await persisted('myKey8', { a: 1 })
       const values: NumberDict[] = []
 
       const unsub = store.subscribe((value: NumberDict) => {
@@ -193,8 +199,8 @@ describe('persisted()', () => {
       unsub()
     })
 
-    it('ignores storages events when value is null', () => {
-      const store = persisted('myKey9', { a: 1 })
+    it('ignores storages events when value is null', async () => {
+      const store = await persisted('myKey9', { a: 1 })
       const values: NumberDict[] = []
 
       const unsub = store.subscribe((value: NumberDict) => {
@@ -209,8 +215,8 @@ describe('persisted()', () => {
       unsub()
     })
 
-    it("doesn't update store when key doesn't match", () => {
-      const store = persisted('myKey10', 1)
+    it("doesn't update store when key doesn't match", async () => {
+      const store = await persisted('myKey10', 1)
       const values: number[] = []
 
       const unsub = store.subscribe((value: number) => {
@@ -225,10 +231,10 @@ describe('persisted()', () => {
       unsub()
     })
 
-    it("doesn't update store when there are no subscribers", () => {
-      localStorage.setItem('myKeyb', '2')
+    it("doesn't update store when there are no subscribers", async () => {
+      await localforage.setItem('myKeyb', '2')
 
-      const store = persisted('myKeyb', 1)
+      const store = await persisted('myKeyb', 1)
       const values: number[] = []
 
       const event = new StorageEvent('storage', { key: 'myKeyb', newValue: '2' })
@@ -243,8 +249,8 @@ describe('persisted()', () => {
       unsub()
     })
 
-    it('ignores session-backed stores', () => {
-      const store = persisted('myKey10', 1, { storage: 'session' })
+    it('ignores session-backed stores', async () => {
+      const store = await persisted('myKey10', 1, { storage: 'session' })
       const values: number[] = []
 
       const unsub = store.subscribe((value) => {
@@ -259,8 +265,8 @@ describe('persisted()', () => {
       unsub()
     })
 
-    it("doesn't update, when syncTabs option is disabled", () => {
-      const store = persisted('myKey13', 1, { syncTabs: false })
+    it("doesn't update, when syncTabs option is disabled", async () => {
+      const store = await persisted('myKey13', 1, { syncTabs: false })
       const values: number[] = []
 
       const unsub = store.subscribe((value) => {
@@ -276,21 +282,21 @@ describe('persisted()', () => {
     })
   })
 
-  it('allows custom serialize/deserialize functions', () => {
+  it('allows custom serialize/deserialize functions', async () => {
     const serializer = {
       stringify: (set: Set<number>) => JSON.stringify(Array.from(set)),
       parse: (json: string) => new Set(JSON.parse(json)),
     }
 
     const testSet = new Set([1, 2, 3])
 
-    const store = persisted('myKey11', testSet, { serializer })
+    const store = await persisted('myKey11', testSet, { serializer })
     const value = get(store)
 
-    store.update(d => d.add(4))
+    await store.update(d => d.add(4))
 
     expect(value).toEqual(testSet)
-    expect(localStorage.myKey11).toEqual(serializer.stringify(new Set([1, 2, 3, 4])))
+    expect(await localforage.getItem("myKey11")).toEqual(serializer.stringify(new Set([1, 2, 3, 4])))
   })
 
   it('lets you switch storage type', () => {
@@ -299,11 +305,11 @@ describe('persisted()', () => {
 
     const value = 'foo'
 
-    const store = persisted('myKey12', value, {
+    const store = await persisted('myKey12', value, {
       storage: 'session'
     })
 
-    store.set('bar')
+    await store.set('bar')
 
     expect(window.sessionStorage.setItem).toHaveBeenCalled()
   })

test/readDomExceptions.test.ts

@@ -1,32 +1,33 @@
+import localforage from 'localforage'
 import { persisted } from '../index'
 import { expect, vi, beforeEach, describe, it } from 'vitest'
 
 beforeEach(() => localStorage.clear())
 
 describe('persisted()', () => {
 
-  it('logs error encountered when reading from local storage', () => {
+  it('logs error encountered when reading from local storage', async () => {
     const consoleMock = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-    localStorage.setItem("myKey", "INVALID JSON")
-    persisted('myKey', '')
+    await localforage.setItem("myKey", "INVALID JSON")
+    await persisted('myKey', '')
 
     expect(consoleMock).toHaveBeenCalledWith('Error when parsing "INVALID JSON" from persisted store "myKey"', expect.any(SyntaxError))
     consoleMock.mockReset();
   })
 
-  it('calls custom error function upon init', () => {
+  it('calls custom error function upon init', async () => {
     const mockFunc = vi.fn()
 
-    localStorage.setItem("myKey2", "INVALID JSON")
-    persisted('myKey2', '', { onParseError: mockFunc })
+    await localforage.setItem("myKey2", "INVALID JSON")
+    await persisted('myKey2', '', { onParseError: mockFunc })
 
     expect(mockFunc).toHaveBeenCalledOnce()
   })
 
-  it('calls custom error function upon external write', () => {
+  it('calls custom error function upon external write', async () => {
     const mockFunc = vi.fn()
 
-    const store = persisted('myKey3', '', { onParseError: mockFunc })
+    const store = await persisted('myKey3', '', { onParseError: mockFunc })
     const unsub = store.subscribe(() => undefined)
 
     const event = new StorageEvent('storage', { key: 'myKey3', newValue: 'INVALID JSON' })