@olane/o-node 0.7.12 → 0.7.13-alpha.1

package/dist/test/network-communication.spec.js

@@ -0,0 +1,256 @@
+import { expect } from 'chai';
+import { TestEnvironment } from './helpers/index.js';
+import { NetworkBuilder, NetworkTopologies } from './helpers/network-builder.js';
+import { createConnectionSpy } from './helpers/connection-spy.js';
+import { oNodeAddress } from '../src/router/o-node.address.js';
+import { oErrorCodes } from '@olane/o-core';
+describe('Network Communication', () => {
+    const env = new TestEnvironment();
+    let builder;
+    afterEach(async () => {
+        if (builder) {
+            await builder.cleanup();
+        }
+        await env.cleanup();
+    });
+    describe('Two-Node Direct Communication', () => {
+        it('should establish connection between parent and child', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Verify child has leader transports
+            expect(child.address.libp2pTransports.length).to.be.greaterThan(0);
+            // Create connection spy
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make a call from leader to child
+            const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'hello from leader' },
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.message).to.equal('hello from leader');
+            expect(response.result.data.nodeAddress).to.include('child');
+            // Verify connection was established
+            const summary = spy.getSummary();
+            expect(summary.currentConnections).to.be.greaterThan(0);
+            spy.stop();
+        });
+        it('should allow bidirectional communication', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Leader → Child
+            const response1 = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'from leader' },
+            });
+            expect(response1.result.success).to.be.true;
+            expect(response1.result.data.message).to.equal('from leader');
+            // Child → Leader
+            const response2 = await child.use(new oNodeAddress(leader.address.toString(), leader.address.libp2pTransports), {
+                method: 'get_info',
+                params: {},
+            });
+            expect(response2.result.success).to.be.true;
+            expect(response2.result.data.address).to.include('leader');
+        });
+        it('should reuse connections for multiple requests', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make multiple requests
+            for (let i = 0; i < 5; i++) {
+                const response = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: `request ${i}` },
+                });
+                expect(response.result.success).to.be.true;
+            }
+            // Should have only 1 connection (reused)
+            const summary = spy.getSummary();
+            expect(summary.currentConnections).to.equal(1);
+            spy.stop();
+        });
+    });
+    describe('Three-Node Hierarchical Communication', () => {
+        it('should route through hierarchy (leader → parent → child)', async () => {
+            builder = await NetworkTopologies.threeNode();
+            const leader = builder.getNode('o://leader');
+            const parent = builder.getNode('o://parent');
+            const child = builder.getNode('o://child');
+            // Leader → Child (should route through parent)
+            const response = await leader.use(child.address, {
+                method: 'echo',
+                params: { message: 'hello from leader' },
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.message).to.equal('hello from leader');
+            expect(response.result.data.nodeAddress).to.include('child');
+        });
+    });
+    describe('Self-Routing Optimization', () => {
+        it('should execute locally when routing to self', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            const initialStreamCount = spy.getTotalStreamCount();
+            // Call self
+            const response = await leader.use(leader.address, {
+                method: 'get_info',
+                params: {},
+            });
+            expect(response.result.success).to.be.true;
+            expect(response.result.data.address).to.include('leader');
+            // Stream count should not increase (no network call)
+            const finalStreamCount = spy.getTotalStreamCount();
+            expect(finalStreamCount).to.equal(initialStreamCount);
+            spy.stop();
+        });
+        it('should handle self-routing with different address formats', async () => {
+            builder = new NetworkBuilder();
+            const leader = await builder.addNode('o://leader');
+            // Call with exact address
+            const response1 = await leader.use(leader.address, {
+                method: 'get_info',
+                params: {},
+            });
+            expect(response1.result.success).to.be.true;
+            // Call with address string (should also detect self)
+            const response2 = await leader.use(new oNodeAddress('o://leader'), {
+                method: 'get_info',
+                params: {},
+            });
+            expect(response2.result.success).to.be.true;
+        });
+    });
+    describe('Method Execution', () => {
+        it('should execute tool methods correctly', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            // Test echo method
+            const echoResponse = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test message' },
+            });
+            expect(echoResponse.result.success).to.be.true;
+            expect(echoResponse.result.data.message).to.equal('test message');
+            expect(echoResponse.result.data.timestamp).to.be.a('number');
+            // Test get_info method
+            const infoResponse = await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'get_info',
+                params: {},
+            });
+            expect(infoResponse.result.success).to.be.true;
+            expect(infoResponse.result.data.address).to.be.a('string');
+            expect(infoResponse.result.data.callCount).to.equal(1); // One echo call
+        });
+        it('should handle method not found errors', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'non_existent_method',
+                params: {},
+            }).catch((error) => {
+                expect(error).to.exist;
+                expect(error?.code).to.be.equal(oErrorCodes.INVALID_ACTION);
+            });
+        });
+    });
+    describe('Concurrent Requests', () => {
+        it('should handle concurrent requests to same node', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const promises = [];
+            for (let i = 0; i < 10; i++) {
+                promises.push(leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                    method: 'echo',
+                    params: { message: `concurrent ${i}` },
+                }));
+            }
+            const responses = await Promise.all(promises);
+            // All should succeed
+            expect(responses).to.have.lengthOf(10);
+            responses.forEach((response, i) => {
+                expect(response.result.success).to.be.true;
+                expect(response.result.data.message).to.equal(`concurrent ${i}`);
+            });
+        });
+        it('should handle concurrent requests to different nodes', async () => {
+            builder = await NetworkTopologies.fiveNode();
+            const leader = builder.getNode('o://leader');
+            const parent1 = builder.getNode('o://parent1');
+            const parent2 = builder.getNode('o://parent2');
+            const child1 = builder.getNode('o://child1');
+            const child2 = builder.getNode('o://child2');
+            const promises = [
+                leader.use(parent1.address, { method: 'get_info', params: {} }),
+                leader.use(parent2.address, { method: 'get_info', params: {} }),
+                leader.use(child1.address, { method: 'get_info', params: {} }),
+                leader.use(child2.address, { method: 'get_info', params: {} }),
+            ];
+            const responses = await Promise.all(promises);
+            // All should succeed
+            expect(responses).to.have.lengthOf(4);
+            responses.forEach((response) => {
+                expect(response.result.success).to.be.true;
+            });
+            // Verify correct nodes responded
+            expect(responses[0].result.data.address).to.include('parent1');
+            expect(responses[1].result.data.address).to.include('parent2');
+            expect(responses[2].result.data.address).to.include('child1');
+            expect(responses[3].result.data.address).to.include('child2');
+        });
+    });
+    describe('Connection Pooling', () => {
+        it('should pool connections efficiently', async () => {
+            builder = await NetworkTopologies.fiveNode();
+            const leader = builder.getNode('o://leader');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            const child1 = builder.getNode('o://child1');
+            const child2 = builder.getNode('o://child2');
+            // Make multiple calls to same nodes
+            for (let i = 0; i < 5; i++) {
+                await leader.use(child1.address, {
+                    method: 'echo',
+                    params: { message: `child1-${i}` },
+                });
+                await leader.use(child2.address, {
+                    method: 'echo',
+                    params: { message: `child2-${i}` },
+                });
+            }
+            const summary = spy.getSummary();
+            // Should have connections to parents (which route to children)
+            expect(summary.currentConnections).to.be.greaterThan(0);
+            expect(summary.currentConnections).to.be.lessThan(10); // Not 10 (one per call)
+            spy.stop();
+        });
+        it('should maintain connection status correctly', async () => {
+            builder = await NetworkTopologies.twoNode();
+            const leader = builder.getNode('o://leader');
+            const child = builder.getNode('o://child');
+            const spy = createConnectionSpy(leader);
+            spy.start();
+            // Make initial request to establish connection
+            await leader.use(new oNodeAddress(child.address.toString(), child.address.libp2pTransports), {
+                method: 'echo',
+                params: { message: 'test' },
+            });
+            // Get connection stats
+            const stats = spy.getConnectionStats();
+            expect(stats.length).to.be.greaterThan(0);
+            const connection = stats[0];
+            expect(connection.status).to.equal('open');
+            expect(connection.peerId).to.be.a('string');
+            spy.stop();
+        });
+    });
+});

