@buley/dash 0.0.30 → 2.1.1

package/tests/indexes/indexes.spec.ts

@@ -1,203 +0,0 @@
-
-import indexesMethods from '../../src/indexes';
-import { DashContext } from '../../src/utilities';
-
-describe('indexesMethods', () => {
-    let mockSuccessCallback: jest.Mock;
-    let mockErrorCallback: jest.Mock;
-    let mockCompleteCallback: jest.Mock;
-
-    beforeEach(() => {
-        mockSuccessCallback = jest.fn();
-        mockErrorCallback = jest.fn();
-        mockCompleteCallback = jest.fn();
-    });
-
-    describe('get', () => {
-        it('should retrieve indexes from the object store and call on_success', async () => {
-            const mockObjectStore = {
-                indexNames: ['index1', 'index2']
-            };
-
-            const get_ctx: DashContext = {
-                objectstore: mockObjectStore as unknown as IDBObjectStore,
-                on_success: mockSuccessCallback
-            };
-
-            await indexesMethods.get(get_ctx);
-
-            expect(get_ctx.indexes).toEqual(['index1', 'index2']);
-            expect(mockSuccessCallback).toHaveBeenCalledWith(get_ctx);
-        });
-    });
-
-    describe('add', () => {
-        it('should add an index to the object store and call on_success', async () => {
-            const mockObjectStore = {
-                createIndex: jest.fn()
-            };
-
-            const add_ctx: DashContext = {
-                objectstore: mockObjectStore as unknown as IDBObjectStore,
-                index: 'newIndex',
-                index_key_path: 'keyPath',
-                index_unique: true,
-                on_success: mockSuccessCallback
-            };
-
-            await indexesMethods.add(add_ctx);
-
-            expect(mockObjectStore.createIndex).toHaveBeenCalledWith('newIndex', 'keyPath', {
-                unique: true,
-                multiEntry: false
-            });
-            expect(mockSuccessCallback).toHaveBeenCalledWith(add_ctx);
-        });
-    });
-
-    describe('remove', () => {
-        it('should remove an index from the object store and call on_success', async () => {
-            const mockObjectStore = {
-                deleteIndex: jest.fn()
-            };
-
-            const remove_ctx: DashContext = {
-                objectstore: mockObjectStore as unknown as IDBObjectStore,
-                index: 'indexToRemove',
-                on_success: mockSuccessCallback
-            };
-
-            await indexesMethods.remove(remove_ctx);
-
-            expect(mockObjectStore.deleteIndex).toHaveBeenCalledWith('indexToRemove');
-            expect(mockSuccessCallback).toHaveBeenCalledWith(remove_ctx);
-        });
-    });
-
-    describe('getEntries', () => {
-        it('should retrieve entries from an index and call on_success for each entry and on_complete at the end', async () => {
-            jest.setTimeout(10000);  // Increase timeout to 10 seconds
-
-            let callCount = 0;
-            const mockEntries = [
-                { id: 1, name: 'Entry1' },
-                { id: 2, name: 'Entry2' }
-            ];
-        
-            const mockCursor = {
-                value: mockEntries[0],
-                continue: jest.fn(() => {
-                    callCount++;
-                    if (callCount >= mockEntries.length) {
-                        mockRequest.result = null;  // Simulate end of the cursor
-                    } else {
-                        mockCursor.value = mockEntries[callCount];
-                    }
-                    mockRequest.onsuccess(new Event('success'));
-                }),
-            };
-        
-            const mockRequest = {
-                result: mockCursor as { value: { id: number; name: string; }; continue: jest.Mock<void, [], any>; } | null,
-                onsuccess: (ev: Event) => {
-                    // your code here
-                },
-            };
-        
-            const mockObjectStore = {
-                index: jest.fn(() => ({
-                    openCursor: jest.fn(() => mockRequest),
-                })),
-            };
-        
-            const mockSuccessCallback = jest.fn();
-            const mockCompleteCallback = jest.fn();
-        
-            const get_ctx: DashContext = {
-                objectstore: mockObjectStore as unknown as IDBObjectStore,
-                index: 'indexName',
-                on_success: mockSuccessCallback,
-                on_complete: mockCompleteCallback,
-            };
-        
-            const getEntriesPromise = indexesMethods.getEntries(get_ctx);
-        
-            // Trigger the first onsuccess callback
-            if (mockRequest.onsuccess) {
-                mockRequest.onsuccess(new Event('success'));
-            }
-        
-            await getEntriesPromise;
-        
-            expect(mockObjectStore.index).toHaveBeenCalledWith('indexName');
-            expect(mockSuccessCallback).toHaveBeenCalledTimes(2);  // Called for two entries
-            expect(mockSuccessCallback).toHaveBeenNthCalledWith(1, mockEntries[0]);
-            expect(mockSuccessCallback).toHaveBeenNthCalledWith(2, mockEntries[1]);
-            expect(mockCompleteCallback).toHaveBeenCalledWith(get_ctx);
-        });
-        
-    });
-
-    describe('countEntries', () => {
-        it('should count entries in the object store index and call on_success', async () => {
-            const mockObjectStore = {
-                index: jest.fn().mockReturnValue({
-                    count: jest.fn().mockReturnValue({
-                        addEventListener: (event: string, callback: () => void) => {
-                            if (event === 'success') callback();
-                        },
-                        result: 5
-                    })
-                })
-            };
-    
-            const count_ctx: DashContext = {
-                objectstore: mockObjectStore as unknown as IDBObjectStore,
-                index: 'testIndex',
-                on_success: mockSuccessCallback
-            };
-    
-            await indexesMethods.countEntries(count_ctx);
-    
-            expect(mockObjectStore.index).toHaveBeenCalledWith('testIndex');
-            expect(mockSuccessCallback).toHaveBeenCalledWith(count_ctx);
-            expect(count_ctx.total).toBe(5);
-        });
-    
-        
-        it('should handle errors and call on_error', async () => {
-            const mockObjectStore = {
-                index: jest.fn().mockReturnValue({
-                    count: jest.fn().mockReturnValue({
-                        addEventListener: (event: string, callback: (event: any) => void) => {
-                            if (event === 'error') {
-                                const mockErrorEvent = { target: { error: new Error('Test Error') } };
-                                callback(mockErrorEvent);
-                            }
-                        }
-                    })
-                })
-            };
-        
-            const count_ctx: DashContext = {
-                objectstore: mockObjectStore as unknown as IDBObjectStore,
-                index: 'testIndex',
-                on_error: mockErrorCallback
-            };
-        
-            try {
-                // Await the function call
-                await indexesMethods.countEntries(count_ctx);
-            } catch (ctx: any) {
-                // Expect the error to be part of the returned context
-                expect(ctx.error).toEqual(new Error('Test Error'));
-        
-                // Ensure the error callback is called with the correct context
-                expect(mockErrorCallback).toHaveBeenCalledWith(count_ctx);
-            }
-        });
-        
-        
-    });
-    
-});

