@storve/core 1.0.1 → 1.0.3

package/tests/integration.test.ts

@@ -1,278 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { createStore } from '../src/store';
-
-describe('3.1 Real World Scenarios', () => {
-    describe('Counter store', () => {
-        it('increment, decrement, reset', () => {
-            const store = createStore({ count: 0 });
-            store.setState((s) => ({ count: s.count + 1 }));
-            expect(store.getState().count).toBe(1);
-            store.setState((s) => ({ count: s.count - 1 }));
-            expect(store.getState().count).toBe(0);
-            store.setState({ count: 0 });
-        });
-
-        it('multiple components subscribed', () => {
-            const store = createStore({ count: 0 });
-            const s1 = vi.fn(), s2 = vi.fn();
-            store.subscribe(s1); store.subscribe(s2);
-            store.setState({ count: 1 });
-            expect(s1).toHaveBeenCalled();
-            expect(s2).toHaveBeenCalled();
-        });
-    });
-
-    describe('Todo store', () => {
-        it('add todo', () => {
-            const store = createStore({ todos: [] as unknown[] });
-            store.setState(s => ({ todos: [...s.todos, { id: 1 }] }));
-            expect(store.getState().todos.length).toBe(1);
-        });
-        it('remove todo', () => {
-            const store = createStore({ todos: [{ id: 1 }] });
-            store.setState(() => ({ todos: [] }));
-            expect(store.getState().todos.length).toBe(0);
-        });
-        it('toggle todo complete', () => {
-            const store = createStore({ todos: [{ id: 1, done: false }] });
-            store.setState(() => ({ todos: [{ id: 1, done: true }] }));
-            expect(store.getState().todos[0].done).toBe(true);
-        });
-        it('filter completed todos via computed (derived)', () => {
-            const store = createStore({ todos: [{ id: 1, done: true }, { id: 2, done: false }] });
-            const completed = store.getState().todos.filter(t => t.done);
-            expect(completed.length).toBe(1);
-        });
-        it('clear all todos', () => {
-            const store = createStore({ todos: [{ id: 1 }] });
-            store.setState({ todos: [] });
-            expect(store.getState().todos.length).toBe(0);
-        });
-    });
-
-    describe('User profile store', () => {
-        it.each([
-            ['update name', { user: { name: 'A', address: { city: 'X' } } }, { user: { name: 'B', address: { city: 'X' } } }],
-            ['update nested address', { user: { name: 'A', address: { city: 'X' } } }, { user: { name: 'A', address: { city: 'Y' } } }],
-            ['replace entire nested object', { user: { name: 'A', address: { city: 'X' } } }, { user: { name: 'B', address: { city: 'Y' } } }]
-        ])('%s', (_, initial, expected) => {
-            const store = createStore(initial);
-            store.setState(expected);
-            expect(store.getState()).toEqual(expected);
-        });
-    });
-
-    describe('Shopping cart store', () => {
-        it.each([
-            ['add item', { items: [] }, { items: [{ id: 1, qty: 1 }] }],
-            ['remove item', { items: [{ id: 1 }] }, { items: [] }],
-            ['update quantity', { items: [{ id: 1, qty: 1 }] }, { items: [{ id: 1, qty: 2 }] }],
-            ['clear cart', { items: [{ id: 1 }] }, { items: [] }]
-        ])('%s', (_, initial, expected) => {
-            const store = createStore(initial as Record<string, unknown>);
-            store.setState(expected as Record<string, unknown>);
-            expect(store.getState()).toEqual(expected);
-        });
-
-        it('total computed from items', () => {
-            const store = createStore({ items: [{ price: 10, qty: 2 }, { price: 5, qty: 1 }] });
-            const total = store.getState().items.reduce((acc, item) => acc + item.price * item.qty, 0);
-            expect(total).toBe(25);
-        });
-    });
-
-    describe('Theme store', () => {
-        it('toggle dark/light mode', () => {
-            const store = createStore({ theme: 'light' });
-            store.setState({ theme: 'dark' });
-            expect(store.getState().theme).toBe('dark');
-        });
-    });
-
-    describe('Auth store', () => {
-        it('login sets user', () => {
-            const store = createStore({ user: null as ({ id: number } | null) });
-            store.setState({ user: { id: 1 } });
-            expect(store.getState().user).toEqual({ id: 1 });
-        });
-        it('logout clears user', () => {
-            const store = createStore({ user: { id: 1 } as ({ id: number } | null) });
-            store.setState({ user: null });
-            expect(store.getState().user).toBeNull();
-        });
-    });
-
-    describe('Pagination store', () => {
-        it.each([
-            ['next page', { page: 1 }, { page: 2 }],
-            ['previous page', { page: 2 }, { page: 1 }],
-            ['jump to page', { page: 1 }, { page: 5 }]
-        ])('%s', (_, initial, expected) => {
-            const store = createStore(initial);
-            store.setState(expected);
-            expect(store.getState()).toEqual(expected);
-        });
-    });
-
-    describe('Form store', () => {
-        it.each([
-            ['update field value', { f1: '', f2: '' }, { f1: 'A', f2: '' }],
-            ['reset all fields', { f1: 'A', f2: 'B' }, { f1: '', f2: '' }]
-        ])('%s', (_, initial, expected) => {
-            const store = createStore(initial);
-            store.setState(expected);
-            expect(store.getState()).toEqual(expected);
-        });
-
-        it('validate fields', () => {
-            const store = createStore({ email: 'test', errors: {} as Record<string, unknown> });
-            if (!store.getState().email.includes('@')) {
-                store.setState({ errors: { email: 'invalid' } });
-            }
-            expect(store.getState().errors.email).toBe('invalid');
-        });
-    });
-
-    describe('Multi-store', () => {
-        it('two stores are fully independent', () => {
-            const s1 = createStore({ a: 1 });
-            const s2 = createStore({ b: 2 });
-            s1.setState({ a: 10 });
-            expect(s2.getState().b).toBe(2);
-        });
-        it('store A change does not notify store B subscribers', () => {
-            const s1 = createStore({ a: 1 });
-            const s2 = createStore({ b: 2 });
-            const l2 = vi.fn();
-            s2.subscribe(l2);
-            s1.setState({ a: 10 });
-            expect(l2).not.toHaveBeenCalled();
-        });
-        it('both stores can be subscribed simultaneously', () => {
-            const s1 = createStore({ a: 1 });
-            const s2 = createStore({ b: 2 });
-            const l1 = vi.fn(), l2 = vi.fn();
-            s1.subscribe(l1); s2.subscribe(l2);
-            s1.setState({ a: 10 });
-            s2.setState({ b: 20 });
-            expect(l1).toHaveBeenCalledTimes(1);
-            expect(l2).toHaveBeenCalledTimes(1);
-        });
-    });
-});
-
-describe('3.2 Subscription Lifecycle', () => {
-    it('Subscribe → update → unsubscribe → update — listener not called after', () => {
-        const store = createStore({ a: 1 });
-        const listener = vi.fn();
-        const unsub = store.subscribe(listener);
-        store.setState({ a: 2 });
-        unsub();
-        store.setState({ a: 3 });
-        expect(listener).toHaveBeenCalledTimes(1);
-    });
-
-    it('Subscribe → update → re-subscribe → update — listener called again', () => {
-        const store = createStore({ a: 1 });
-        const listener = vi.fn();
-        let unsub = store.subscribe(listener);
-        store.setState({ a: 2 });
-        unsub();
-        unsub = store.subscribe(listener);
-        store.setState({ a: 3 });
-        expect(listener).toHaveBeenCalledTimes(2);
-    });
-
-    it('Subscribe multiple → unsubscribe all → update — no listeners called', () => {
-        const store = createStore({ a: 1 });
-        const l1 = vi.fn(), l2 = vi.fn();
-        const u1 = store.subscribe(l1);
-        const u2 = store.subscribe(l2);
-        u1(); u2();
-        store.setState({ a: 2 });
-        expect(l1).not.toHaveBeenCalled();
-        expect(l2).not.toHaveBeenCalled();
-    });
-
-    it('Subscribe → many updates → unsubscribe — correct call count', () => {
-        const store = createStore({ a: 1 });
-        const listener = vi.fn();
-        const unsub = store.subscribe(listener);
-        for (let i = 0; i < 10; i++) store.setState({ a: i });
-        unsub();
-        expect(listener).toHaveBeenCalledTimes(10);
-    });
-
-    it('Subscribe inside subscribe callback — nested subscription works', () => {
-        const store = createStore({ a: 1 });
-        const l2 = vi.fn();
-        let once = false;
-        store.subscribe(() => {
-            if (!once) { store.subscribe(l2); once = true; }
-        });
-        store.setState({ a: 2 });
-        store.setState({ a: 3 });
-        expect(l2).toHaveBeenCalled();
-    });
-
-    it('Unsubscribe inside subscribe callback — safe to call mid-notification', () => {
-        const store = createStore({ a: 1 });
-        const l1 = vi.fn();
-        const unsub1 = store.subscribe(() => {
-            l1();
-            unsub1();
-        });
-        store.setState({ a: 2 });
-        store.setState({ a: 3 });
-        expect(l1).toHaveBeenCalledTimes(1);
-    });
-
-    it('Store with zero subscribers — setState does not throw', () => {
-        const store = createStore({ a: 1 });
-        expect(() => store.setState({ a: 2 })).not.toThrow();
-    });
-
-    it('Store with zero subscribers — getState still works', () => {
-        const store = createStore({ a: 1 });
-        store.setState({ a: 2 });
-        expect(store.getState().a).toBe(2);
-    });
-});
-
-describe('3.3 State Immutability', () => {
-    it('Mutating returned getState() does not affect store state', () => {
-        const store = createStore({ a: 1 });
-        const state = store.getState();
-        const listener = vi.fn();
-        store.subscribe(listener);
-        (state as Record<string, unknown>).a = 2;
-        expect(listener).not.toHaveBeenCalled();
-    });
-
-    it('Mutating original definition object does not affect store state', () => {
-        const initial = { a: 1 };
-        const store = createStore(initial);
-        const listener = vi.fn();
-        store.subscribe(listener);
-        initial.a = 2;
-        expect(listener).not.toHaveBeenCalled();
-    });
-
-    it('Mutating setState argument after calling setState has no effect', () => {
-        const store = createStore({ obj: { val: 1 } });
-        const update = { obj: { val: 2 } };
-        store.setState(update);
-        const listener = vi.fn();
-        store.subscribe(listener);
-        update.obj.val = 3;
-        expect(listener).not.toHaveBeenCalled();
-    });
-
-    it('Two stores created from same definition object are independent', () => {
-        const def = { a: 1 };
-        const s1 = createStore({ ...def });
-        const s2 = createStore({ ...def });
-        s1.setState({ a: 2 });
-        expect(s2.getState().a).toBe(1);
-    });
-});

