holosphere 1.1.10 → 1.1.12

package/test/federation.test.js

@@ -88,6 +88,135 @@ describe('Federation Tests', () => {
       await expect(holosphere.federate(space, space, null))
         .rejects.toThrow('Cannot federate a space with itself');
     });
+
+    test('should create a federation with lens-specific settings', async () => {
+      const space1 = `${testPrefix}lens_space1`;
+      const space2 = `${testPrefix}lens_space2`;
+      
+      // Create federation with specific lens configuration
+      const lensConfig = {
+        federate: ['quests', 'announcements'],
+        notify: ['quests']
+      };
+      
+      const result = await holosphere.federate(space1, space2, null, null, true, lensConfig);
+      expect(result).toBe(true);
+      
+      // Verify federation info contains lens configuration
+      const fedInfo = await holosphere.getFederation(space1);
+      expect(fedInfo).toBeTruthy();
+      expect(fedInfo.lensConfig).toBeTruthy();
+      expect(fedInfo.lensConfig[space2]).toBeTruthy();
+      expect(fedInfo.lensConfig[space2].federate).toEqual(['quests', 'announcements']);
+      expect(fedInfo.lensConfig[space2].notify).toEqual(['quests']);
+    });
+
+    test('should respect lens configuration during propagation', async () => {
+      const space1 = `${testPrefix}prop_space1`;
+      const space2 = `${testPrefix}prop_space2`;
+      
+      // Create federation with specific lens configuration
+      const lensConfig = {
+        federate: ['quests', 'announcements'],
+        notify: ['quests']
+      };
+      
+      await holosphere.federate(space1, space2, null, null, true, lensConfig);
+      
+      // Test propagation for allowed lens
+      const questData = { id: 'test-quest', title: 'Test Quest' };
+      const questResult = await holosphere.propagate(space1, 'quests', questData);
+      expect(questResult.success).toBe(1); // Should propagate
+      
+      // Test propagation for non-allowed lens
+      const shoppingData = { id: 'test-shopping', item: 'Test Item' };
+      const shoppingResult = await holosphere.propagate(space1, 'shopping', shoppingData);
+      expect(shoppingResult.success).toBe(0); // Should not propagate
+      expect(shoppingResult.message).toContain("Propagation of lens 'shopping' to target space " + space2 + " skipped: lens not in 'federate' configuration.");
+    });
+
+    test('should handle wildcard lens configuration', async () => {
+      const space1 = `${testPrefix}wild_space1`;
+      const space2 = `${testPrefix}wild_space2`;
+      
+      // Create federation with wildcard lens configuration
+      const lensConfig = {
+        federate: ['*'],
+        notify: ['quests', 'announcements']
+      };
+      
+      await holosphere.federate(space1, space2, null, null, true, lensConfig);
+      
+      // Test propagation for various lenses
+      const testData = { id: 'test-item', value: 'test' };
+      
+      // Should propagate for quests (in notify list)
+      const questResult = await holosphere.propagate(space1, 'quests', testData);
+      expect(questResult.success).toBe(1);
+      
+      // Should propagate for announcements (in notify list)
+      const announcementResult = await holosphere.propagate(space1, 'announcements', testData);
+      expect(announcementResult.success).toBe(1);
+      
+      // Should now propagate for other lenses because federate is ['*'] and space2 is in space1's notify list.
+      const otherResult = await holosphere.propagate(space1, 'shopping', testData);
+      expect(otherResult.success).toBe(1);
+    });
+
+    test('should handle bidirectional lens configuration correctly', async () => {
+      const space1 = `${testPrefix}bi_space1`;
+      const space2 = `${testPrefix}bi_space2`;
+      
+      // Create federation with different lens configs for each direction
+      const lensConfig = {
+        federate: ['quests', 'announcements'],
+        notify: ['quests']
+      };
+      
+      await holosphere.federate(space1, space2, null, null, true, lensConfig);
+      
+      // Verify both spaces have correct lens configuration
+      const fedInfo1 = await holosphere.getFederation(space1);
+      const fedInfo2 = await holosphere.getFederation(space2);
+      
+      expect(fedInfo1.lensConfig[space2].federate).toEqual(['quests', 'announcements']);
+      expect(fedInfo1.lensConfig[space2].notify).toEqual(['quests']);
+      expect(fedInfo2.lensConfig[space1].federate).toEqual(['quests', 'announcements']);
+      expect(fedInfo2.lensConfig[space1].notify).toEqual(['quests']);
+      
+      // Test propagation in both directions
+      const testData = { id: 'test-item', value: 'test' };
+      
+      // Space1 to Space2
+      const result1 = await holosphere.propagate(space1, 'quests', testData);
+      expect(result1.success).toBe(1);
+      
+      // Space2 to Space1
+      const result2 = await holosphere.propagate(space2, 'quests', testData);
+      expect(result2.success).toBe(1);
+    });
+
+    test('should handle unidirectional lens configuration', async () => {
+      const space1 = `${testPrefix}uni_space1`;
+      const space2 = `${testPrefix}uni_space2`;
+      
+      // Create federation with unidirectional lens config
+      const lensConfig = {
+        federate: ['quests', 'announcements'],
+        notify: ['quests']
+      };
+      
+      await holosphere.federate(space1, space2, null, null, false, lensConfig);
+      
+      // Verify lens configuration is only set for one direction
+      const fedInfo1 = await holosphere.getFederation(space1);
+      const fedInfo2 = await holosphere.getFederation(space2);
+      
+      expect(fedInfo1.lensConfig[space2].federate).toEqual(['quests', 'announcements']);
+      expect(fedInfo1.lensConfig[space2].notify).toEqual(['quests']);
+      expect(fedInfo2.lensConfig[space1].federate).toEqual([]);
+      expect(fedInfo2.lensConfig[space1].notify).toEqual([]);
+    });
   });
   
   describe('unfederate', () => {
@@ -167,4 +296,54 @@ describe('Federation Tests', () => {
       expect(result.message).toBeDefined();
     });
   });
