@buley/dash 0.0.30

package/tests/databases/databases.spec.ts

@@ -0,0 +1,199 @@
+import { databasesMethods } from '../../src/databases';
+import { DashContext } from '../../src/utilities';
+
+// Mock indexedDB globally
+const mockIndexedDB = {
+  databases: jest.fn(),
+  open: jest.fn(),
+  deleteDatabase: jest.fn(),
+};
+(global as any).indexedDB = mockIndexedDB;
+
+describe('databasesMethods', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('open', () => {
+    it('should open a database successfully', async () => {
+      const mockDB = {};
+      const mockRequest = {
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'success') {
+            callback({ target: { result: mockDB } });
+          }
+        }),
+      };
+      mockIndexedDB.open.mockReturnValue(mockRequest);
+
+      const open_ctx: DashContext = {
+        database: 'testDB',
+        version: 1,
+      };
+
+      const result = await databasesMethods.open(open_ctx);
+      expect(result.db).toBe(mockDB);
+      expect(mockIndexedDB.open).toHaveBeenCalledWith('testDB', 1);
+    });
+
+    it('should handle upgradeneeded event', async () => {
+      const mockDB = {};
+      const mockRequest = {
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'upgradeneeded') {
+            callback({ target: { result: mockDB } });
+          }
+        }),
+      };
+      mockIndexedDB.open.mockReturnValue(mockRequest);
+
+      const open_ctx: DashContext = {
+        database: 'testDB',
+        version: 2,
+        on_upgrade_needed: jest.fn(),
+      };
+
+      const result = await databasesMethods.open(open_ctx);
+      expect(result.db).toBe(mockDB);
+      expect(open_ctx.on_upgrade_needed).toHaveBeenCalled();
+    });
+
+    it('should handle errors', async () => {
+      const mockError = new Error('Open failed');
+      const mockRequest = {
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'error') {
+            callback({ target: { error: mockError } });
+          }
+        }),
+      };
+      mockIndexedDB.open.mockReturnValue(mockRequest);
+
+      const open_ctx: DashContext = {
+        database: 'testDB',
+        version: 1,
+      };
+
+      await expect(databasesMethods.open(open_ctx)).rejects.toMatchObject({
+        error: mockError,
+      });
+    });
+  });
+  
+  describe('get', () => {
+    it('should get all databases successfully', async () => {
+      const mockDatabases = [{ name: 'db1' }, { name: 'db2' }];
+      mockIndexedDB.databases.mockReturnValue(mockDatabases);
+
+      const get_ctx: DashContext = {
+        databases: [],
+        on_success: jest.fn(),
+      };
+
+      const result = await databasesMethods.get(get_ctx);
+      expect(result.databases).toEqual(mockDatabases);
+      expect(get_ctx.on_success).toHaveBeenCalledWith(result);
+    });
+
+    it('should handle errors when getting databases', async () => {
+      const mockError = new Error('Get failed');
+      mockIndexedDB.databases.mockImplementation(() => {
+        throw mockError;
+      });
+
+      const get_ctx: DashContext = {
+        databases: [],
+        on_error: jest.fn(),
+      };
+
+      await expect(databasesMethods.get(get_ctx)).rejects.toMatchObject({
+        error: mockError,
+      });
+      expect(get_ctx.on_error).toHaveBeenCalled();
+    });
+  });
+
+  describe('delete', () => {
+    it('should delete a database successfully', async () => {
+      const mockRequest = {
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'success') {
+            callback();
+          }
+        }),
+      };
+      mockIndexedDB.deleteDatabase.mockReturnValue(mockRequest);
+
+      const delete_ctx: DashContext = {
+        database: 'testDB',
+      };
+
+      const result = await databasesMethods.delete(delete_ctx);
+      expect(result).toBe(delete_ctx);
+      expect(mockIndexedDB.deleteDatabase).toHaveBeenCalledWith('testDB');
+    });
+
+    it('should handle errors during deletion', async () => {
+      const mockError = new Error('Delete failed');
+      const mockRequest = {
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'error') {
+            callback({ target: { error: mockError } });
+          }
+        }),
+      };
+      mockIndexedDB.deleteDatabase.mockReturnValue(mockRequest);
+
+      const delete_ctx: DashContext = {
+        database: 'testDB',
+      };
+
+      await expect(databasesMethods.delete(delete_ctx)).rejects.toMatchObject({
+        error: mockError,
+      });
+    });
+  });
+
+  describe('close', () => {
+    it('should close a database', async () => {
+      const mockDB = {
+          close: jest.fn(),
+      } as unknown as IDBDatabase;
+      const close_ctx: DashContext = {
+        db: mockDB,
+      };
+
+      const result = await databasesMethods.close(close_ctx);
+      expect(result).toBe(close_ctx);
+      expect(mockDB.close).toHaveBeenCalled();
+    });
+  });
+
+  describe('listAll', () => {
+    it('should list all databases when supported', async () => {
+      const mockDatabases = [{ name: 'db1' }, { name: 'db2' }];
+      mockIndexedDB.databases.mockResolvedValue(mockDatabases);
+
+      const result = await databasesMethods.listAll();
+      expect(result).toEqual(mockDatabases);
+    });
+
+    it('should handle errors when listing databases', async () => {
+      const mockError = new Error('Listing failed');
+      mockIndexedDB.databases.mockRejectedValue(mockError);
+
+      await expect(databasesMethods.listAll()).rejects.toThrow('Listing failed');
+    });
+
+    it('should reject when databases method is not supported', async () => {
+      const originalDatabases = mockIndexedDB.databases;
+      mockIndexedDB.databases = undefined as any;
+
+      await expect(databasesMethods.listAll()).rejects.toThrow(
+        "The `databases` method is not supported in this browser."
+      );
+
+      mockIndexedDB.databases = originalDatabases;
+    });
+  });
+});

