holosphere 1.1.12 → 1.1.13

package/test/auth.test.js

@@ -1,275 +0,0 @@
-import HoloSphere from '../holosphere.js';
-import { jest } from '@jest/globals';
-
-// Increase timeout for all tests
-jest.setTimeout(30000);
-
-describe('HoloSphere Authentication and Authorization', () => {
-    let holoSphere;
-    let strictHoloSphere;
-    const testPassword = 'TestPass123!';
-    const testHolon = 'test-holon';
-    const testLens = 'test-lens';
-    const PUBLIC_GLOBAL_TABLE = 'publicTestTable'; // For public global data
-    const PRIVATE_GLOBAL_TABLE = 'veryPrivateGlobalTable'; // For all private global data tests
-
-    beforeAll(async () => {
-        holoSphere = new HoloSphere('test-app', false, null);
-        strictHoloSphere = new HoloSphere('test-app-strict', true, null);
-        // Wait for initialization
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    });
-
-    beforeEach(async () => {
-        // Clean state before each test
-        await holoSphere.deleteAll(testHolon, testLens);
-        await holoSphere.deleteAllGlobal(PUBLIC_GLOBAL_TABLE);
-        await holoSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
-        await new Promise(resolve => setTimeout(resolve, 100));
-    });
-
-    afterEach(async () => {
-        // Clean up test data
-        try {
-            if (holoSphere) {
-                await holoSphere.deleteAll(testHolon, testLens);
-            }
-            if (strictHoloSphere) {
-                await strictHoloSphere.deleteAll(testHolon, testLens);
-            }
-        } catch (error) {
-            console.error('Error in afterEach cleanup:', error);
-        }
-    });
-
-    afterAll(async () => {
-        // Clean up all test data
-        try {
-            if (holoSphere) {
-                await holoSphere.deleteAll(testHolon, testLens);
-                await holoSphere.deleteAllGlobal(PUBLIC_GLOBAL_TABLE);
-                await holoSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
-            }
-            if (strictHoloSphere) {
-                 await strictHoloSphere.deleteAll(testHolon, testLens);
-                await strictHoloSphere.deleteAllGlobal(PUBLIC_GLOBAL_TABLE);
-                await strictHoloSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
-            }
-        } catch (error) {
-            console.error('Error during afterAll data cleanup:', error);
-        }
-
-        // Close HoloSphere instances
-        try {
-            if (holoSphere) {
-                console.log('Closing non-strict HoloSphere instance...');
-                await holoSphere.close();
-                console.log('Non-strict HoloSphere instance closed.');
-            }
-            if (strictHoloSphere) {
-                console.log('Closing strict HoloSphere instance...');
-                await strictHoloSphere.close();
-                console.log('Strict HoloSphere instance closed.');
-            }
-        } catch (error) {
-             console.error('Error during afterAll close:', error);
-        }
-
-        // Add a slightly longer, more explicit wait after close calls
-        console.log('Waiting extra time for cleanup...');
-        await new Promise(resolve => setTimeout(resolve, 2000)); 
-        console.log('Finished afterAll.');
-    });
-
-    describe('Authentication System', () => {
-        it('should authenticate with password and handle auth failures', async () => {
-            const testData = { id: 'test1', value: 'private-data' };
-            
-            // Test storing with authentication
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            // Wait for data to be properly stored
-            await new Promise(resolve => setTimeout(resolve, 100));
-            
-            // Test retrieving with wrong password
-            const wrongResult = await holoSphere.get(testHolon, testLens, testData.id, 'wrong_password');
-            expect(wrongResult).toBeNull();
-            
-            // Test retrieving with no password
-            const noPassResult = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(noPassResult).toBeNull();
-            
-            // Test retrieving with correct password
-            const correctResult = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
-            expect(correctResult).toEqual(testData);  // Use full object comparison
-        });
-
-        it('should handle authentication errors gracefully', async () => {
-            const testData = { id: 'test2', value: 'private-data' };
-            
-            // Store data with correct password
-            await new Promise(resolve => setTimeout(resolve, 100)); // Added delay
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            
-            // Try to retrieve with wrong password
-            const result = await holoSphere.get(testHolon, testLens, testData.id, 'wrong_password');
-            expect(result).toBeNull();
-        }, 10000);
-    });
-
-    describe('Schema Validation', () => {
-        it('should only validate schema in strict mode', async () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    id: { type: 'string' },
-                    value: { type: 'number' }
-                },
-                required: ['id', 'value']
-            };
-            
-            // Set schema for both instances
-            await holoSphere.setSchema(testLens, schema);
-            await strictHoloSphere.setSchema(testLens, schema);
-            
-            const invalidData = { id: 'invalid' }; // Missing required 'value' field
-            
-            // Should work in non-strict mode
-            await expect(holoSphere.put(testHolon, testLens, invalidData)).resolves.toBeTruthy();
-            
-            // Should fail in strict mode
-            await expect(strictHoloSphere.put(testHolon, testLens, invalidData))
-                .rejects.toThrow('Schema validation failed');
-        }, 10000);
-
-        it('should require schema in strict mode', async () => {
-            const testData = { id: 'test', value: 123 };
-            
-            // Should work in non-strict mode without schema
-            await expect(holoSphere.put(testHolon, 'nonExistentLens', testData)).resolves.toBeTruthy();
-            
-            // Delete any existing schema for the lens
-            await strictHoloSphere.putGlobal('schemas', { id: 'nonExistentLens', schema: null });
-            
-            try {
-                // This should throw an error in strict mode
-                await strictHoloSphere.put(testHolon, 'nonExistentLens', testData);
-                // If we get here, the test should fail
-                expect('Expected an error').toBe('but none was thrown');
-            } catch (error) {
-                expect(error.message).toBe('Schema required in strict mode');
-            }
-        }, 10000);
-    });
-
-    describe('Private Data Operations', () => {
-        it('should store and retrieve private data with password', async () => {
-            const testData = { id: 'test3', value: 123 };
-            
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            
-            const result = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
-            expect(result).toEqual(testData);
-        });
-
-        it('should handle public data access', async () => {
-            const testData = { id: 'public', value: 456 };
-            
-            await holoSphere.put(testHolon, testLens, testData);
-            
-            const result = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(result).toEqual(testData);
-        });
-
-        it('should prevent unauthorized access to private data', async () => {
-            const testData = { id: 'private', value: 789 };
-            
-            // Store with password
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            
-            // Try to retrieve without password
-            const result = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(result).toBeNull();
-        });
-
-        it('should handle deletion of private data', async () => {
-            const testData = { id: 'delete', value: 101 };
-            
-            await holoSphere.put(testHolon, testLens, testData, testPassword);
-            await holoSphere.delete(testHolon, testLens, testData.id, testPassword);
-            
-            const result = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
-            expect(result).toBeNull();
-        });
-
-        it('should handle multiple private data versions', async () => {
-            const versions = [
-                { id: 'version1', value: 1 },
-                { id: 'version2', value: 2 },
-                { id: 'version3', value: 3 }
-            ];
-            
-            // Clean up any existing data first
-            await holoSphere.deleteAll(testHolon, testLens, testPassword);
-            
-            // Store each version
-            for (const data of versions) {
-                await holoSphere.put(testHolon, testLens, data, testPassword);
-            }
-            
-            // Wait a bit for data to settle
-            await new Promise(resolve => setTimeout(resolve, 1000));
-            
-            const results = await holoSphere.getAll(testHolon, testLens, testPassword);
-            expect(results.length).toBe(versions.length);
-            for (const version of versions) {
-                expect(results).toContainEqual(expect.objectContaining(version));
-            }
-        }, 10000);
-    });
-
-    describe('Global Data Operations', () => {
-        it('should handle private global data', async () => {
-            const testData = { id: 'globalPrivateItem', value: 111 };
-            await holoSphere.putGlobal(PRIVATE_GLOBAL_TABLE, testData, testPassword);
-            const result = await holoSphere.getGlobal(PRIVATE_GLOBAL_TABLE, testData.id, testPassword);
-            expect(result).toEqual(testData);
-        });
-
-        it('should handle public global data', async () => {
-            const testData = { id: 'publicGlobalItem', value: 222 };
-            await holoSphere.putGlobal(PUBLIC_GLOBAL_TABLE, testData);
-            const result = await holoSphere.getGlobal(PUBLIC_GLOBAL_TABLE, testData.id);
-            expect(result).toEqual(testData);
-        });
-
-        it('should handle getAllGlobal with private data', async () => {
-            const testData = [
-                { id: 'globalPrivate1', value: 1 },
-                { id: 'globalPrivate2', value: 2 }
-            ];
-            
-            // Clean up before this specific test (already done in beforeEach, but good for clarity)
-            // await holoSphere.deleteAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword); // This might be re-enabled later if tests pass without it
-            
-            for (const data of testData) {
-                await holoSphere.putGlobal(PRIVATE_GLOBAL_TABLE, data, testPassword);
-            }
-            
-            await new Promise(resolve => setTimeout(resolve, 1000)); // Settle time
-            
-            const results = await holoSphere.getAllGlobal(PRIVATE_GLOBAL_TABLE, testPassword);
-            expect(results.length).toBe(testData.length);
-            for (const data of testData) {
-                expect(results).toContainEqual(expect.objectContaining(data));
-            }
-        }, 10000);
-
-        it('should handle deleteGlobal with private data', async () => {
-            const testData = { id: 'deleteGlobalPrivate', value: 333 };
-            await holoSphere.putGlobal(PRIVATE_GLOBAL_TABLE, testData, testPassword);
-            await holoSphere.deleteGlobal(PRIVATE_GLOBAL_TABLE, testData.id, testPassword);
-            const result = await holoSphere.getGlobal(PRIVATE_GLOBAL_TABLE, testData.id, testPassword);
-            expect(result).toBeNull();
-        });
-    });
-}); 

