@olane/o-node 0.7.40 → 0.7.42

package/dist/test/stream-handler-caching.spec.js

@@ -1,261 +0,0 @@
-import { expect } from 'chai';
-import { StreamHandler } from '../src/connection/stream-handler.js';
-import { oAddress } from '@olane/o-core';
-describe('StreamHandler Address-Based Caching', () => {
-    let streamHandler;
-    let mockConnection;
-    let mockStream;
-    let callerAddress;
-    let receiverAddress;
-    beforeEach(() => {
-        streamHandler = new StreamHandler();
-        // Create mock connection
-        mockConnection = {
-            status: 'open',
-            remotePeer: {
-                toString: () => 'test-peer-id',
-            },
-            remoteAddr: {
-                toString: () => '/memory/test',
-            },
-            streams: [],
-            newStream: async () => mockStream,
-        };
-        // Create mock stream
-        mockStream = {
-            id: 'test-stream-id',
-            status: 'open',
-            writeStatus: 'writable',
-            remoteReadStatus: 'readable',
-            direction: 'outbound',
-            protocol: '/o/test',
-            addEventListener: () => { },
-        };
-        callerAddress = new oAddress('o://caller');
-        receiverAddress = new oAddress('o://receiver');
-    });
-    describe('getOrCreateStream with Address-Based Caching', () => {
-        it('should create new stream when cache is empty', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            expect(stream).to.equal(mockStream);
-        });
-        it('should reuse cached stream with same caller-receiver pair', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            // First call creates and caches
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Second call should reuse
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            expect(stream1).to.equal(stream2);
-        });
-        it('should reuse stream bidirectionally (A→B same as B→A)', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            // First: caller → receiver
-            const streamAtoB = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAtoB);
-            // Second: receiver → caller (reversed)
-            const streamBtoA = {
-                callerAddress: receiverAddress,
-                receiverAddress: callerAddress,
-                direction: 'inbound',
-            };
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamBtoA);
-            // Should be the same stream due to bidirectional caching
-            expect(stream1).to.equal(stream2);
-        });
-        it('should create new stream for different address pairs', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const otherReceiver = new oAddress('o://other-receiver');
-            // Create new mock stream for second call
-            const mockStream2 = {
-                ...mockStream,
-                id: 'test-stream-id-2',
-            };
-            let streamCount = 0;
-            mockConnection.newStream = async () => {
-                streamCount++;
-                return (streamCount === 1 ? mockStream : mockStream2);
-            };
-            // First pair
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            });
-            // Different pair
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, {
-                callerAddress,
-                receiverAddress: otherReceiver,
-                direction: 'outbound',
-            });
-            // Should be different streams
-            expect(stream1.id).to.not.equal(stream2.id);
-        });
-        it('should not cache when reusePolicy is none', async () => {
-            const config = {
-                reusePolicy: 'none',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            let callCount = 0;
-            mockConnection.newStream = async () => {
-                callCount++;
-                return {
-                    ...mockStream,
-                    id: `stream-${callCount}`,
-                };
-            };
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Should be different streams (not cached)
-            expect(stream1.id).to.not.equal(stream2.id);
-        });
-        it('should remove non-reusable streams from cache', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            // First call creates and caches
-            const stream1 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Make stream non-reusable
-            mockStream.status = 'closed';
-            // Create new mock stream for second call
-            const mockStream2 = {
-                ...mockStream,
-                id: 'test-stream-id-2',
-                status: 'open',
-            };
-            mockConnection.newStream = async () => mockStream2;
-            // Second call should create new stream (old one not reusable)
-            const stream2 = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            expect(stream1.id).to.not.equal(stream2.id);
-        });
-        it('should fall back to protocol-based check when addresses not provided', async () => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            // Add mock stream to connection streams
-            mockConnection.streams = [mockStream];
-            // Call without streamAddresses
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config);
-            // Should find and return the existing stream by protocol
-            expect(stream).to.equal(mockStream);
-        });
-    });
-    describe('extractRemotePeerAddress', () => {
-        it('should extract address from connection peer ID', () => {
-            const address = streamHandler.extractRemotePeerAddress(mockConnection);
-            expect(address.value).to.include('o://peer/');
-            expect(address.value).to.include('test-peer-id');
-        });
-    });
-    describe('cacheInboundStream', () => {
-        it('should cache inbound stream when reuse is enabled', async () => {
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'reuse');
-            // Try to get the cached stream
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Should reuse the cached inbound stream
-            expect(stream).to.equal(mockStream);
-        });
-        it('should not cache when reusePolicy is none', async () => {
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'none');
-            // Try to get stream - should create new one
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            const newMockStream = { ...mockStream, id: 'new-stream-id' };
-            mockConnection.newStream = async () => newMockStream;
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            const stream = await streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            // Should not reuse (was not cached)
-            expect(stream.id).to.equal('new-stream-id');
-        });
-        it('should not cache duplicate streams', () => {
-            // Cache first time
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'reuse');
-            // Try to cache again - should be no-op
-            streamHandler.cacheInboundStream(mockStream, callerAddress, receiverAddress, 'reuse');
-            // No error should occur, and stream should still be cached
-            // (This test mainly ensures no exception is thrown)
-        });
-    });
-    describe('Stream Cleanup', () => {
-        it('should remove stream from cache on close event', (done) => {
-            const config = {
-                reusePolicy: 'reuse',
-            };
-            let closeListener;
-            // Override addEventListener to capture the close listener
-            mockStream.addEventListener = (event, listener) => {
-                if (event === 'close') {
-                    closeListener = listener;
-                }
-            };
-            const streamAddresses = {
-                callerAddress,
-                receiverAddress,
-                direction: 'outbound',
-            };
-            streamHandler
-                .getOrCreateStream(mockConnection, '/o/test', config, streamAddresses)
-                .then(() => {
-                expect(closeListener).to.not.be.undefined;
-                // Simulate close event
-                if (closeListener) {
-                    closeListener();
-                }
-                // Create new stream for next call
-                const newMockStream = { ...mockStream, id: 'new-stream-after-close' };
-                mockConnection.newStream = async () => newMockStream;
-                // Try to get stream again - should create new one since old one was removed
-                return streamHandler.getOrCreateStream(mockConnection, '/o/test', config, streamAddresses);
-            })
-                .then((stream) => {
-                expect(stream.id).to.equal('new-stream-after-close');
-                done();
-            })
-                .catch(done);
-        });
-    });
-});