+
+  describe('getFederatedConfig', () => {
+    test('should retrieve the correct lens configuration for a specific federation link', async () => {
+      const space1 = `${testPrefix}lens_config_space1`;
+      const space2 = `${testPrefix}lens_config_space2`;
+      const space3 = `${testPrefix}lens_config_space3`; // Another space for testing
+
+      const specificLensConfig = {
+        federate: ['books', 'movies'],
+        notify: ['books']
+      };
+
+      // Federate space1 with space2 with specific lens config
+      await holosphere.federate(space1, space2, null, null, true, specificLensConfig);
+      // Federate space1 with space3 with default (empty or wildcard) lens config
+      await holosphere.federate(space1, space3, null, null, true, {}); 
+
+      // Test 1: Get specific lens config for space1 -> space2
+      const retrievedConfig1to2 = await holosphere.getFederatedConfig(space1, space2);
+      expect(retrievedConfig1to2).toEqual(specificLensConfig);
+
+      // Test 2: Get lens config for space1 -> space3 (should be default/empty or null)
+      // Depending on implementation, it might return null or { federate: [], notify: [] }
+      // For now, let's check if it's not the specific one and is an object (or null)
+      const retrievedConfig1to3 = await holosphere.getFederatedConfig(space1, space3);
+      expect(retrievedConfig1to3).not.toEqual(specificLensConfig);
+      if (retrievedConfig1to3 !== null) {
+        expect(typeof retrievedConfig1to3).toBe('object');
+        expect(Array.isArray(retrievedConfig1to3.federate)).toBe(true);
+        expect(Array.isArray(retrievedConfig1to3.notify)).toBe(true);
+        // Check if it defaulted to empty arrays as per current federate logic for empty lensConfig input
+        expect(retrievedConfig1to3.federate).toEqual([]);
+        expect(retrievedConfig1to3.notify).toEqual([]);
+      } else {
+        expect(retrievedConfig1to3).toBeNull();
+      }
+
+      // Test 3: Try to get config for a non-federated link
+      const space4 = `${testPrefix}lens_config_space4`;
+      const retrievedConfig1to4 = await holosphere.getFederatedConfig(space1, space4);
+      expect(retrievedConfig1to4).toBeNull();
+    });
+
+    test('should return null if no federation info exists for the source space', async () => {
+      const nonExistentSpace = `${testPrefix}non_existent_space`;
+      const targetSpace = `${testPrefix}any_target_space`;
+      const config = await holosphere.getFederatedConfig(nonExistentSpace, targetSpace);
+      expect(config).toBeNull();
+    });
+  });
 });