package/dist/test/o-node.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=o-node.spec.d.ts.map

package/dist/test/o-node.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-node.spec.d.ts","sourceRoot":"","sources":["../../test/o-node.spec.ts"],"names":[],"mappings":""}

package/dist/test/o-node.spec.js

@@ -0,0 +1,247 @@
+import { NodeState } from '@olane/o-core';
+import { expect } from 'chai';
+import { assertRunning, assertStopped } from '@olane/o-test';
+import { TestEnvironment } from './helpers/index.js';
+import { oNodeTool } from '../src/o-node.tool.js';
+import { oNodeAddress } from '../src/index.js';
+describe('oNode', () => {
+    const env = new TestEnvironment();
+    afterEach(async () => {
+        await env.cleanup();
+    });
+    describe('Lifecycle', () => {
+        it('should be able to start a single node with no leader', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://test'),
+                leader: null,
+                parent: null,
+            });
+            await node.start();
+            // Use o-test assertion helpers
+            assertRunning(node);
+            const transports = node.transports;
+            // expect(transports.length).to.equal(1);
+            // expect(transports[0].toString()).to.contain('/memory');
+            await node.stop();
+            assertStopped(node);
+            // Also verify with traditional chai for backward compatibility
+            expect(node.state).to.equal(NodeState.STOPPED);
+        });
+        it('should initialize with correct address', async () => {
+            const testAddress = new oNodeAddress('o://test-node');
+            const node = new oNodeTool({
+                address: testAddress,
+                leader: null,
+                parent: null,
+            });
+            await node.start();
+            expect(node.address.value).to.equal('o://test-node');
+            assertRunning(node);
+            await node.stop();
+        });
+        it('should handle start and stop lifecycle correctly', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://lifecycle-test'),
+                leader: null,
+                parent: null,
+            });
+            // Initially not started
+            expect(node.state).to.equal(NodeState.STOPPED);
+            // Start node
+            await node.start();
+            assertRunning(node);
+            // Stop node
+            await node.stop();
+            assertStopped(node);
+            // Verify state is properly reset
+            expect(node.state).to.equal(NodeState.STOPPED);
+        });
+        it('should allow restart after stop with state reset', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://restart-test'),
+                leader: null,
+                parent: null,
+                seed: 'restart-test-seed',
+            });
+            // First start
+            await node.start();
+            assertRunning(node);
+            // Verify node has transports after start
+            expect(node.address.libp2pTransports.length).to.be.greaterThan(0);
+            const firstPeerId = node.peerId.toString();
+            // Stop the node
+            await node.stop();
+            assertStopped(node);
+            // After stop, state should be reset
+            expect(node.p2pNode).to.be.undefined;
+            expect(node.peerId).to.be.undefined;
+            expect(node.connectionManager).to.be.undefined;
+            // Restart should now work
+            await node.start();
+            assertRunning(node);
+            // Verify node is functional after restart
+            expect(node.peerId.toString()).to.equal(firstPeerId); // Same seed = same peerId
+            expect(node.address.libp2pTransports.length).to.be.greaterThan(0);
+            await node.stop();
+        });
+        it('should reset address to staticAddress with no transports', async () => {
+            const staticAddress = new oNodeAddress('o://address-reset-test');
+            const node = new oNodeTool({
+                address: staticAddress,
+                leader: null,
+                parent: null,
+            });
+            // Verify initial state
+            expect(node.address.value).to.equal('o://address-reset-test');
+            expect(node.address.transports).to.have.length(0);
+            // Start node
+            await node.start();
+            assertRunning(node);
+            // After start, address should have transports
+            expect(node.address.transports.length).to.be.greaterThan(0);
+            const transportsDuringRun = node.address.transports.length;
+            // Stop node
+            await node.stop();
+            assertStopped(node);
+            // After stop, address should be reset to staticAddress with no transports
+            expect(node.address.value).to.equal('o://address-reset-test');
+            expect(node.address.transports).to.have.length(0);
+            // Restart to verify it works
+            await node.start();
+            assertRunning(node);
+            expect(node.address.transports.length).to.be.greaterThan(0);
+            await node.stop();
+        });
+        it('should reset errors array on stop', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://errors-reset-test'),
+                leader: null,
+                parent: null,
+            });
+            await node.start();
+            assertRunning(node);
+            // Simulate adding errors
+            node.errors.push(new Error('Test error'));
+            expect(node.errors).to.have.length(1);
+            await node.stop();
+            assertStopped(node);
+            // Errors should be cleared
+            expect(node.errors).to.have.length(0);
+        });
+        it('should reset metrics on stop', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://metrics-reset-test'),
+                leader: null,
+                parent: null,
+            });
+            await node.start();
+            assertRunning(node);
+            // Make some calls to accumulate metrics
+            await node.use(node.address, {
+                method: 'get_libp2p_metrics',
+                params: {},
+            });
+            // Verify metrics were recorded
+            const metricsBeforeStop = node.metrics.successCount;
+            expect(metricsBeforeStop).to.be.greaterThan(0);
+            await node.stop();
+            assertStopped(node);
+            // Metrics should be reset
+            expect(node.metrics.successCount).to.equal(0);
+            expect(node.metrics.errorCount).to.equal(0);
+        });
+        it('should support multiple restart cycles', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://multi-restart-test'),
+                leader: null,
+                parent: null,
+                seed: 'multi-restart-seed',
+            });
+            const peerId = node.peerId?.toString();
+            // First cycle
+            await node.start();
+            assertRunning(node);
+            expect(node.p2pNode).to.exist;
+            await node.stop();
+            assertStopped(node);
+            expect(node.p2pNode).to.be.undefined;
+            // Second cycle
+            await node.start();
+            assertRunning(node);
+            expect(node.p2pNode).to.exist;
+            await node.stop();
+            assertStopped(node);
+            expect(node.p2pNode).to.be.undefined;
+            // Third cycle
+            await node.start();
+            assertRunning(node);
+            expect(node.p2pNode).to.exist;
+            // Verify node is still functional
+            const response = await node.use(node.address, {
+                method: 'get_libp2p_metrics',
+                params: {},
+            });
+            expect(response.result.success).to.be.true;
+            await node.stop();
+            assertStopped(node);
+        });
+        it('should reset didRegister flag on stop', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://didregister-test'),
+                leader: null,
+                parent: null,
+            });
+            await node.start();
+            assertRunning(node);
+            // After start, didRegister might be true (depending on if registration happened)
+            // For standalone nodes without leader, it stays false, but let's verify the reset works
+            await node.stop();
+            assertStopped(node);
+            // Should be able to restart
+            await node.start();
+            assertRunning(node);
+            await node.stop();
+        });
+        it('should clear p2p node after stop', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://clear-test'),
+                leader: null,
+                parent: null,
+                seed: 'clear-test-seed',
+            });
+            await node.start();
+            assertRunning(node);
+            // Test basic functionality before stop
+            const response1 = await node.use(node.address, {
+                method: 'get_libp2p_metrics',
+                params: {},
+            });
+            expect(response1.result.success).to.be.true;
+            expect(response1.result.data).to.exist;
+            // Verify p2pNode exists
+            expect(node.p2pNode).to.exist;
+            await node.stop();
+            assertStopped(node);
+            // p2pNode should be cleared (allowing restart)
+            expect(node.p2pNode).to.be.undefined;
+        });
+        it('should clean up resources properly on stop', async () => {
+            const node = new oNodeTool({
+                address: new oNodeAddress('o://cleanup-test'),
+                leader: null,
+                parent: null,
+            });
+            await node.start();
+            assertRunning(node);
+            // Verify p2p node exists and is started
+            expect(node.p2pNode).to.exist;
+            expect(node.p2pNode.status).to.equal('started');
+            await node.stop();
+            assertStopped(node);
+            // Verify resources are cleaned up
+            expect(node.p2pNode).to.be.undefined;
+            expect(node.connectionManager).to.be.undefined;
+            expect(node.connectionHeartbeatManager).to.be.undefined;
+        });
+    });
+});

package/dist/test/parent-child-registration.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=parent-child-registration.spec.d.ts.map

package/dist/test/parent-child-registration.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parent-child-registration.spec.d.ts","sourceRoot":"","sources":["../../test/parent-child-registration.spec.ts"],"names":[],"mappings":""}