package/test/delete.test.js

@@ -1,229 +0,0 @@
-import HoloSphere from '../holosphere.js';
-import { jest } from '@jest/globals';
-
-// Configure Jest
-jest.setTimeout(30000); // 30 second timeout
-
-// Utility to wait for GunDB propagation
-const waitForGun = (delay = 250) => new Promise(resolve => setTimeout(resolve, delay));
-
-describe('HoloSphere Deletion Tests', () => {
-    const testAppName = 'test-app-deletion';
-    const testHolon = 'testHolonDeletion';
-    const testLens = 'testLensDeletion';
-    const testGlobalTable = 'testGlobalTable';
-    const testPassword = 'testPassword1234';
-    let holoSphere;
-
-    beforeAll(async () => {
-        holoSphere = new HoloSphere(testAppName, false, null);
-    });
-
-    afterAll(async () => {
-        // Clean up all test data
-        await holoSphere.deleteAll(testHolon, testLens);
-        await holoSphere.deleteAllGlobal(testGlobalTable);
-        
-        // Close Gun connections
-        if (holoSphere) {
-            await holoSphere.close();
-        }
-        
-        // Wait for connections to close
-        await new Promise(resolve => setTimeout(resolve, 1000));
-    });
-
-    describe('Basic Deletion', () => {
-        test('should delete a single item properly', async () => {
-            // Create test data
-            const testData = { id: 'delete-test-1', value: 'delete me' };
-            
-            // Store data
-            await holoSphere.put(testHolon, testLens, testData);
-            
-            // Verify data exists
-            const storedData = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(storedData).toBeDefined();
-            expect(storedData.value).toBe(testData.value);
-            
-            // Delete data
-            const deleteResult = await holoSphere.delete(testHolon, testLens, testData.id);
-            expect(deleteResult).toBe(true);
-            
-            // Verify data is deleted
-            const deletedData = await holoSphere.get(testHolon, testLens, testData.id);
-            expect(deletedData).toBeNull();
-        });
-
-        test('should delete a node properly', async () => {
-            // Create test node data
-            const nodeData = { value: 'node-to-delete' };
-            const nodeKey = 'test-node-key';
-            
-            // Store node
-            await holoSphere.putNode(testHolon, testLens, { id: nodeKey, value: nodeData });
-            
-            // Verify node exists
-            const storedNode = await holoSphere.getNode(testHolon, testLens, 'value');
-            expect(storedNode).toBeDefined();
-            
-            // Delete node
-            const deleteResult = await holoSphere.deleteNode(testHolon, testLens, 'value');
-            expect(deleteResult).toBe(true);
-            
-            // Verify node is deleted
-            const deletedNode = await holoSphere.getNode(testHolon, testLens, 'value');
-            expect(deletedNode).toBeNull();
-        });
-    });
-
-    describe('Bulk Deletion', () => {
-        test('should delete all items in a lens', async () => {
-            // Create multiple test items
-            const items = [
-                { id: 'bulk-delete-1', value: 'bulk 1' },
-                { id: 'bulk-delete-2', value: 'bulk 2' },
-                { id: 'bulk-delete-3', value: 'bulk 3' }
-            ];
-            
-            // Store all items
-            for (const item of items) {
-                await holoSphere.put(testHolon, testLens, item);
-            }
-            
-            // Verify items exist
-            const allItems = await holoSphere.getAll(testHolon, testLens);
-            expect(allItems.length).toBeGreaterThanOrEqual(items.length);
-            
-            // Delete all items
-            const deleteAllResult = await holoSphere.deleteAll(testHolon, testLens);
-            expect(deleteAllResult).toBe(true);
-            
-            // Verify all items are deleted
-            const remainingItems = await holoSphere.getAll(testHolon, testLens);
-            expect(remainingItems.length).toBe(0);
-        });
-    });
-
-    describe('Global Table Deletion', () => {
-        test('should delete global items properly', async () => {
-            // Create global test data
-            const globalData = { id: 'global-delete-test', value: 'global delete me' };
-
-            // 1. Store global data
-            await holoSphere.putGlobal(testGlobalTable, globalData);
-
-            // 2. Wait significantly for put to settle
-            await waitForGun(1500); // Generous wait after put
-
-            // 3. Delete global data
-            const deleteResult = await holoSphere.deleteGlobal(testGlobalTable, globalData.id);
-            expect(deleteResult).toBe(true);
-
-            // 4. Wait for delete to settle
-            await waitForGun(500); // Wait after delete
-
-            // 5. Verify global data is deleted
-            const deletedGlobalData = await holoSphere.getGlobal(testGlobalTable, globalData.id);
-            expect(deletedGlobalData).toBeNull();
-        });
-
-        test('should delete all global items in a table', async () => {
-            // Create multiple global test items
-            const items = [
-                { id: 'global-bulk-1', value: 'global bulk 1' },
-                { id: 'global-bulk-2', value: 'global bulk 2' },
-                { id: 'global-bulk-3', value: 'global bulk 3' }
-            ];
-            
-            // Store all global items
-            for (const item of items) {
-                await holoSphere.putGlobal(testGlobalTable, item);
-            }
-            
-            // Verify global items exist
-            const allGlobalItems = await holoSphere.getAllGlobal(testGlobalTable);
-            expect(allGlobalItems.length).toBeGreaterThanOrEqual(items.length);
-            
-            // Delete all global items
-            const deleteAllResult = await holoSphere.deleteAllGlobal(testGlobalTable);
-            expect(deleteAllResult).toBe(true);
-            
-            // Verify all global items are deleted
-            const remainingGlobalItems = await holoSphere.getAllGlobal(testGlobalTable);
-            expect(remainingGlobalItems.length).toBe(0);
-        });
-    });
-
-    describe('Private Data Deletion', () => {
-        test('should delete private data properly', async () => {
-            // Create private test data
-            const privateData = { id: 'private-delete-test', value: 'private delete me' };
-            
-            // Store private data
-            await holoSphere.put(testHolon, testLens, privateData, testPassword);
-            
-            // Verify private data exists
-            const storedPrivateData = await holoSphere.get(testHolon, testLens, privateData.id, testPassword);
-            expect(storedPrivateData).toBeDefined();
-            expect(storedPrivateData.value).toBe(privateData.value);
-            
-            // Delete private data
-            const deleteResult = await holoSphere.delete(testHolon, testLens, privateData.id, testPassword);
-            expect(deleteResult).toBe(true);
-            
-            // Verify private data is deleted
-            const deletedPrivateData = await holoSphere.get(testHolon, testLens, privateData.id, testPassword);
-            expect(deletedPrivateData).toBeNull();
-        });
-
-        test('should delete all private items in a lens', async () => {
-            // Create multiple private test items
-            const items = [
-                { id: 'private-bulk-1', value: 'private bulk 1' },
-                { id: 'private-bulk-2', value: 'private bulk 2' },
-                { id: 'private-bulk-3', value: 'private bulk 3' }
-            ];
-            
-            // Store all private items
-            for (const item of items) {
-                await holoSphere.put(testHolon, testLens, item, testPassword);
-            }
-            
-            // Verify private items exist
-            const allPrivateItems = await holoSphere.getAll(testHolon, testLens, testPassword);
-            expect(allPrivateItems.length).toBeGreaterThanOrEqual(items.length);
-            
-            // Delete all private items
-            const deleteAllResult = await holoSphere.deleteAll(testHolon, testLens, testPassword);
-            expect(deleteAllResult).toBe(true);
-            
-            // Verify all private items are deleted
-            const remainingPrivateItems = await holoSphere.getAll(testHolon, testLens, testPassword);
-            expect(remainingPrivateItems.length).toBe(0);
-        });
-    });
-
-    describe('Edge Cases', () => {
-        test('should handle deletion of non-existent items gracefully', async () => {
-            // Try to delete non-existent item
-            const deleteResult = await holoSphere.delete(testHolon, testLens, 'non-existent-id');
-            expect(deleteResult).toBe(true); // Gun returns success even for non-existent items
-            
-            // Try to delete non-existent global item
-            const deleteGlobalResult = await holoSphere.deleteGlobal(testGlobalTable, 'non-existent-global-id');
-            expect(deleteGlobalResult).toBe(true);
-        });
-
-        test('should handle invalid parameters gracefully', async () => {
-            // Test with missing parameters
-            await expect(holoSphere.delete(null, testLens, 'test-id')).rejects.toThrow();
-            await expect(holoSphere.delete(testHolon, null, 'test-id')).rejects.toThrow();
-            await expect(holoSphere.delete(testHolon, testLens, null)).rejects.toThrow();
-            
-            // Test with missing global parameters
-            await expect(holoSphere.deleteGlobal(null, 'test-id')).rejects.toThrow();
-            await expect(holoSphere.deleteGlobal(testGlobalTable, null)).rejects.toThrow();
-        });
-    });
-});