holosphere 1.1.3 → 1.1.5

package/test/federation.test.js

@@ -1,9 +1,8 @@
 import HoloSphere from '../holosphere.js';
-import * as h3 from 'h3-js';
 import { jest } from '@jest/globals';
 
 // Set global timeout for all tests
-jest.setTimeout(30000);
+jest.setTimeout(3000);
 
 describe('Federation Operations', () => {
     const testAppName = 'test-app';
@@ -28,8 +27,6 @@ describe('Federation Operations', () => {
             await holoSphere.deleteAllGlobal('federation');
             await holoSphere.deleteGlobal('spaces', space1.spacename);
             await holoSphere.deleteGlobal('spaces', space2.spacename);
-            // Wait for cleanup
-            await new Promise(resolve => setTimeout(resolve, 2000));
         } catch (error) {
             // Ignore errors during cleanup
             console.log('Cleanup error (expected):', error.message);
@@ -44,12 +41,9 @@ describe('Federation Operations', () => {
             } catch (error) {
                 console.log('Space creation attempt', i + 1, 'failed:', error.message);
                 if (i === 2) throw error;
-                await new Promise(resolve => setTimeout(resolve, 2000));
             }
         }
 
-        // Wait for space creation to complete
-        await new Promise(resolve => setTimeout(resolve, 5000));
 
         // Verify spaces were created
         const space1Created = await holoSphere.getGlobal('spaces', space1.spacename);
@@ -58,9 +52,6 @@ describe('Federation Operations', () => {
         if (!space1Created || !space2Created) {
             throw new Error('Failed to create test spaces');
         }
-
-        // Wait for everything to settle
-        await new Promise(resolve => setTimeout(resolve, 2000));
     }, 30000);
 
     beforeEach(async () => {
@@ -91,9 +82,7 @@ describe('Federation Operations', () => {
         await holoSphere.setSchema(testLens, baseSchema);
         await strictHoloSphere.setSchema(testLens, baseSchema);
         
-        // Wait for schema to be set
-        await new Promise(resolve => setTimeout(resolve, 1000));
-        
+    
         // Verify spaces exist before proceeding
         const space1Exists = await holoSphere.getGlobal('spaces', space1.spacename);
         const space2Exists = await holoSphere.getGlobal('spaces', space2.spacename);
@@ -102,7 +91,6 @@ describe('Federation Operations', () => {
         if (!space1Exists) {
             try {
                 await holoSphere.createSpace(space1.spacename, space1.password);
-                await new Promise(resolve => setTimeout(resolve, 2000));
             } catch (error) {
                 if (error.message !== 'Space already exists') {
                     throw error;
@@ -112,7 +100,6 @@ describe('Federation Operations', () => {
         if (!space2Exists) {
             try {
                 await holoSphere.createSpace(space2.spacename, space2.password);
-                await new Promise(resolve => setTimeout(resolve, 2000));
             } catch (error) {
                 if (error.message !== 'Space already exists') {
                     throw error;
@@ -120,9 +107,6 @@ describe('Federation Operations', () => {
             }
         }
         
-        // Wait for space creation to complete
-        await new Promise(resolve => setTimeout(resolve, 2000));
-        
         // Verify spaces again
         const space1Verified = await holoSphere.getGlobal('spaces', space1.spacename);
         const space2Verified = await holoSphere.getGlobal('spaces', space2.spacename);
@@ -142,17 +126,12 @@ describe('Federation Operations', () => {
         // Login as first space to holoSphere
         await holoSphere.login(space1.spacename, space1.password);
         
-        // Wait for login to complete
-        await new Promise(resolve => setTimeout(resolve, 2000));
     }, 20000);
 
     test('should create federation relationship between spaces', async () => {
         // Create federation relationship
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 1000));
-
         // Verify federation was created
         const fedInfo = await holoSphere.getFederation(space1.spacename);
         expect(fedInfo).toBeDefined();
@@ -163,9 +142,6 @@ describe('Federation Operations', () => {
         // Create bidirectional federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 2000));
-
         // Login to space1 to verify federation
         await holoSphere.login(space1.spacename, space1.password);
 
@@ -186,9 +162,6 @@ describe('Federation Operations', () => {
         // Create initial federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 3000));
-
         // Verify federation exists
         const fedInfo = await holoSphere.getFederation(space1.spacename);
         expect(fedInfo).toBeDefined();
@@ -213,18 +186,12 @@ describe('Federation Operations', () => {
         // Set up federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Login to space2 with strict instance
         await strictHoloSphere.login(space2.spacename, space2.password);
 
         // Put data in first space
         await holoSphere.put(testHolon, testLens, testData);
 
-        // Wait for propagation
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Verify data was propagated to federated space
         const federatedData = await strictHoloSphere.get(testHolon, testLens, testData.id);
         expect(federatedData).toBeDefined();
@@ -239,9 +206,6 @@ describe('Federation Operations', () => {
         // Clean up any existing test data first
         await holoSphere.deleteAll(testHolon, testLens);
         await strictHoloSphere.deleteAll(testHolon, testLens);
-        
-        // Wait for cleanup to complete
-        await new Promise(resolve => setTimeout(resolve, 5000));
 
         // Set up federation using non-strict instance (already logged in as space1)
         await holoSphere.federate(space1.spacename, space2.spacename);
@@ -249,9 +213,6 @@ describe('Federation Operations', () => {
         // Login to space2 with strict instance
         await strictHoloSphere.login(space2.spacename, space2.password);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Test data with overlapping IDs and different fields
         const testData1 = { 
             id: 'user1', 
@@ -281,18 +242,13 @@ describe('Federation Operations', () => {
         // Put data using both instances and wait between puts
         console.log('Putting test data 1:', JSON.stringify(testData1, null, 2));
         await holoSphere.put(testHolon, testLens, testData1);
-        await new Promise(resolve => setTimeout(resolve, 5000));
         
         console.log('Putting test data 2:', JSON.stringify(testData2, null, 2));
         await strictHoloSphere.put(testHolon, testLens, testData2);
-        await new Promise(resolve => setTimeout(resolve, 5000));
         
         console.log('Putting test data 3:', JSON.stringify(testData3, null, 2));
         await holoSphere.put(testHolon, testLens, testData3);
 
-        // Wait longer for data propagation
-        await new Promise(resolve => setTimeout(resolve, 10000));
-
         // Test 1: Simple concatenation without deduplication
         const concatenatedResults = await holoSphere.getFederated(testHolon, testLens, {
             aggregate: false,
@@ -352,9 +308,6 @@ describe('Federation Operations', () => {
         // Set up federation
         await holoSphere.federate(space1.spacename, space2.spacename);
 
-        // Wait for federation to be established
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Verify federation exists
         let fedInfo1 = await holoSphere.getFederation(space1.spacename);
         expect(fedInfo1).toBeDefined();
@@ -364,9 +317,6 @@ describe('Federation Operations', () => {
         // Remove federation
         await holoSphere.unfederate(space1.spacename, space2.spacename);
 
-        // Wait for unfederation to complete
-        await new Promise(resolve => setTimeout(resolve, 5000));
-
         // Verify federation is removed
         fedInfo1 = await holoSphere.getFederation(space1.spacename);
         const fedInfo2 = await holoSphere.getFederation(space2.spacename);
@@ -391,9 +341,6 @@ describe('Federation Operations', () => {
         if (strictHoloSphere.currentSpace) {
             await strictHoloSphere.logout();
         }
-        
-        // Wait for cleanup
-        await new Promise(resolve => setTimeout(resolve, 1000));
     });
 
     afterAll(async () => {
@@ -401,8 +348,6 @@ describe('Federation Operations', () => {
         try {
             await holoSphere.deleteGlobal('spaces', space1.spacename);
             await holoSphere.deleteGlobal('spaces', space2.spacename);
-            // Wait for cleanup
-            await new Promise(resolve => setTimeout(resolve, 1000));
         } catch (error) {
             console.error('Error during final cleanup:', error.message);
         }

package/test/holosphere.test.js

@@ -7,10 +7,13 @@ describe('HoloSphere', () => {
         spacename: 'testuser',
         password: 'testpass'
     };
-    let holoSphere = new HoloSphere(testAppName, false);
+    let holoSphere;
+    let strictHoloSphere;
+
     beforeAll(async () => {
-        // Initialize HoloSphere once for all tests
-       
+        // Initialize HoloSphere instances once for all tests
+        holoSphere = new HoloSphere(testAppName, false);
+        strictHoloSphere = new HoloSphere(testAppName, true);
         
         // Set up test space and authenticate
         try {
@@ -26,15 +29,9 @@ describe('HoloSphere', () => {
             }
         }
         
-        // Ensure we're logged in
+        // Ensure both instances are logged in
         await holoSphere.login(testCredentials.spacename, testCredentials.password);
-    });
-
-    beforeEach(async () => {
-        // Ensure we're logged in before each test
-        if (!holoSphere.currentSpace || holoSphere.currentSpace.exp < Date.now()) {
-            await holoSphere.login(testCredentials.spacename, testCredentials.password);
-        }
+        await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
     });
 
     describe('Constructor', () => {
@@ -45,11 +42,8 @@ describe('HoloSphere', () => {
             expect(holoSphere.openai).toBeUndefined();
         });
 
-        test('should initialize with OpenAI when key provided', () => {
-            const hsWithAI = new HoloSphere(testAppName, false, 'fake-key');
-            expect(hsWithAI.openai).toBeDefined();
-            // Clean up additional instance
-            if (hsWithAI.gun) hsWithAI.gun.off();
+        test('should initialize with OpenAI', () => {
+            expect(new HoloSphere(testAppName, false, 'fake-key').openai).toBeDefined();
         });
     });
 
@@ -65,10 +59,8 @@ describe('HoloSphere', () => {
         };
 
         beforeEach(async () => {
-            // Ensure we're logged in before each schema test
-            if (!holoSphere.currentSpace || holoSphere.currentSpace.exp < Date.now()) {
-                await holoSphere.login(testCredentials.spacename, testCredentials.password);
-            }
+            // Clean up any existing schemas
+            await holoSphere.deleteAllGlobal('schemas');
         });
 
         test('should set and get schema', async () => {
@@ -84,11 +76,6 @@ describe('HoloSphere', () => {
         });
 
         test('should enforce strict mode schema validation', async () => {
-            const strictHoloSphere = new HoloSphere(testAppName, true);
-            
-            // Login to the strict instance
-            await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
-            
             const invalidSchema = {
                 type: 'object',
                 properties: {
@@ -98,9 +85,6 @@ describe('HoloSphere', () => {
 
             await expect(strictHoloSphere.setSchema(testLens, invalidSchema))
                 .rejects.toThrow();
-
-            // Clean up
-            await strictHoloSphere.logout();
         });
 
         test('should handle schema retrieval for non-existent lens', async () => {
@@ -110,10 +94,6 @@ describe('HoloSphere', () => {
 
         test('should maintain schema integrity across storage and retrieval', async () => {
             const testLens = 'schemaTestLens';
-            const strictHoloSphere = new HoloSphere(testAppName, true); 
-            
-            // Login to the strict instance
-            await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
             
             // Create test schemas of increasing complexity
             const testSchemas = [
@@ -151,9 +131,6 @@ describe('HoloSphere', () => {
 
                 // Store schema
                 await strictHoloSphere.setSchema(testLensWithIndex, schema);
-                
-                // Add delay to ensure schema is stored
-                await new Promise(resolve => setTimeout(resolve, 100));
 
                 // Retrieve schema
                 const retrievedSchema = await strictHoloSphere.getSchema(testLensWithIndex);
@@ -189,18 +166,8 @@ describe('HoloSphere', () => {
 
                 // Clean up after each schema test
                 await strictHoloSphere.deleteAll('testHolon', testLensWithIndex);
-                await strictHoloSphere.gun.get(strictHoloSphere.appname)
-                    .get(testLensWithIndex)
-                    .get('schema')
-                    .put(null);
-            }
-
-            // Clean up the strict instance
-            if (strictHoloSphere.gun) {
-                await strictHoloSphere.logout();
-                await new Promise(resolve => setTimeout(resolve, 100)); // Allow time for cleanup
             }
-        }, 10000); // Increase timeout to 10 seconds
+        }, 10000);
 
         test('should handle concurrent schema operations', async () => {
             const baseLens = 'concurrentSchemaTest';
@@ -220,16 +187,12 @@ describe('HoloSphere', () => {
                     required: ['id', 'value']
                 };
                 expectedSchemas.push({ lens, schema });
-                // Add small delay between operations to prevent race conditions
-                await new Promise(resolve => setTimeout(resolve, 50));
                 promises.push(holoSphere.setSchema(lens, schema));
             }
 
             // Wait for all operations to complete
             await Promise.all(promises);
 
-            // Add delay before verification to ensure data is settled
-            await new Promise(resolve => setTimeout(resolve, 500));
 
             // Verify each schema was stored correctly
             for (const { lens, schema } of expectedSchemas) {
@@ -279,10 +242,7 @@ describe('HoloSphere', () => {
 
         afterEach(async () => {
             // Clean up schemas after each test
-            await holoSphere.gun.get(holoSphere.appname)
-                    .get(testLens)
-                    .get('schema')
-                    .put(null);
+            await holoSphere.deleteAllGlobal('schemas');
         });
     });
 
@@ -362,11 +322,6 @@ describe('HoloSphere', () => {
         });
 
         test('should enforce strict mode data validation', async () => {
-            const strictHoloSphere = new HoloSphere(testAppName, true);
-            
-            // Login to the strict instance
-            await strictHoloSphere.login(testCredentials.spacename, testCredentials.password);
-            
             // Define schema for strict mode tests
             const strictSchema = {
                 type: 'object',
@@ -383,9 +338,6 @@ describe('HoloSphere', () => {
             // Try to put data without schema in strict mode
             await expect(strictHoloSphere.put(testHolon, 'no-schema-lens', validData))
                 .rejects.toThrow('Schema required in strict mode');
-
-            // Clean up
-            await strictHoloSphere.logout();
         });
 
         test('should maintain content integrity in holon storage', async () => {
@@ -480,9 +432,6 @@ describe('HoloSphere', () => {
                 await holoSphere.put(testHolon, testLens, storeData);
             }
 
-            // Wait a bit to ensure data is settled
-            await new Promise(resolve => setTimeout(resolve, 100));
-
             // Get data multiple times
             const results = await Promise.all(
                 Array.from({ length: 5 }, () => holoSphere.getAll(testHolon, testLens))
@@ -671,27 +620,33 @@ describe('HoloSphere', () => {
         test('should stop receiving data after unsubscribe', async () => {
             const testData1 = { id: 'test1', data: 'first' };
             const testData2 = { id: 'test2', data: 'second' };
-            let received = false;
+            let receivedData = [];
 
-            const subscription = await holoSphere.subscribe(testHolon, testLens, async (data) => {
-                if (!received && data.id === testData1.id) {
-                    received = true;
-                    await subscription.off();
-                    
-                    // Put second piece of data after unsubscribe
-                    await holoSphere.put(testHolon, testLens, testData2);
+            return new Promise(async (resolve, reject) => {
+                const timeout = setTimeout(() => {
+                    // If we only received the first piece of data, test passes
+                    if (receivedData.length === 1 && receivedData[0].id === testData1.id) {
+                        resolve();
+                    } else {
+                        reject(new Error('Test timeout or received unexpected data'));
+                    }
+                }, 5000);
+
+                const subscription = await holoSphere.subscribe(testHolon, testLens, async (data) => {
+                    receivedData.push(data);
                     
-                    // Wait a bit to ensure no more data is received
-                    setTimeout(() => {
-                        expect(received).toBe(true);
-                    }, 1000);
-                } else if (data.id === testData2.id) {
-                    throw new Error('Received data after unsubscribe');
-                }
-            });
+                    if (data.id === testData1.id) {
+                        subscription.unsubscribe();
+                        resolve();
+                    } else if (data.id === testData2.id) {
+                        clearTimeout(timeout);
+                        reject(new Error('Received data after unsubscribe'));
+                    }
+                });
 
-            // Put first piece of data
-            await holoSphere.put(testHolon, testLens, testData1);
+                // Put first piece of data
+                await holoSphere.put(testHolon, testLens, testData1);
+            });
         }, 10000);
 
         test('should handle multiple subscriptions', async () => {
@@ -846,16 +801,13 @@ describe('HoloSphere', () => {
             for (let i = 0; i < numOperations; i++) {
                 const data = { id: `concurrent${i}`, value: `value${i}` };
                 expectedData.push(data);
-                // Add small delay between operations
-                await new Promise(resolve => setTimeout(resolve, 50));
                 promises.push(holoSphere.putGlobal(testTable, data));
             }
 
             // Wait for all operations to complete
             await Promise.all(promises);
 
-            // Add delay before verification
-            await new Promise(resolve => setTimeout(resolve, 500));
+
 
             // Retrieve and verify data
             const retrievedData = await holoSphere.getAllGlobal(testTable);
@@ -908,24 +860,31 @@ describe('HoloSphere', () => {
 
         test('should validate holon resolution', async () => {
             const invalidHolon = h3.latLngToCell(40.7128, -74.0060, 0); // Resolution 0
-            await expect(holoSphere.compute(invalidHolon, testLens, 'summarize'))
+            await expect(holoSphere.compute(invalidHolon, testLens, { operation: 'summarize' }))
                 .rejects.toThrow('compute: Invalid holon resolution (must be between 1 and 15)');
         });
 
         test('should validate depth parameters', async () => {
-            await expect(holoSphere.compute(testHolon, testLens, 'summarize', -1))
-                .rejects.toThrow('compute: Invalid depth parameter');
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                depth: -1
+            })).rejects.toThrow('compute: Invalid depth parameter');
 
-            await expect(holoSphere.compute(testHolon, testLens, 'summarize', 0, 0))
-                .rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                maxDepth: 0
+            })).rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
 
-            await expect(holoSphere.compute(testHolon, testLens, 'summarize', 0, 16))
-                .rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'summarize',
+                maxDepth: 16
+            })).rejects.toThrow('compute: Invalid maxDepth parameter (must be between 1 and 15)');
         });
 
         test('should validate operation type', async () => {
-            await expect(holoSphere.compute(testHolon, testLens, 'invalid-operation'))
-                .rejects.toThrow('compute: Invalid operation (must be "summarize")');
+            await expect(holoSphere.compute(testHolon, testLens, {
+                operation: 'invalid-operation'
+            })).rejects.toThrow('compute: Invalid operation (must be one of summarize, aggregate, concatenate)');
         });
 
         afterEach(async () => {
@@ -967,8 +926,6 @@ describe('HoloSphere', () => {
             for (let i = 0; i < numOperations; i++) {
                 const id = `concurrent${i}`;
                 expectedIds.add(id);
-                // Add small delay between operations to prevent race conditions
-                await new Promise(resolve => setTimeout(resolve, 50));
                 promises.push(holoSphere.put(testHolon, testLens, { 
                     id: id, 
                     data: 'test' 
@@ -978,9 +935,6 @@ describe('HoloSphere', () => {
             // Wait for all operations to complete
             await Promise.all(promises);
 
-            // Add delay before verification to ensure data is settled
-            await new Promise(resolve => setTimeout(resolve, 500));
-
             // Get and verify results
             const results = await holoSphere.getAll(testHolon, testLens);
             const resultIds = new Set(results.map(r => r.id));
@@ -1020,14 +974,13 @@ describe('HoloSphere', () => {
 
     describe('OpenAI Integration', () => {
         test('should handle missing OpenAI key', async () => {
-            const noAIHoloSphere = new HoloSphere('test');
-            const result = await noAIHoloSphere.summarize('test content');
-            expect(result).toBe('OpenAI not initialized, please specify the API key in the constructor.');
+            expect(await holoSphere.summarize('test content'))
+                .toBe('OpenAI not initialized, please specify the API key in the constructor.');
         });
 
         test.skip('should summarize content with valid OpenAI key', async () => {
-            const hsWithAI = new HoloSphere('test', false, process.env.OPENAI_API_KEY);
-            const summary = await hsWithAI.summarize('Test content to summarize');
+            const summary = await new HoloSphere('test', false, process.env.OPENAI_API_KEY)
+                .summarize('Test content to summarize');
             expect(typeof summary).toBe('string');
             expect(summary.length).toBeGreaterThan(0);
         });
@@ -1043,13 +996,21 @@ describe('HoloSphere', () => {
         await holoSphere.deleteAllGlobal('testTable');
         await holoSphere.deleteAllGlobal('testGlobalTable');
         await holoSphere.deleteAllGlobal('concurrentGlobalTest');
+        await holoSphere.deleteAllGlobal('schemas');
         
         // Clean up test space
         await holoSphere.deleteGlobal('spaces', testCredentials.spacename);
         
-        // Logout
+        // Logout both instances
         if (holoSphere.currentSpace) {
             await holoSphere.logout();
         }
+        if (strictHoloSphere.currentSpace) {
+            await strictHoloSphere.logout();
+        }
+
+        // Clean up Gun instances
+        if (holoSphere.gun) holoSphere.gun.off();
+        if (strictHoloSphere.gun) strictHoloSphere.gun.off();
     });
 }); 

package/test/jest.setup.js

@@ -0,0 +1,5 @@
+
+// Mock process.env
+process.env.OPENWEATHER_API_KEY = 'test-api-key';
+process.env.ETHERSCAN_API_KEY = 'test-api-key';
+process.env.NOAA_API_KEY = 'test-api-key'; 

package/test/spacesauth.test.js

@@ -1,7 +1,5 @@
 import HoloSphere from '../holosphere.js';
 import * as h3 from 'h3-js';
-import Gun from 'gun';
-import 'gun/sea';
 
 describe('Space Authentication and Authorization', () => {
     // Global HoloSphere instances