package/tests/persist/adapters/indexedDB.adapter.test.ts

@@ -1,185 +0,0 @@
-import { vi, describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { indexedDBAdapter } from '../../../src/persist/adapters/indexedDB'
-
-function createIDBMock() {
-  const store = new Map<string, string>()
-  const mockDB = {
-    objectStoreNames: { contains: vi.fn(() => true) },
-    createObjectStore: vi.fn(),
-    transaction: vi.fn(() => ({
-      objectStore: vi.fn(() => ({
-        get: vi.fn((key: string) => {
-          const req: { onsuccess: (() => void) | null, onerror: (() => void) | null, result: string | null } = { 
-            onsuccess: null,
-            onerror: null,
-            result: store.get(key) ?? null
-          }
-          setTimeout(() => req.onsuccess?.(), 0)
-          return req
-        }),
-        put: vi.fn((value: string, key: string) => { 
-          store.set(key, value)
-          const req: { onsuccess: (() => void) | null, onerror: (() => void) | null } = { onsuccess: null, onerror: null }
-          setTimeout(() => req.onsuccess?.(), 0)
-          return req
-        }),
-        delete: vi.fn((key: string) => {
-          store.delete(key)
-          const req: { onsuccess: (() => void) | null, onerror: (() => void) | null } = { onsuccess: null, onerror: null }
-          setTimeout(() => req.onsuccess?.(), 0)
-          return req
-        }),
-      }))
-    }))
-  }
-  return { store, mockDB }
-}
-
-describe('indexedDBAdapter', () => {
-  let store: Map<string, string>
-  let mockDB: ReturnType<typeof createIDBMock>['mockDB']
-  let openSpy: ReturnType<typeof vi.fn>
-
-  beforeEach(() => {
-    const mock = createIDBMock()
-    store = mock.store
-    mockDB = mock.mockDB
-
-    openSpy = vi.fn(() => {
-      const request: { 
-        onsuccess: (() => void) | null
-        onerror: (() => void) | null
-        onupgradeneeded: (() => void) | null
-        result: typeof mockDB 
-      } = {
-        onsuccess: null,
-        onerror: null,
-        onupgradeneeded: null,
-        result: mockDB
-      }
-      setTimeout(() => request.onsuccess?.(), 0)
-      return request
-    })
-
-    vi.stubGlobal('indexedDB', { open: openSpy })
-  })
-
-  afterEach(() => {
-    vi.restoreAllMocks()
-    vi.unstubAllGlobals()
-  })
-
-  describe('Normal environment (indexedDB available)', () => {
-    it('getItem returns null for a key that was never set', async () => {
-      const adapter = indexedDBAdapter()
-      const result = await adapter.getItem('missing')
-      expect(result).toBeNull()
-    })
-
-    it('getItem returns correct value after setItem', async () => {
-      const adapter = indexedDBAdapter()
-      await adapter.setItem('key', 'value')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('value')
-    })
-
-    it('setItem stores value correctly', async () => {
-      const adapter = indexedDBAdapter()
-      await adapter.setItem('key', 'value')
-      expect(store.get('key')).toBe('value')
-    })
-
-    it('setItem overwrites existing value', async () => {
-      const adapter = indexedDBAdapter()
-      await adapter.setItem('key', 'first')
-      await adapter.setItem('key', 'second')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('second')
-    })
-
-    it('removeItem removes the key (getItem returns null after)', async () => {
-      const adapter = indexedDBAdapter()
-      await adapter.setItem('delete-me', 'please')
-      await adapter.removeItem('delete-me')
-      const result = await adapter.getItem('delete-me')
-      expect(result).toBeNull()
-    })
-
-    it('removeItem is a no-op when key does not exist', async () => {
-      const adapter = indexedDBAdapter()
-      await expect(adapter.removeItem('never-set')).resolves.toBeUndefined()
-    })
-
-    it('DB is opened only once across multiple operations (lazy + shared promise)', async () => {
-      const adapter = indexedDBAdapter()
-      await adapter.setItem('a', '1')
-      await adapter.getItem('a')
-      await adapter.removeItem('a')
-
-      expect(openSpy).toHaveBeenCalledTimes(1)
-    })
-
-    it('custom dbName is used when provided', async () => {
-      const adapter = indexedDBAdapter('custom-db')
-      await adapter.getItem('test')
-      expect(openSpy).toHaveBeenCalledWith('custom-db', 1)
-    })
-  })
-
-  describe('Error handling', () => {
-    beforeEach(() => {
-      // make open fail
-      openSpy.mockImplementation(() => {
-        const request: { onerror: (() => void) | null } = { onerror: null }
-        setTimeout(() => request.onerror?.(), 0)
-        return request
-      })
-    })
-
-    it('when DB open fails, getItem resolves to null without throwing', async () => {
-      const adapter = indexedDBAdapter()
-      const result = await adapter.getItem('key')
-      expect(result).toBeNull()
-    })
-
-    it('when DB open fails, setItem resolves without throwing', async () => {
-      const adapter = indexedDBAdapter()
-      await expect(adapter.setItem('key', 'val')).resolves.toBeUndefined()
-    })
-
-    it('when DB open fails, a warning is logged (vi.spyOn console.warn)', async () => {
-      const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
-      const adapter = indexedDBAdapter()
-      await adapter.getItem('key')
-      expect(warnSpy).toHaveBeenCalledWith(expect.stringContaining('[storve] Failed to open IndexedDB'))
-    })
-  })
-
-  describe('SSR guard (indexedDB undefined)', () => {
-    beforeEach(() => {
-      vi.stubGlobal('indexedDB', undefined)
-    })
-
-    it('getItem returns Promise<null> without throwing', async () => {
-      const adapter = indexedDBAdapter()
-      const result = await adapter.getItem('ssr-key')
-      expect(result).toBeNull()
-    })
-
-    it('setItem returns Promise<void> without throwing', async () => {
-      const adapter = indexedDBAdapter()
-      await expect(adapter.setItem('ssr-key', 'value')).resolves.toBeUndefined()
-    })
-
-    it('removeItem returns Promise<void> without throwing', async () => {
-      const adapter = indexedDBAdapter()
-      await expect(adapter.removeItem('ssr-key')).resolves.toBeUndefined()
-    })
-
-    it('indexedDB is never accessed', async () => {
-      const adapter = indexedDBAdapter()
-      await adapter.getItem('key')
-      expect(openSpy).not.toHaveBeenCalled()
-    })
-  })
-})

package/tests/persist/adapters/localStorage.adapter.test.ts

@@ -1,105 +0,0 @@
-// @vitest-environment jsdom
-import { vi, describe, it, expect, afterEach } from 'vitest'
-import { localStorageAdapter } from '../../../src/persist/adapters/localStorage'
-
-describe('localStorageAdapter', () => {
-  afterEach(() => {
-    vi.restoreAllMocks()
-    vi.unstubAllGlobals()
-    if (typeof localStorage !== 'undefined') localStorage.clear()
-  })
-
-  describe('browser environment', () => {
-    it('getItem returns null for a key that does not exist', async () => {
-      const adapter = localStorageAdapter()
-      const result = await adapter.getItem('missing')
-      expect(result).toBeNull()
-    })
-
-    it('getItem returns the correct value after setItem', async () => {
-      const adapter = localStorageAdapter()
-      await adapter.setItem('key', 'value')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('value')
-    })
-
-    it('setItem stores value in window.localStorage correctly', async () => {
-      const adapter = localStorageAdapter()
-      await adapter.setItem('direct', 'data')
-      expect(localStorage.getItem('direct')).toBe('data')
-    })
-
-    it('setItem overwrites existing value for the same key', async () => {
-      const adapter = localStorageAdapter()
-      await adapter.setItem('key', 'first')
-      await adapter.setItem('key', 'second')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('second')
-    })
-
-    it('removeItem removes the key (getItem returns null after)', async () => {
-      const adapter = localStorageAdapter()
-      await adapter.setItem('delete-me', 'please')
-      await adapter.removeItem('delete-me')
-      const result = await adapter.getItem('delete-me')
-      expect(result).toBeNull()
-    })
-
-    it('removeItem is a no-op when key does not exist (no error)', async () => {
-      const adapter = localStorageAdapter()
-      expect(() => adapter.removeItem('never-set')).not.toThrow()
-    })
-
-    it('delegates directly to window.localStorage — verify with vi.spyOn', async () => {
-      const spySet = vi.spyOn(Storage.prototype, 'setItem')
-      const spyGet = vi.spyOn(Storage.prototype, 'getItem')
-      const spyRemove = vi.spyOn(Storage.prototype, 'removeItem')
-
-      const adapter = localStorageAdapter()
-      await adapter.setItem('spyKey', 'spyValue')
-      expect(spySet).toHaveBeenCalledWith('spyKey', 'spyValue')
-
-      await adapter.getItem('spyKey')
-      expect(spyGet).toHaveBeenCalledWith('spyKey')
-
-      await adapter.removeItem('spyKey')
-      expect(spyRemove).toHaveBeenCalledWith('spyKey')
-    })
-  })
-
-  describe('SSR — window undefined', () => {
-    it('getItem returns null without throwing', async () => {
-      vi.stubGlobal('window', undefined)
-      const adapter = localStorageAdapter()
-      const result = await adapter.getItem('ssr-key')
-      expect(result).toBeNull()
-    })
-
-    it('setItem does nothing without throwing', async () => {
-      vi.stubGlobal('window', undefined)
-      const adapter = localStorageAdapter()
-      expect(() => adapter.setItem('ssr-key', 'value')).not.toThrow()
-    })
-
-    it('removeItem does nothing without throwing', async () => {
-      vi.stubGlobal('window', undefined)
-      const adapter = localStorageAdapter()
-      expect(() => adapter.removeItem('ssr-key')).not.toThrow()
-    })
-
-    it('localStorage is never accessed when window is undefined', async () => {
-      const spyGet = vi.spyOn(Storage.prototype, 'getItem')
-      const spySet = vi.spyOn(Storage.prototype, 'setItem')
-      
-      vi.stubGlobal('window', undefined)
-      const adapter = localStorageAdapter()
-      
-      await adapter.getItem('key')
-      await adapter.setItem('key', 'val')
-      await adapter.removeItem('key')
-      
-      expect(spyGet).not.toHaveBeenCalled()
-      expect(spySet).not.toHaveBeenCalled()
-    })
-  })
-})

package/tests/persist/adapters/memory.adapter.test.ts

@@ -1,112 +0,0 @@
-import { describe, it, expect } from 'vitest'
-import { memoryAdapter } from '../../../src/persist/adapters/memory'
-
-describe('memoryAdapter', () => {
-  describe('getItem', () => {
-    it('returns null for a key that has never been set', async () => {
-      const adapter = memoryAdapter()
-      const result = await adapter.getItem('missing')
-      expect(result).toBeNull()
-    })
-
-    it('returns the correct value after setItem has been called', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('key', 'value')
-      const result = await adapter.getItem('key')
-      expect(result).toBe('value')
-    })
-
-    it('returns null after removeItem has been called on that key', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('key', 'value')
-      await adapter.removeItem('key')
-      const result = await adapter.getItem('key')
-      expect(result).toBeNull()
-    })
-
-    it('is case-sensitive (key \'Count\' and key \'count\' are different)', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('Count', '1')
-      await adapter.setItem('count', '2')
-      
-      const countUpper = await adapter.getItem('Count')
-      const countLower = await adapter.getItem('count')
-      
-      expect(countUpper).toBe('1')
-      expect(countLower).toBe('2')
-    })
-  })
-
-  describe('setItem', () => {
-    it('stores a string value correctly', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('token', 'abc')
-      expect(await adapter.getItem('token')).toBe('abc')
-    })
-
-    it('overwrites an existing value for the same key', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('key', 'first')
-      await adapter.setItem('key', 'second')
-      expect(await adapter.getItem('key')).toBe('second')
-    })
-
-    it('stores multiple keys independently', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('a', '1')
-      await adapter.setItem('b', '2')
-      
-      expect(await adapter.getItem('a')).toBe('1')
-      expect(await adapter.getItem('b')).toBe('2')
-    })
-  })
-
-  describe('removeItem', () => {
-    it('removes an existing key (getItem returns null after)', async () => {
-      const adapter = memoryAdapter()
-      await adapter.setItem('target', 'content')
-      await adapter.removeItem('target')
-      expect(await adapter.getItem('target')).toBeNull()
-    })
-
-    it('is a no-op when key does not exist (no error thrown)', async () => {
-      const adapter = memoryAdapter()
-      // should not throw
-      expect(() => adapter.removeItem('never-set')).not.toThrow()
-    })
-  })
-
-  describe('Isolation', () => {
-    it('two separate memoryAdapter() instances do not share data', async () => {
-      const adapter1 = memoryAdapter()
-      const adapter2 = memoryAdapter()
-      
-      await adapter1.setItem('key', 'value')
-      expect(await adapter2.getItem('key')).toBeNull()
-    })
-
-    it('setting a key in instance A does not affect instance B', async () => {
-      const adapterA = memoryAdapter()
-      const adapterB = memoryAdapter()
-      
-      await adapterA.setItem('shared', 'A')
-      await adapterB.setItem('shared', 'B')
-      
-      expect(await adapterA.getItem('shared')).toBe('A')
-      expect(await adapterB.getItem('shared')).toBe('B')
-    })
-
-    it('clearing instance A does not affect instance B', async () => {
-      const adapterA = memoryAdapter()
-      const adapterB = memoryAdapter()
-      
-      await adapterA.setItem('key', 'value')
-      await adapterB.setItem('key', 'value')
-      
-      await adapterA.removeItem('key')
-      
-      expect(await adapterA.getItem('key')).toBeNull()
-      expect(await adapterB.getItem('key')).toBe('value')
-    })
-  })
-})