package/tests/entry/entry.spec.ts

@@ -0,0 +1,252 @@
+
+import { entryMethods } from "../../src/entry";
+
+// Mock data and context for tests
+const mockObjectStore = {
+    add: jest.fn(),
+    get: jest.fn(),
+    put: jest.fn(),
+    delete: jest.fn(),
+    index: jest.fn(),
+    count: jest.fn(),
+};
+
+describe('entryMethods', () => {
+
+    describe('add', () => {
+        const add_ctx = {
+            objectstore: mockObjectStore as unknown as IDBObjectStore,
+            data: {},
+            key: 'testKey',
+        };
+
+        it('should add an entry and resolve with the updated context', async () => {
+            mockObjectStore.add.mockReturnValueOnce({
+                addEventListener: (event: string, callback: () => void) => {
+                    if (event === 'success') {
+                        callback();
+                    }
+                },
+                result: 'newKey'
+            });
+            const result = await entryMethods.add({ ...add_ctx, objectstore: mockObjectStore as unknown as IDBObjectStore });
+            expect((result as { key: string }).key).toBe('newKey');
+        });
+
+        it('should reject with an error if the request fails', async () => {
+            return await expect(entryMethods.add(add_ctx)).rejects.toEqual(expect.objectContaining({
+                error: expect.objectContaining({
+                    message: "Request object is null",
+                    name: "DashRequestError"
+                })
+            }));
+        });
+    });
+
+    describe('get', () => {
+        const get_ctx = {
+            objectstore: mockObjectStore as unknown as IDBObjectStore,
+            key: 'testKey',
+            index: null,
+        };
+
+        it('should get an entry and resolve with the context', async () => {
+            mockObjectStore.get.mockReturnValueOnce({
+                addEventListener: (event: string, callback: () => void) => {
+                    if (event === 'success') {
+                        callback();
+                    }
+                },
+                result: { entryData: 'test' }
+            });
+            const result = await entryMethods.get(get_ctx) as { entry: { entryData: string } };
+            expect(result.entry).toEqual({ entryData: 'test' });
+        });
+
+        it('should reject with an error if the request fails', async () => {
+            await expect(entryMethods.get(get_ctx)).rejects.toEqual(expect.objectContaining({
+                error: expect.objectContaining({
+                    message: "Request object is null",
+                    name: "DashRequestError"
+                })
+            }));
+        });
+    });
+
+    describe('put', () => {
+        const put_ctx = {
+            objectstore: mockObjectStore as unknown as IDBObjectStore,
+            data: {},
+            key: 'testKey',
+        };
+
+        it('should put an entry and resolve with the updated context', async () => {
+            mockObjectStore.put.mockReturnValueOnce({
+                addEventListener: (event: string, callback: () => void) => {
+                    if (event === 'success') {
+                        callback();
+                    }
+                },
+            });
+            const result = await entryMethods.put(put_ctx) as { entry: any };
+            expect(result.entry).toBe(put_ctx.data);
+        });
+
+        it('should reject with an error if the request fails', async () => {
+            await expect(entryMethods.put(put_ctx)).rejects.toEqual(expect.objectContaining({
+                error: expect.objectContaining({
+                    message: "Request object is null",
+                    name: "DashRequestError"
+                })
+            }));
+        });
+    });
+
+    describe('remove', () => {
+        const remove_ctx = {
+            objectstore: mockObjectStore as unknown as IDBObjectStore,
+            key: 'testKey',
+        };
+
+        it('should remove an entry and resolve with the context', async () => {
+            mockObjectStore.delete.mockReturnValueOnce({
+                addEventListener: (event: string, callback: () => void) => {
+                    if (event === 'success') {
+                        callback();
+                    }
+                },
+            });
+            const result = await entryMethods.remove(remove_ctx) as { key: string };
+            expect(result.key).toBe('testKey');
+        });
+
+        it('should reject with an error if the request fails', async () => {
+            await expect(entryMethods.remove(remove_ctx)).rejects.toEqual(expect.objectContaining({
+                error: expect.objectContaining({
+                    message: "Request object is null",
+                    name: "DashRequestError"
+                })
+            }));
+        });
+    });
+
+    describe('count', () => {
+        const count_ctx = {
+            objectstore: mockObjectStore as unknown as IDBObjectStore,
+        };
+
+        it('should count entries and resolve with the context', async () => {
+            mockObjectStore.count.mockReturnValueOnce({
+                addEventListener: (event: string, callback: () => void) => {
+                    if (event === 'success') {
+                        callback();
+                    }
+                },
+                result: 42,
+            });
+            const result = await entryMethods.count(count_ctx) as { amount: number };
+            expect(result.amount).toBe(42);
+        });
+
+        it('should reject with an error if the request fails', async () => {
+            await expect(entryMethods.count(count_ctx)).rejects.toEqual(expect.objectContaining({
+                error: expect.objectContaining({
+                    message: "Request object is null",
+                    name: "DashRequestError"
+                })
+            }));
+        });
+    });
+
+    describe('entryMethods - additional tests', () => {
+        describe('add', () => {
+            const add_ctx = {
+                objectstore: { add: jest.fn(() => null) } as any,
+                data: { name: 'test' },
+                key: 'testKey',
+            };
+            
+            it('should reject with an error if request fails', async () => {
+                add_ctx.objectstore = { add: jest.fn(() => null) };
+                await expect(entryMethods.add(add_ctx)).rejects.toEqual(expect.objectContaining({
+                    error: expect.objectContaining({
+                        message: "Request object is null",
+                        name: "DashRequestError"
+                    })
+                }));
+            });
+        });
+    
+        describe('get', () => {
+            const get_ctx1 = {
+                objectstore: {
+                    index: jest.fn(() => null),
+                    get: jest.fn(() => null)
+                } as any,
+                key: 'testKey',
+                index: null,
+            };
+            
+            const get_ctx2 = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+                index: null,
+            };
+            
+            it('should reject with an error if the objectstore is null', async () => {
+                return await expect(entryMethods.get(get_ctx1)).rejects.toEqual(expect.objectContaining({
+                    error: expect.objectContaining({
+                        message: "Request object is null",
+                        name: "DashRequestError"
+                    })
+                }));
+            });
+    
+            it('should reject with an error if the index is invalid', async () => {
+                get_ctx1.objectstore = {
+                    index: jest.fn(() => null),
+                    get: jest.fn(() => null)
+                };
+                (get_ctx1 as any).index = 'invalidIndex';  // Casting to any if necessary
+                await expect(entryMethods.get(get_ctx1)).rejects.toEqual(expect.objectContaining({
+                    error: expect.objectContaining({
+                        message: "Invalid index or get method",
+                        name: "DashInvalidIndex"
+                    })
+                }));
+            });
+        });
+    
+        describe('remove', () => {
+            const remove_ctx = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+                key: 'testKey',
+            };
+    
+            it('should reject with an error if the request is null', async () => {
+                return await expect(entryMethods.remove(remove_ctx)).rejects.toEqual(expect.objectContaining({
+                    error: expect.objectContaining({
+                        message: "Request object is null",
+                        name: "DashRequestError"
+                    })
+                }));
+            });
+        });
+    
+        describe('count', () => {
+            const count_ctx = {
+                objectstore: mockObjectStore as unknown as IDBObjectStore,
+            };
+    
+            it('should reject with an error if the objectstore is null', async () => {
+                return await expect(entryMethods.count(count_ctx)).rejects.toEqual(expect.objectContaining({
+                    error: expect.objectContaining({
+                        message: "Request object is null",
+                        name: "DashRequestError"
+                    })
+                }));
+            });
+        });
+    });
+
+});