package/tests/store/store.spec.ts

@@ -1,164 +0,0 @@
-
-import storeMethods from '../../src/store';
-import { DashContext } from '../../src/utilities';
-
-describe('storeMethods', () => {
-    // Mock functions to be used in tests
-    const mockSuccessCallback = jest.fn();
-    const mockErrorCallback = jest.fn();
-
-    beforeEach(() => {
-        // Reset mock functions before each test
-        mockSuccessCallback.mockReset();
-        mockErrorCallback.mockReset();
-    });
-
-    describe('clear', () => {
-        it('should clear the object store and call on_success', async () => {
-            const mockRequest = {
-                addEventListener: jest.fn((event, callback) => {
-                    if (event === 'success') {
-                        setTimeout(() => {
-                            callback();
-                        }, 0);  // Simulate async success event
-                    }
-                }),
-            };
-        
-            const clear_ctx: DashContext = {
-                objectstore: {
-                    clear: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                on_success: mockSuccessCallback,
-            };
-        
-            await storeMethods.clear(clear_ctx);
-            expect(clear_ctx.objectstore?.clear).toHaveBeenCalled();
-            expect(mockSuccessCallback).toHaveBeenCalledWith(clear_ctx);
-        });
-        
-
-        it('should handle errors when clearing the object store', () => {
-            const mockRequest = { addEventListener: jest.fn((event: string, callback: EventListenerOrEventListenerObject) => {
-                if (event === 'error') (callback as EventListener)({ target: { error: new Error('Clear Error') } } as any);
-            }) };
-
-            const clear_ctx: DashContext = {
-                objectstore: {
-                    clear: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                on_error: mockErrorCallback,
-            };
-
-            return storeMethods.clear(clear_ctx).catch((ctx: DashContext) => {
-                expect(clear_ctx.objectstore?.clear).toHaveBeenCalled();
-                expect(mockErrorCallback).toHaveBeenCalledWith(ctx);
-                expect(ctx.error.message).toBe('Clear Error');
-            });
-        });
-    });
-
-    describe('remove', () => {
-        it('should remove an entry from the object store and call on_success', () => {
-            const mockRequest = { addEventListener: jest.fn((event: string, callback: EventListenerOrEventListenerObject) => {
-                if (event === 'success') (callback as EventListener)(new Event('success'));
-            }) };
-
-            const remove_ctx: DashContext = {
-                objectstore: {
-                    delete: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                key: 'testKey',
-                on_success: mockSuccessCallback,
-            };
-
-            return storeMethods.remove(remove_ctx).then((ctx: DashContext) => {
-                expect(remove_ctx.objectstore?.delete).toHaveBeenCalledWith('testKey');
-                expect(mockSuccessCallback).toHaveBeenCalledWith(ctx);
-            });
-        });
-
-        it('should handle errors when removing an entry', () => {
-            const mockRequest = { addEventListener: jest.fn((event: string, callback: EventListenerOrEventListenerObject) => {
-                if (event === 'error') (callback as EventListener)({ target: { error: new Error('Remove Error') } } as any);
-            }) };
-
-            const remove_ctx: DashContext = {
-                objectstore: {
-                    delete: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                key: 'testKey',
-                on_error: mockErrorCallback,
-            };
-
-            return storeMethods.remove(remove_ctx).catch((ctx: DashContext) => {
-                expect(remove_ctx.objectstore?.delete).toHaveBeenCalledWith('testKey');
-                expect(mockErrorCallback).toHaveBeenCalledWith(ctx);
-                expect(ctx.error.message).toBe('Remove Error');
-            });
-        });
-    });
-
-    describe('get', () => {
-        it('should retrieve an entry from the object store and call on_success', () => {
-            const mockRequest = { addEventListener: jest.fn((event: string, callback: EventListenerOrEventListenerObject) => {
-                if (event === 'success') (callback as EventListener)(new Event('success'));
-            }), result: 'testEntry' };
-
-            const get_ctx: DashContext = {
-                objectstore: {
-                    get: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                key: 'testKey',
-                on_success: mockSuccessCallback,
-            };
-
-            return storeMethods.get(get_ctx).then((ctx: DashContext) => {
-                expect(get_ctx.objectstore?.get).toHaveBeenCalledWith('testKey');
-                expect(mockSuccessCallback).toHaveBeenCalledWith(ctx);
-                expect(ctx.entry).toBe('testEntry');
-            });
-        });
-
-        it('should handle errors when retrieving an entry', () => {
-            const mockRequest = { addEventListener: jest.fn((event: string, callback: EventListenerOrEventListenerObject) => {
-                if (event === 'error') (callback as EventListener)({ target: { error: new Error('Get Error') } } as any);
-            }) };
-
-            const get_ctx: DashContext = {
-                objectstore: {
-                    get: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                key: 'testKey',
-                on_error: mockErrorCallback,
-            };
-
-            return storeMethods.get(get_ctx).catch((ctx: DashContext) => {
-                expect(get_ctx.objectstore?.get).toHaveBeenCalledWith('testKey');
-                expect(mockErrorCallback).toHaveBeenCalledWith(ctx);
-                expect(ctx.error.message).toBe('Get Error');
-            });
-        });
-
-        it('should reject if the entry is missing', () => {
-            const mockRequest = { addEventListener: jest.fn((event: string, callback: EventListenerOrEventListenerObject) => {
-                if (event === 'success') (callback as EventListener)(new Event('success'));
-            }), result: undefined };
-
-            const get_ctx: DashContext = {
-                objectstore: {
-                    get: jest.fn(() => mockRequest),
-                } as unknown as IDBObjectStore,
-                key: 'testKey',
-                on_error: mockErrorCallback,
-            };
-
-            return storeMethods.get(get_ctx).catch((ctx: DashContext) => {
-                expect(get_ctx.objectstore?.get).toHaveBeenCalledWith('testKey');
-                expect(mockErrorCallback).toHaveBeenCalledWith(ctx);
-                expect(ctx.error.message).toBe('missing');
-                expect(ctx.error.name).toBe('DashNoEntry');
-            });
-        });
-    });
-});

package/tests/stores/stores.spec.ts

@@ -1,148 +0,0 @@
-
-import storesMethods from '../../src/stores';
-import { DashContext } from '../../src/utilities';
-
-describe('storesMethods', () => {
-    // Mock functions to be used in tests
-    const mockSuccessCallback = jest.fn();
-    const mockErrorCallback = jest.fn();
-
-    beforeEach(() => {
-        // Reset mock functions before each test
-        mockSuccessCallback.mockReset();
-        mockErrorCallback.mockReset();
-    });
-
-const mockDb = {
-    name: 'mockDb',
-    version: 1,
-    objectStoreNames: ['store1', 'store2'],
-    createObjectStore: jest.fn(() => ({
-        createIndex: jest.fn(),
-    })),
-    deleteObjectStore: jest.fn(),
-    transaction: jest.fn(() => ({
-        objectStore: jest.fn(() => ({
-            clear: jest.fn(),
-        })),
-        db: {},
-        mode: 'readwrite',
-        error: null,
-        onabort: null,
-        oncomplete: null,
-        onerror: null,
-        addEventListener: jest.fn(),
-        removeEventListener: jest.fn(),
-        dispatchEvent: jest.fn(),
-    })),
-    close: jest.fn(),
-    onabort: null,
-    onclose: null,
-    onerror: null,
-    onversionchange: null,
-} as unknown as IDBDatabase;
-
-
-    describe('get', () => {
-        it('should retrieve object store names and call on_success', () => {
-            const get_ctx: DashContext = { db: mockDb, on_success: mockSuccessCallback };
-
-            storesMethods.get(get_ctx);
-
-            expect(get_ctx.stores).toEqual(['store1', 'store2']);  // Check store names
-            expect(mockSuccessCallback).toHaveBeenCalledWith(get_ctx);  // Success callback should be called
-        });
-    });
-
-    describe('add', () => {
-        it('should add a new object store and call on_success', () => {
-            const mockRequest = {
-                result: {
-                    createObjectStore: jest.fn(() => ({
-                        createIndex: jest.fn(),
-                    })),
-                },
-            } as IDBRequest<any>;
-        
-            const add_ctx: DashContext = {
-                request: mockRequest,  // Mock the request object and its result
-                store: 'newStore',
-                store_key_path: 'id',
-                auto_increment: true,
-                indexes: [{ name: 'index1', keyPath: 'key1', unique: true }],
-                on_success: mockSuccessCallback,
-            };
-        
-            storesMethods.add(add_ctx);
-        
-            expect(mockRequest.result.createObjectStore).toHaveBeenCalledWith('newStore', { keyPath: 'id', autoIncrement: true });
-            expect(mockSuccessCallback).toHaveBeenCalledWith(add_ctx);  // Success callback should be called
-        });
-
-        it('should throw an error if database is undefined', () => {
-            const add_ctx: DashContext = { db: undefined, on_error: mockErrorCallback };
-
-            expect(() => storesMethods.add(add_ctx)).toThrow('Database is undefined');
-        });
-    });
-
-    describe('remove', () => {
-        it('should remove an object store and call on_success', () => {
-            const remove_ctx: DashContext = { db: mockDb, store: 'storeToRemove', on_success: mockSuccessCallback };
-
-            storesMethods.remove(remove_ctx);
-
-            expect(mockDb.deleteObjectStore).toHaveBeenCalledWith('storeToRemove');
-            expect(mockSuccessCallback).toHaveBeenCalledWith(remove_ctx);  // Success callback should be called
-        });
-    });
-
-    describe('clearAll', () => {
-        it('should clear all object stores and call on_success on transaction complete', () => {
-            const mockTransaction = {
-                objectStore: jest.fn(() => ({
-                    clear: jest.fn(),
-                })),
-                addEventListener: jest.fn((event, callback) => {
-                    if (event === 'complete') callback();  // Trigger complete event
-                }),
-                oncomplete: jest.fn(),
-            };
-        
-            const mockDb = {
-                name: 'mockDb',
-                objectStoreNames: ['store1', 'store2'],
-                transaction: jest.fn(() => mockTransaction),
-                createObjectStore: jest.fn(),
-                deleteObjectStore: jest.fn(),
-            } as unknown as IDBDatabase;
-        
-            const clear_ctx: DashContext = { db: mockDb, on_success: mockSuccessCallback, on_error: mockErrorCallback };
-        
-            storesMethods.clearAll(clear_ctx);
-        
-            expect(mockDb.transaction).toHaveBeenCalledWith(['store1', 'store2'], 'readwrite');
-            expect(mockSuccessCallback).toHaveBeenCalledWith(clear_ctx);  // Success callback should be called
-        });
-
-        it('should call on_error when transaction encounters an error', () => {
-            const failingMockDb: unknown = {
-                ...mockDb,
-                transaction: jest.fn(() => ({
-                    objectStore: jest.fn(() => ({
-                        clear: jest.fn(),
-                    })),
-                    addEventListener: jest.fn((event, callback) => {
-                        if (event === 'error') callback({ target: { error: new Error('Transaction Error') } });
-                    }),
-                })),
-            };
-            const clear_ctx: DashContext = { db: failingMockDb as IDBDatabase, on_success: mockSuccessCallback, on_error: mockErrorCallback };
-
-            storesMethods.clearAll(clear_ctx);
-
-            expect(mockErrorCallback).toHaveBeenCalled();  // Error callback should be called
-            expect(clear_ctx.error.message).toBe('Transaction Error');
-        });
-    });
-});

package/tests/utilities/clone.spec.ts

@@ -1,48 +0,0 @@
-import { clone } from '../../src/utilities';
-
-describe('clone', () => {
-    it('should clone a simple object', () => {
-        const result = clone({ foo: "bar" });
-        expect(result).toBeDefined();
-        expect(result).toEqual({ foo: "bar" });
-        expect(result).not.toBe({ foo: "bar" }); // Ensure it's not the same reference
-    });
-
-    it('should deeply clone a nested object', () => {
-        const source = { foo: "bar", nested: { baz: 42 } };
-        const result = clone(source);
-        expect(result).toEqual(source);
-        expect(result).not.toBe(source); // Different reference
-        expect(result.nested).not.toBe(source.nested); // Nested object should also be cloned
-    });
-
-    it('should clone arrays correctly', () => {
-        const source = [1, 2, 3, { foo: "bar" }];
-        const result = clone(source);
-        expect(result).toEqual(source);
-        expect(result).not.toBe(source); // Ensure it's not the same reference
-        expect(result[3]).not.toBe(source[3]); // Nested objects in arrays should also be cloned
-    });
-
-    it('should handle cloning null', () => {
-        const result = clone(null);
-        expect(result).toBeNull();
-    });
-
-    it('should handle cloning undefined', () => {
-        const result = clone(undefined);
-        expect(result).toBeUndefined();
-    });
-
-    it('should handle cloning complex objects with functions', () => {
-        const source = {
-            foo: "bar",
-            method: function () {
-                return "test";
-            }
-        };
-        const result = clone(source);
-        expect(result).toEqual(source);
-        expect(result.method()).toBe("test"); // Functions should still work after cloning
-    });
-});

package/tests/utilities/cloneError.spec.ts

@@ -1,33 +0,0 @@
-import { cloneError } from '../../src/utilities';
-
-describe('cloneError', () => {
-    it('should create a deep clone of an error object', () => {
-        const source = new Error('test');
-        const result = cloneError(source);
-        
-        // Check that the result is defined and an instance of Error
-        expect(result).toBeDefined();
-        expect(result).toBeInstanceOf(Error);
-        
-        // Ensure the cloned error has the same message and properties
-        expect(result.message).toBe(source.message);
-        
-        // Optionally verify the stack if it's available
-        if (source.stack) {
-            expect(result.stack).toBe(source.stack);  // Stack should be the same
-        }
-
-        // Ensure the result is a new object, not just a reference to the original
-        expect(result).not.toBe(source);
-    });
-
-    it('should handle custom error properties', () => {
-        const source = new Error('test') as any;
-        source.customProp = 'customValue';
-        const result = cloneError(source);
-
-        // Ensure the custom properties are cloned as well
-        expect((result as any).customProp).toBe(source.customProp);
-        expect(result).not.toBe(source);  // Verify it's a new object
-    });
-});

package/tests/utilities/contains.spec.ts

@@ -1,28 +0,0 @@
-import { contains } from '../../src/utilities';
-
-describe('contains', () => {
-    it('should return true if the substring exists in the string', () => {
-        const result = contains('hello world', 'world');
-        expect(result).toBe(true);
-    });
-
-    it('should return false if the substring does not exist in the string', () => {
-        const result = contains('hello world', 'moon');
-        expect(result).toBe(false);
-    });
-
-    it('should return false when the main string is empty', () => {
-        const result = contains('', 'hello');
-        expect(result).toBe(false);
-    });
-
-    it('should return true when the substring is empty', () => {
-        const result = contains('hello world', '');
-        expect(result).toBe(true); // An empty substring is technically in any string
-    });
-
-    it('should handle case sensitivity properly', () => {
-        const result = contains('hello world', 'World');
-        expect(result).toBe(false); // Case-sensitive
-    });
-});

package/tests/utilities/exists.spec.ts

@@ -1,21 +0,0 @@
-import { exists } from '../../src/utilities';
-
-describe('exists', () => {
-    it('should return true for defined values', () => {
-        expect(exists(42)).toBe(true);          // number
-        expect(exists('hello')).toBe(true);     // non-empty string
-        expect(exists({})).toBe(true);          // object
-        expect(exists([])).toBe(true);          // array
-        expect(exists(false)).toBe(true);       // boolean false
-        expect(exists(0)).toBe(true);           // number 0
-    });
-
-    it('should return false for undefined or null values', () => {
-        expect(exists(undefined)).toBe(false);  // undefined
-        expect(exists(null)).toBe(false);       // null
-    });
-
-    it('should return true for empty string', () => {
-        expect(exists('')).toBe(true);          // empty string is still a defined value
-    });
-});

package/tests/utilities/is.spec.ts

@@ -1,37 +0,0 @@
-import { is } from '../../src/utilities';
-
-describe('is', () => {
-    it('should return true for identical primitive values', () => {
-        expect(is(42, 42)).toBe(true);           // number
-        expect(is('hello', 'hello')).toBe(true); // string
-        expect(is(true, true)).toBe(true);       // boolean
-    });
-
-    it('should return true for objects with the same reference', () => {
-        const obj = { foo: 'bar' };
-        expect(is(obj, obj)).toBe(true);         // Same reference
-    });
-
-    it('should return false for different objects even if they have the same structure', () => {
-        const obj1 = { foo: 'bar' };
-        const obj2 = { foo: 'bar' };
-        expect(is(obj1, obj2)).toBe(false);      // Different references
-    });
-
-    it('should return true for identical arrays (by reference)', () => {
-        const arr = [1, 2, 3];
-        expect(is(arr, arr)).toBe(true);         // Same array reference
-    });
-
-    it('should return false for different arrays with the same elements', () => {
-        expect(is([1, 2, 3], [1, 2, 3])).toBe(false); // Different array instances
-    });
-
-    it('should return true for null values compared to null', () => {
-        expect(is(null, null)).toBe(true);       // null values
-    });
-
-    it('should return false when comparing null with undefined', () => {
-        expect(is(null, undefined)).toBe(false); // null vs undefined
-    });
-});