holosphere 1.1.5 → 1.1.7

package/test/auth.test.js

@@ -0,0 +1,241 @@
+import Gun from 'gun';
+import HoloSphere from '../holosphere.js';
+import * as h3 from 'h3-js';
+import { jest } from '@jest/globals';
+
+// Increase timeout for all tests
+jest.setTimeout(3000);
+
+describe('HoloSphere Authentication and Authorization', () => {
+    let holoSphere;
+    let strictHoloSphere;
+    const testPassword = 'TestPass123!';
+    const testHolon = 'test-holon';
+    const testLens = 'test-lens';
+
+    beforeAll(async () => {
+        holoSphere = new HoloSphere('test-app', false, null);
+        strictHoloSphere = new HoloSphere('test-app-strict', true, null);
+    });
+
+    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
+        await holoSphere.deleteAll(testHolon, testLens);
+        await holoSphere.deleteAllGlobal('testTable');
+        
+        // Close Gun connections
+        if (holoSphere.gun) {
+            holoSphere.gun.off();
+        }
+        if (strictHoloSphere.gun) {
+            strictHoloSphere.gun.off();
+        }
+        
+        // Wait for connections to close
+        await new Promise(resolve => setTimeout(resolve, 1000));
+    });
+
+    describe('Authentication System', () => {
+        it('should authenticate with password and store/retrieve data', async () => {
+            const testData = { id: 'test1', value: 'private-data' };
+            
+            // Test storing with authentication
+            await holoSphere.put(testHolon, testLens, testData, testPassword);
+            
+            // Test retrieving with authentication
+            const result = await holoSphere.get(testHolon, testLens, testData.id, testPassword);
+            expect(result).toBeDefined();
+            expect(result.value).toBe(testData.value);
+        });
+
+        it('should handle authentication errors gracefully', async () => {
+            const testData = { id: 'test2', value: 'private-data' };
+            
+            // Store data with correct password
+            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, testLens, testData)).resolves.toBeTruthy();
+            
+            // Delete any existing schema
+            await strictHoloSphere.putGlobal('schemas', { id: testLens, schema: null });
+            
+            // Should fail in strict mode without schema
+            try {
+                await strictHoloSphere.put(testHolon, testLens, testData);
+                fail('Should have thrown an error');
+            } 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: 'global', value: 111 };
+            
+            await holoSphere.putGlobal('testTable', testData, testPassword);
+            
+            const result = await holoSphere.getGlobal('testTable', testData.id, testPassword);
+            expect(result).toEqual(testData);
+        });
+
+        it('should handle public global data', async () => {
+            const testData = { id: 'public_global', value: 222 };
+            
+            await holoSphere.putGlobal('testTable', testData);
+            
+            const result = await holoSphere.getGlobal('testTable', testData.id);
+            expect(result).toEqual(testData);
+        });
+
+        it('should handle getAllGlobal with private data', async () => {
+            const testData = [
+                { id: 'global1', value: 1 },
+                { id: 'global2', value: 2 }
+            ];
+            
+            // Clean up any existing data first
+            await holoSphere.deleteAllGlobal('testTable', testPassword);
+            
+            // Store each item
+            for (const data of testData) {
+                await holoSphere.putGlobal('testTable', data, testPassword);
+            }
+            
+            // Wait a bit for data to settle
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            
+            const results = await holoSphere.getAllGlobal('testTable', 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: 'delete_global', value: 333 };
+            
+            await holoSphere.putGlobal('testTable', testData, testPassword);
+            
+            await holoSphere.deleteGlobal('testTable', testData.id, testPassword);
+            
+            const result = await holoSphere.getGlobal('testTable', testData.id, testPassword);
+            expect(result).toBeNull();
+        });
+    });
+}); 

package/test/delete.test.js

@@ -0,0 +1,225 @@
+import HoloSphere from '../holosphere.js';
+import { jest } from '@jest/globals';
+
+// Configure Jest
+jest.setTimeout(30000); // 30 second timeout
+
+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' };
+            
+            // Store global data
+            await holoSphere.putGlobal(testGlobalTable, globalData);
+            
+            // Verify global data exists
+            const storedGlobalData = await holoSphere.getGlobal(testGlobalTable, globalData.id);
+            expect(storedGlobalData).toBeDefined();
+            expect(storedGlobalData.value).toBe(globalData.value);
+            
+            // Delete global data
+            const deleteResult = await holoSphere.deleteGlobal(testGlobalTable, globalData.id);
+            expect(deleteResult).toBe(true);
+            
+            // 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();
+        });
+    });
+});