package/tests/index/index.spec.ts

@@ -0,0 +1,94 @@
+import { indexMethods } from '../../src/index/index';
+import { DashContext } from '../../src/utilities';
+
+describe('indexMethods', () => {
+  describe('get', () => {
+    it('should get an index and resolve with the entry', async () => {
+      const mockEntry = { id: 1, name: 'Test Entry' };
+      const mockRequest = {
+        result: mockEntry,
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'success') {
+            callback();
+          }
+        }),
+      };
+      const mockIndex = {
+        get: jest.fn(() => mockRequest),
+      };
+      const get_ctx: DashContext = {
+        idx: mockIndex as unknown as IDBIndex,
+        key: 'testKey',
+      };
+
+      const result = await indexMethods.get(get_ctx);
+
+      expect(mockIndex.get).toHaveBeenCalledWith('testKey');
+      expect((result as any).entry).toBe(mockEntry);
+    });
+
+    it('should reject with an error if the request fails', async () => {
+      const mockError = new Error('Test error');
+      const mockRequest = {
+        addEventListener: jest.fn((event, callback) => {
+          if (event === 'error') {
+            callback({ target: { error: mockError } });
+          }
+        }),
+      };
+      const mockIndex = {
+        get: jest.fn(() => mockRequest),
+      };
+      const get_ctx: DashContext = {
+        idx: mockIndex as unknown as IDBIndex,
+        key: 'testKey',
+      };
+
+      await expect(indexMethods.get(get_ctx)).rejects.toEqual(expect.objectContaining({
+        error: expect.any(Error),
+      }));
+    });
+  });
+
+  describe('remove', () => {
+    it('should remove an index and resolve', async () => {
+      const mockObjectStore = {
+        deleteIndex: jest.fn(),
+      };
+      const remove_ctx: DashContext = {
+        objectstore: mockObjectStore as unknown as IDBObjectStore,
+        key: 'testIndex',
+      };
+
+      await indexMethods.remove(remove_ctx);
+
+      expect(mockObjectStore.deleteIndex).toHaveBeenCalledWith('testIndex');
+    });
+  });
+
+  describe('getIndexes', () => {
+    it('should get all indexes and resolve with an array', async () => {
+      const mockIndexNames = ['index1', 'index2', 'index3'];
+      const mockObjectStore = {
+        indexNames: mockIndexNames,
+      };
+      const ctx: DashContext = {
+        objectstore: mockObjectStore as unknown as IDBObjectStore,
+      };
+
+      const result = await indexMethods.getIndexes(ctx);
+      
+      expect((result as { indexes: string[] }).indexes).toEqual(mockIndexNames);
+    });
+
+    it('should resolve with an empty array if there are no indexes', async () => {
+      const ctx: DashContext = {
+        objectstore: {} as IDBObjectStore,
+      };
+
+      const result = await indexMethods.getIndexes(ctx);
+      
+      expect((result as { indexes: string[] }).indexes).toEqual([]);
+    });
+  });
+});