package/test/hologram-deletion.test.js

@@ -0,0 +1,197 @@
+/**
+ * Tests for hologram deletion functionality
+ * Verifies that when deleting holograms, only the hologram is deleted and the target's _holograms list is updated
+ * The original data should remain intact
+ */
+
+import HoloSphere from '../holosphere.js';
+
+const appName = 'test-hologram-deletion-app';
+const testHolon = 'hologramDeletionTestHolon';
+const testLens = 'testLens';
+const otherLens = 'otherLens';
+
+const waitForGun = (delay = 250) => new Promise(resolve => setTimeout(resolve, delay));
+
+describe('Hologram Deletion Tests', () => {
+    let holoSphere;
+
+    beforeEach(async () => {
+        holoSphere = new HoloSphere(appName, false);
+        await waitForGun();
+    });
+
+    afterEach(async () => {
+        if (holoSphere) {
+            await holoSphere.close();
+        }
+        await waitForGun();
+    });
+
+    test('delete() should only delete hologram and update target _holograms list', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-1', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-1`;
+
+        // 2. Store a hologram pointing to the original data
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-to-delete', soul: hologramData.soul };
+        await holoSphere.put(testHolon, otherLens, hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/${testHolon}/${otherLens}/hologram-to-delete`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete the hologram
+        await holoSphere.delete(testHolon, otherLens, 'hologram-to-delete');
+        await waitForGun(1000);
+
+        // 5. Verify the hologram is deleted
+        const deletedHologram = await holoSphere.get(testHolon, otherLens, 'hologram-to-delete');
+        expect(deletedHologram).toBeNull();
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-1');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleteAll() should handle holograms properly', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-2', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-2`;
+
+        // 2. Store just one hologram in otherLens (simplified test)
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-in-deleteall', soul: hologramData.soul };
+        await holoSphere.put(testHolon, otherLens, hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/${testHolon}/${otherLens}/hologram-in-deleteall`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete all items from otherLens
+        await holoSphere.deleteAll(testHolon, otherLens);
+        await waitForGun(1000);
+
+        // 5. Verify all items in otherLens are deleted
+        const allItems = await holoSphere.getAll(testHolon, otherLens);
+        expect(allItems).toHaveLength(0);
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-2');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleteGlobal() should handle holograms properly', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-3', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-3`;
+
+        // 2. Store a hologram in global table
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-in-global', soul: hologramData.soul };
+        await holoSphere.putGlobal('testTable', hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/testTable/hologram-in-global`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete the hologram from global table
+        await holoSphere.deleteGlobal('testTable', 'hologram-in-global');
+        await waitForGun(1000);
+
+        // 5. Verify the hologram is deleted
+        const deletedHologram = await holoSphere.getGlobal('testTable', 'hologram-in-global');
+        expect(deletedHologram).toBeNull();
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-3');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleteAllGlobal() should handle holograms properly', async () => {
+        // 1. Store original data
+        const originalData = { id: 'original-data-4', value: 'Original content' };
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        const originalSoul = `${appName}/${testHolon}/${testLens}/original-data-4`;
+
+        // 2. Store just one hologram in global table (simplified test)
+        const hologramData = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologramStorage = { id: 'hologram-in-deleteallglobal', soul: hologramData.soul };
+        await holoSphere.putGlobal('testTable2', hologramStorage);
+        await waitForGun(500);
+        const hologramSoul = `${appName}/testTable2/hologram-in-deleteallglobal`;
+
+        // 3. Verify hologram was added to tracking initially
+        const targetNodeRef = holoSphere.getNodeRef(originalSoul);
+        let hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet).toBeDefined();
+        expect(hologramsSet[hologramSoul]).toBeDefined();
+
+        // 4. Delete all items from global table
+        await holoSphere.deleteAllGlobal('testTable2');
+        await waitForGun(1000);
+
+        // 5. Verify all items in global table are deleted
+        const allItems = await holoSphere.getAllGlobal('testTable2');
+        expect(allItems).toHaveLength(0);
+
+        // 6. Verify the original data still exists
+        const originalStillExists = await holoSphere.get(testHolon, testLens, 'original-data-4');
+        expect(originalStillExists).toBeDefined();
+        expect(originalStillExists.value).toBe('Original content');
+
+        // 7. Verify the hologram was removed from target's _holograms list
+        hologramsSet = await new Promise(resolve => targetNodeRef.get('_holograms').once(resolve));
+        expect(hologramsSet[hologramSoul]).toBeNull();
+    }, 15000);
+
+    test('deleting non-hologram data should work normally', async () => {
+        // 1. Store regular data
+        const regularData = { id: 'regular-data-to-delete', value: 'Regular content' };
+        await holoSphere.put(testHolon, testLens, regularData);
+        await waitForGun();
+
+        // 2. Delete the regular data
+        await holoSphere.delete(testHolon, testLens, 'regular-data-to-delete');
+        await waitForGun();
+
+        // 3. Verify the data is deleted
+        const deletedData = await holoSphere.get(testHolon, testLens, 'regular-data-to-delete');
+        expect(deletedData).toBeNull();
+    }, 10000);
+}); 

package/test/hologram-updates-return.test.js

@@ -0,0 +1,166 @@
+// hologram-updates-return.test.js
+
+import HoloSphere from '../holosphere.js';
+
+describe('Hologram Updates Return Value Tests', () => {
+    let holoSphere;
+    const testHolon = 'updateReturnTestHolon';
+    const testLens = 'testLens';
+    const otherLens = 'otherLens';
+    const appName = 'test-hologram-return-app';
+
+    const waitForGun = (ms = 300) => new Promise(resolve => setTimeout(resolve, ms));
+
+    beforeEach(async () => {
+        holoSphere = new HoloSphere(appName, false);
+        // Clean up before each test
+        try {
+            await holoSphere.deleteAll(testHolon, testLens);
+            await holoSphere.deleteAll(testHolon, otherLens);
+        } catch (error) {
+            // Ignore cleanup errors
+        }
+        
+        await waitForGun(100);
+    }, 30000);
+
+    afterEach(async () => {
+        if (holoSphere) {
+            await holoSphere.close();
+        }
+    });
+
+    test('put should return empty array when no holograms exist', async () => {
+        const originalData = { id: 'no-holograms-test', value: 'Original Value' };
+        
+        // Put original data
+        const result = await holoSphere.put(testHolon, testLens, originalData);
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(Array.isArray(result.updatedHolograms)).toBe(true);
+        expect(result.updatedHolograms).toHaveLength(0);
+    });
+
+    test('put should return list of updated holograms when they exist', async () => {
+        const originalData = { id: 'with-holograms-test', value: 'Original Value' };
+        
+        // Step 1: Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Step 2: Create holograms pointing to the original data
+        const hologram1 = holoSphere.createHologram(testHolon, testLens, originalData);
+        const hologram2 = holoSphere.createHologram(testHolon, testLens, originalData);
+        
+        await holoSphere.put(testHolon, otherLens, { id: 'hologram-1', soul: hologram1.soul });
+        await holoSphere.put(testHolon, otherLens, { id: 'hologram-2', soul: hologram2.soul });
+        await waitForGun(500);
+        
+        // Step 3: Update the original data and check the return value
+        const updatedData = { ...originalData, value: 'Updated Value', count: 42 };
+        const result = await holoSphere.put(testHolon, testLens, updatedData);
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(Array.isArray(result.updatedHolograms)).toBe(true);
+        expect(result.updatedHolograms.length).toBeGreaterThan(0);
+        
+        // Check that the returned hologram info is complete
+        result.updatedHolograms.forEach(hologram => {
+            expect(hologram.soul).toBeDefined();
+            expect(hologram.holon).toBe(testHolon);
+            expect(hologram.lens).toBeDefined(); // Could be testLens or otherLens
+            expect(hologram.key).toBeDefined();
+            expect(hologram.id).toBeDefined();
+            expect(hologram.timestamp).toBeDefined();
+            expect(typeof hologram.timestamp).toBe('number');
+        });
+        
+        // Verify that the souls match what we expect
+        const expectedSouls = [
+            `${appName}/${testHolon}/${otherLens}/hologram-1`,
+            `${appName}/${testHolon}/${otherLens}/hologram-2`
+        ];
+        
+        const returnedSouls = result.updatedHolograms.map(h => h.soul);
+        expectedSouls.forEach(expectedSoul => {
+            expect(returnedSouls).toContain(expectedSoul);
+        });
+    });
+
+    test('put should return updated holograms with correct structure', async () => {
+        const originalData = { id: 'structure-test', value: 'Test Value' };
+        
+        // Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Create one hologram
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        await holoSphere.put(testHolon, otherLens, { id: 'structure-hologram', soul: hologram.soul });
+        await waitForGun(500);
+        
+        // Update original data
+        const updatedData = { ...originalData, value: 'Updated Test Value' };
+        const result = await holoSphere.put(testHolon, testLens, updatedData);
+        
+        expect(result.updatedHolograms).toHaveLength(1);
+        
+        const updatedHologram = result.updatedHolograms[0];
+        expect(updatedHologram).toEqual({
+            soul: `${appName}/${testHolon}/${otherLens}/structure-hologram`,
+            holon: testHolon,
+            lens: otherLens,
+            key: 'structure-hologram',
+            id: 'structure-hologram',
+            timestamp: expect.any(Number)
+        });
+        
+        // Verify timestamp is recent (within last few seconds)
+        const now = Date.now();
+        expect(updatedHologram.timestamp).toBeGreaterThan(now - 5000);
+        expect(updatedHologram.timestamp).toBeLessThanOrEqual(now);
+    });
+
+    test('put with isHologramUpdate option should not return updated holograms', async () => {
+        const originalData = { id: 'no-recursive-test', value: 'Original Value' };
+        
+        // Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Create hologram
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        await holoSphere.put(testHolon, otherLens, { id: 'recursive-test', soul: hologram.soul });
+        await waitForGun(500);
+        
+        // Update with isHologramUpdate flag (should not trigger hologram updates)
+        const updatedData = { ...originalData, value: 'Updated Value' };
+        const result = await holoSphere.put(testHolon, testLens, updatedData, null, { isHologramUpdate: true });
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(result.updatedHolograms).toHaveLength(0);
+    });
+
+    test('put hologram should not return updated holograms', async () => {
+        const originalData = { id: 'hologram-put-test', value: 'Original Value' };
+        
+        // Put original data
+        await holoSphere.put(testHolon, testLens, originalData);
+        await waitForGun();
+        
+        // Put a hologram (not original data)
+        const hologram = holoSphere.createHologram(testHolon, testLens, originalData);
+        const result = await holoSphere.put(testHolon, otherLens, { id: 'test-hologram', soul: hologram.soul });
+        
+        expect(result).toBeDefined();
+        expect(result.success).toBe(true);
+        expect(result.updatedHolograms).toBeDefined();
+        expect(result.updatedHolograms).toHaveLength(0);
+    });
+});