@buley/dash 0.0.30

package/tests/indexes/indexes.spec.ts

@@ -0,0 +1,203 @@
+
+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

@@ -0,0 +1,164 @@
+
+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

@@ -0,0 +1,148 @@
+
+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

@@ -0,0 +1,48 @@
+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

@@ -0,0 +1,33 @@
+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

@@ -0,0 +1,28 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,37 @@
+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
+    });
+});