@olane/o-node 0.7.12-alpha.6 → 0.7.12-alpha.61

package/dist/test/search-resolver.spec.js

@@ -1,693 +0,0 @@
-import { expect } from 'chai';
-import { oSearchResolver } from '../src/router/resolvers/o-node.search-resolver.js';
-import { oAddress, RestrictedAddresses, NodeState, TransportType, } from '@olane/o-core';
-import { oNodeTransport } from '../src/router/o-node.transport.js';
-import { oNodeAddress } from '../src/router/o-node.address.js';
-import { oProtocolMethods } from '@olane/o-protocol';
-describe('oSearchResolver', () => {
-    let resolver;
-    let mockNode;
-    const testAddress = new oNodeAddress('o://test-node');
-    // Helper to create a proper oRouterRequest
-    const createRouterRequest = () => ({
-        method: oProtocolMethods.ROUTE,
-        params: {
-            _connectionId: 'test-connection',
-            _requestMethod: 'test',
-            address: 'o://test',
-            payload: {},
-        },
-        jsonrpc: '2.0',
-        id: '1',
-        state: {},
-        connectionId: 'test-connection',
-        toJSON: () => ({}),
-        setState: () => { },
-        logger: {},
-    });
-    // Helper to create a proper oResponse
-    const createResponse = (result) => ({
-        jsonrpc: '2.0',
-        id: '1',
-        result,
-    });
-    beforeEach(() => {
-        resolver = new oSearchResolver(testAddress);
-        // Create mock node with necessary properties
-        mockNode = {
-            address: testAddress,
-            state: NodeState.RUNNING,
-            leader: new oNodeAddress(RestrictedAddresses.LEADER, [
-                new oNodeTransport('/ip4/127.0.0.1/tcp/4001'),
-            ]),
-            hierarchyManager: {
-                getChild: (address) => null,
-            },
-            use: async (address, request) => {
-                // Mock registry search response
-                return createResponse({
-                    data: [],
-                });
-            },
-        };
-    });
-    describe('Basic resolver configuration', () => {
-        it('should have custom transport for /search', () => {
-            const transports = resolver.customTransports;
-            expect(transports).to.have.lengthOf(1);
-            expect(transports[0].value).to.equal('/search');
-        });
-        it('should use registry as default search target', () => {
-            const registryAddress = resolver.getRegistryAddress();
-            expect(registryAddress.value).to.equal(RestrictedAddresses.REGISTRY);
-        });
-        it('should use "search" as default method', () => {
-            const method = resolver.getSearchMethod();
-            expect(method).to.equal('search');
-        });
-    });
-    describe('resolve() - Basic flow', () => {
-        it('should skip search if address already has transports', async () => {
-            const addressWithTransports = new oNodeAddress('o://test', [
-                new oNodeTransport('/ip4/127.0.0.1/tcp/5001'),
-            ]);
-            const result = await resolver.resolve({
-                address: addressWithTransports,
-                targetAddress: addressWithTransports,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.nextHopAddress.value).to.equal('o://test');
-            expect(result.nextHopAddress.transports).to.have.lengthOf(1);
-        });
-        it('should return original address when no search results found', async () => {
-            const address = new oNodeAddress('o://unknown-service');
-            mockNode.use = async () => createResponse({ data: [] });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.nextHopAddress.value).to.equal('o://unknown-service');
-        });
-        it('should resolve address using registry search results', async () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings');
-            expect(result.targetAddress.transports).to.have.lengthOf(1);
-        });
-        it('should preserve extra path parameters in resolved address', async () => {
-            const address = new oNodeAddress('o://embeddings-text/method/params');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings/method/params');
-        });
-        it('should handle hierarchical address resolution', async () => {
-            const address = new oNodeAddress('o://leader/services/embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.transports).to.have.lengthOf(1);
-        });
-    });
-    describe('buildSearchParams()', () => {
-        it('should include both staticAddress and address', () => {
-            const address = new oNodeAddress('o://leader/services/embeddings-text');
-            const params = resolver.buildSearchParams(address);
-            expect(params.staticAddress).to.equal('o://leader');
-            expect(params.address).to.equal('o://leader/services/embeddings-text');
-        });
-        it('should use root address for staticAddress', () => {
-            const address = new oNodeAddress('o://leader/deep/nested/path');
-            const params = resolver.buildSearchParams(address);
-            expect(params.staticAddress).to.equal('o://leader');
-            expect(params.address).to.equal('o://leader/deep/nested/path');
-        });
-        it('should handle static addresses', () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            const params = resolver.buildSearchParams(address);
-            expect(params.staticAddress).to.equal('o://embeddings-text');
-            expect(params.address).to.equal('o://embeddings-text');
-        });
-    });
-    describe('filterSearchResults()', () => {
-        it('should filter out registry address to prevent loops', () => {
-            const results = [
-                {
-                    staticAddress: RestrictedAddresses.REGISTRY,
-                    address: 'o://registry',
-                },
-                { staticAddress: 'o://service', address: 'o://service' },
-            ];
-            const filtered = resolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(1);
-            expect(filtered[0].staticAddress).to.equal('o://service');
-        });
-        it('should filter out self address to prevent loops', () => {
-            const results = [
-                { address: 'o://test-node', staticAddress: 'o://test' },
-                { address: 'o://other-node', staticAddress: 'o://other' },
-            ];
-            const filtered = resolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(1);
-            expect(filtered[0].address).to.equal('o://other-node');
-        });
-        it('should allow all valid results', () => {
-            const results = [
-                { address: 'o://service-1', staticAddress: 'o://s1' },
-                { address: 'o://service-2', staticAddress: 'o://s2' },
-                { address: 'o://service-3', staticAddress: 'o://s3' },
-            ];
-            const filtered = resolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(3);
-        });
-        it('should handle empty results array', () => {
-            const filtered = resolver.filterSearchResults([], mockNode);
-            expect(filtered).to.be.an('array').that.is.empty;
-        });
-    });
-    describe('selectResult()', () => {
-        it('should select first result from multiple options', () => {
-            const results = [
-                { address: 'o://service-1', peerId: 'peer-1' },
-                { address: 'o://service-2', peerId: 'peer-2' },
-                { address: 'o://service-3', peerId: 'peer-3' },
-            ];
-            const selected = resolver.selectResult(results);
-            expect(selected).to.equal(results[0]);
-            expect(selected.peerId).to.equal('peer-1');
-        });
-        it('should return null for empty results', () => {
-            const selected = resolver.selectResult([]);
-            expect(selected).to.be.null;
-        });
-        it('should return single result', () => {
-            const results = [{ address: 'o://only-service', peerId: 'only-peer' }];
-            const selected = resolver.selectResult(results);
-            expect(selected).to.equal(results[0]);
-        });
-    });
-    describe('mapTransports()', () => {
-        it('should map transport objects to oNodeTransport instances', () => {
-            const result = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/4001', type: TransportType.LIBP2P },
-                    { value: '/ip4/192.168.1.1/tcp/4002', type: TransportType.LIBP2P },
-                ],
-            };
-            const transports = resolver.mapTransports(result);
-            expect(transports).to.have.lengthOf(2);
-            expect(transports[0]).to.be.instanceOf(oNodeTransport);
-            expect(transports[0].value).to.equal('/ip4/127.0.0.1/tcp/4001');
-            expect(transports[1].value).to.equal('/ip4/192.168.1.1/tcp/4002');
-        });
-        it('should handle empty transports array', () => {
-            const result = { transports: [] };
-            const transports = resolver.mapTransports(result);
-            expect(transports).to.be.an('array').that.is.empty;
-        });
-        it('should handle single transport', () => {
-            const result = {
-                transports: [{ value: '/memory', type: TransportType.CUSTOM }],
-            };
-            const transports = resolver.mapTransports(result);
-            expect(transports).to.have.lengthOf(1);
-            expect(transports[0].value).to.equal('/memory');
-        });
-    });
-    describe('resolveNextHopTransports()', () => {
-        it('should use leader transports when next hop is leader', () => {
-            const nextHop = new oNodeAddress(RestrictedAddresses.LEADER);
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/9999'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNode);
-            expect(resolved).to.have.lengthOf(1);
-            expect(resolved[0].value).to.equal('/ip4/127.0.0.1/tcp/4001'); // Leader transport from mock
-        });
-        it('should use child transports when next hop is known child', () => {
-            const childAddress = new oNodeAddress('o://known-child', [
-                new oNodeTransport('/ip4/10.0.0.1/tcp/7001'),
-            ]);
-            mockNode.hierarchyManager = {
-                getChild: (address) => {
-                    if (address.value === 'o://known-child') {
-                        return childAddress;
-                    }
-                    return null;
-                },
-            };
-            const nextHop = new oNodeAddress('o://known-child');
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/9999'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNode);
-            expect(resolved).to.have.lengthOf(1);
-            expect(resolved[0].value).to.equal('/ip4/10.0.0.1/tcp/7001');
-        });
-        it('should use target transports for unknown next hop', () => {
-            const nextHop = new oNodeAddress('o://unknown-node');
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/8001'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNode);
-            expect(resolved).to.have.lengthOf(1);
-            expect(resolved[0].value).to.equal('/ip4/192.168.1.1/tcp/8001');
-        });
-        it('should return empty array when leader has no transports', () => {
-            // Create a new mock node with leader that has no transports
-            const mockNodeNoLeaderTransports = {
-                ...mockNode,
-                leader: new oNodeAddress(RestrictedAddresses.LEADER, []),
-            };
-            const nextHop = new oNodeAddress(RestrictedAddresses.LEADER);
-            const targetTransports = [
-                new oNodeTransport('/ip4/192.168.1.1/tcp/9999'),
-            ];
-            const resolved = resolver.resolveNextHopTransports(nextHop, targetTransports, mockNodeNoLeaderTransports);
-            expect(resolved).to.be.an('array').that.is.empty;
-        });
-    });
-    describe('determineNextHop()', () => {
-        it('should use oAddress.next() for hierarchy routing', async () => {
-            const resolvedTarget = new oNodeAddress('o://leader/services/embeddings');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = resolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            // From leader to o://leader/services/embeddings, next hop should be o://leader/services
-            expect(nextHop.value).to.equal('o://leader/services');
-            expect(nextHop.transports).to.not.be.empty;
-        });
-        it('should set transports on next hop address', async () => {
-            const resolvedTarget = new oNodeAddress('o://leader/services');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = resolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            expect(nextHop.transports).to.not.be.undefined;
-            expect(nextHop.transports).to.not.be.empty;
-        });
-        it('should handle routing to immediate child', async () => {
-            const resolvedTarget = new oNodeAddress('o://leader/services');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = resolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            expect(nextHop.value).to.equal('o://leader/services');
-        });
-    });
-    describe('Custom resolver subclassing', () => {
-        it('should allow overriding getRegistryAddress()', () => {
-            class CustomRegistryResolver extends oSearchResolver {
-                getRegistryAddress() {
-                    return new oAddress('o://custom-registry');
-                }
-            }
-            const customResolver = new CustomRegistryResolver(testAddress);
-            const registryAddress = customResolver.getRegistryAddress();
-            expect(registryAddress.value).to.equal('o://custom-registry');
-        });
-        it('should allow overriding getSearchMethod()', () => {
-            class CustomMethodResolver extends oSearchResolver {
-                getSearchMethod() {
-                    return 'custom_search';
-                }
-            }
-            const customResolver = new CustomMethodResolver(testAddress);
-            const method = customResolver.getSearchMethod();
-            expect(method).to.equal('custom_search');
-        });
-        it('should allow custom result selection (e.g., round-robin)', () => {
-            class RoundRobinResolver extends oSearchResolver {
-                constructor() {
-                    super(...arguments);
-                    this.currentIndex = 0;
-                }
-                selectResult(results) {
-                    if (results.length === 0)
-                        return null;
-                    const result = results[this.currentIndex % results.length];
-                    this.currentIndex++;
-                    return result;
-                }
-            }
-            const customResolver = new RoundRobinResolver(testAddress);
-            const results = [
-                { address: 'o://service-1' },
-                { address: 'o://service-2' },
-                { address: 'o://service-3' },
-            ];
-            // First call
-            let selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-1');
-            // Second call
-            selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-2');
-            // Third call
-            selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-3');
-            // Fourth call - wraps around
-            selected = customResolver.selectResult(results);
-            expect(selected.address).to.equal('o://service-1');
-        });
-        it('should allow custom filtering logic', () => {
-            class StatusFilterResolver extends oSearchResolver {
-                filterSearchResults(results, node) {
-                    // First apply parent filtering
-                    const filtered = super.filterSearchResults(results, node);
-                    // Then apply custom filtering
-                    return filtered.filter((result) => result.status === 'active');
-                }
-            }
-            const customResolver = new StatusFilterResolver(testAddress);
-            const results = [
-                { address: 'o://service-1', status: 'active', staticAddress: 'o://s1' },
-                {
-                    address: 'o://service-2',
-                    status: 'inactive',
-                    staticAddress: 'o://s2',
-                },
-                { address: 'o://service-3', status: 'active', staticAddress: 'o://s3' },
-            ];
-            const filtered = customResolver.filterSearchResults(results, mockNode);
-            expect(filtered).to.have.lengthOf(2);
-            expect(filtered.every((r) => r.status === 'active')).to.be.true;
-        });
-        it('should allow direct routing by overriding determineNextHop()', () => {
-            class DirectRoutingResolver extends oSearchResolver {
-                determineNextHop(node, resolvedTargetAddress, searchResult) {
-                    // Always route directly to target, bypassing hierarchy
-                    const targetTransports = this.mapTransports(searchResult);
-                    resolvedTargetAddress.setTransports(targetTransports);
-                    return resolvedTargetAddress;
-                }
-            }
-            const customResolver = new DirectRoutingResolver(testAddress);
-            const resolvedTarget = new oNodeAddress('o://leader/services/embeddings');
-            const searchResult = {
-                transports: [
-                    { value: '/ip4/127.0.0.1/tcp/6001', type: TransportType.LIBP2P },
-                ],
-            };
-            mockNode.address = new oNodeAddress(RestrictedAddresses.LEADER);
-            const nextHop = customResolver.determineNextHop(mockNode, resolvedTarget, searchResult);
-            // Direct routing: next hop is the target itself
-            expect(nextHop.value).to.equal('o://leader/services/embeddings');
-            expect(nextHop.transports).to.have.lengthOf(1);
-        });
-    });
-    describe('Integration with registry calls', () => {
-        it('should call node.use() with correct registry address', async () => {
-            const address = new oNodeAddress('o://test-service');
-            let capturedAddress;
-            let capturedRequest;
-            mockNode.use = async (addr, req) => {
-                capturedAddress = addr;
-                capturedRequest = req;
-                return createResponse({ data: [] });
-            };
-            await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(capturedAddress?.value).to.equal(RestrictedAddresses.REGISTRY);
-            expect(capturedRequest.method).to.equal('search');
-        });
-        it('should pass correct search parameters to registry', async () => {
-            const address = new oNodeAddress('o://leader/services/embeddings');
-            let capturedParams;
-            mockNode.use = async (addr, req) => {
-                capturedParams = req.params;
-                return createResponse({ data: [] });
-            };
-            await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(capturedParams.staticAddress).to.equal('o://leader');
-            expect(capturedParams.address).to.equal('o://leader/services/embeddings');
-        });
-        it('should handle registry errors gracefully', async () => {
-            const address = new oNodeAddress('o://test-service');
-            mockNode.use = async () => {
-                throw new Error('Registry unavailable');
-            };
-            // Should throw error since registry is unavailable
-            try {
-                await resolver.resolve({
-                    address,
-                    targetAddress: address,
-                    node: mockNode,
-                    request: createRouterRequest(),
-                });
-                expect.fail('Should have thrown error');
-            }
-            catch (error) {
-                expect(error.message).to.equal('Registry unavailable');
-            }
-        });
-    });
-    describe('Address duplication bug fix', () => {
-        it('should NOT duplicate path segments when registry returns full hierarchical address', async () => {
-            // This test verifies the fix for the bug where o://services/embeddings-text
-            // was being resolved to o://leader/services/embeddings-text/services/embeddings-text
-            const address = new oNodeAddress('o://services/embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            // Should be o://leader/services/embeddings-text, NOT o://leader/services/embeddings-text/embeddings-text
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text');
-        });
-        it('should NOT duplicate when calling via static address', async () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text');
-        });
-        it('should still append legitimate extra params beyond the service name', async () => {
-            // If someone calls o://embeddings-text/custom/path, we should preserve /custom/path
-            const address = new oNodeAddress('o://embeddings-text/custom/path');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings-text',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            // Should append the extra /custom/path
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings-text/custom/path');
-        });
-    });
-    describe('Edge cases', () => {
-        it('should handle address with long nested paths', async () => {
-            const address = new oNodeAddress('o://leader/a/b/c/d/e/f');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/a/b/c/d/e/f',
-                        transports: [{ value: '/memory', type: TransportType.CUSTOM }],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/a/b/c/d/e/f');
-        });
-        it('should handle static addresses correctly', async () => {
-            const address = new oNodeAddress('o://embeddings-text');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://leader/services/embeddings',
-                        staticAddress: 'o://embeddings-text',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/6001',
-                                type: TransportType.LIBP2P,
-                            },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.value).to.equal('o://leader/services/embeddings');
-        });
-        it('should handle when leader is undefined', async () => {
-            const address = new oNodeAddress('o://test');
-            // Create a new mock node with undefined leader
-            const mockNodeNoLeader = {
-                ...mockNode,
-                leader: undefined,
-            };
-            mockNodeNoLeader.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://test',
-                        transports: [{ value: '/memory', type: TransportType.CUSTOM }],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNodeNoLeader,
-                request: createRouterRequest(),
-            });
-            // Should still work, just won't have leader transports
-            expect(result.targetAddress.value).to.equal('o://test');
-        });
-        it('should handle multiple transports in search result', async () => {
-            const address = new oNodeAddress('o://multi-transport');
-            mockNode.use = async () => createResponse({
-                data: [
-                    {
-                        address: 'o://multi-transport',
-                        transports: [
-                            {
-                                value: '/ip4/127.0.0.1/tcp/4001',
-                                type: TransportType.LIBP2P,
-                            },
-                            {
-                                value: '/ip4/192.168.1.1/tcp/4002',
-                                type: TransportType.LIBP2P,
-                            },
-                            { value: '/memory', type: TransportType.CUSTOM },
-                        ],
-                    },
-                ],
-            });
-            const result = await resolver.resolve({
-                address,
-                targetAddress: address,
-                node: mockNode,
-                request: createRouterRequest(),
-            });
-            expect(result.targetAddress.transports).to.have.lengthOf(3);
-        });
-    });
-});