@olane/o-client-limited 0.7.51 → 0.7.53

package/dist/test/error-handling.spec.js

@@ -1,378 +0,0 @@
-import { describe, it, expect } from '@jest/globals';
-import { oLimitedConnection } from '../src/connection/o-limited-connection.js';
-import { oNodeAddress } from '@olane/o-node';
-import { createMockP2PConnection, createMockStream, createMockStreamHandler, } from './helpers/index.js';
-describe('Error Handling & Resource Management', () => {
-    const testProtocol = '/test/1.0.0';
-    const testAddress = new oNodeAddress('o://test');
-    const nextHopAddress = new oNodeAddress('o://next-hop');
-    describe('Connection State Validation', () => {
-        it('should throw error when p2pConnection is not open', async () => {
-            const closedConnection = createMockP2PConnection('test-conn', 'closed');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: closedConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Should throw when trying to create stream on closed connection
-            await expect(connection.getOrCreateStream()).rejects.toThrow();
-        });
-        it('should throw error when p2pConnection is closing', async () => {
-            const closingConnection = createMockP2PConnection('test-conn', 'closing');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: closingConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            await expect(connection.getOrCreateStream()).rejects.toThrow();
-        });
-        it('should succeed when p2pConnection is open', async () => {
-            const openConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: openConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Should not throw
-            const stream = await connection.getOrCreateStream();
-            expect(stream).toBeDefined();
-            expect(stream.p2pStream.status).toBe('open');
-        });
-    });
-    describe('Stream Creation Failures', () => {
-        it('should propagate error when newStream() fails', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            // Override newStream to throw an error
-            mockConnection.newStream = async () => {
-                throw new Error('Stream creation failed');
-            };
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            await expect(connection.getOrCreateStream()).rejects.toThrow('Stream creation failed');
-        });
-        it('should handle protocol negotiation failure', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            mockConnection.newStream = async () => {
-                throw new Error('Protocol not supported');
-            };
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            await expect(connection.getOrCreateStream()).rejects.toThrow('Protocol not supported');
-        });
-    });
-    describe('Concurrent Operations', () => {
-        it('should handle multiple concurrent getOrCreateStream calls', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Make 10 concurrent requests
-            const promises = Array.from({ length: 10 }, () => connection.getOrCreateStream());
-            const streams = await Promise.all(promises);
-            // All should succeed
-            expect(streams.length).toBe(10);
-            streams.forEach((stream) => {
-                expect(stream).toBeDefined();
-                expect(stream.p2pStream.protocol).toBe(testProtocol);
-            });
-            // With stream reuse, they should all get the same stream
-            // (since the first one creates it, rest reuse it)
-            const firstStream = streams[0];
-            streams.forEach((stream) => {
-                expect(stream).toBe(firstStream);
-            });
-        });
-        it('should handle concurrent postTransmit calls without errors', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            const stream = await connection.getOrCreateStream();
-            // Call postTransmit multiple times concurrently
-            const promises = Array.from({ length: 5 }, () => connection.postTransmit(stream));
-            // All should complete without error
-            await expect(Promise.all(promises)).resolves.not.toThrow();
-            // Stream should still be open (reuse policy)
-            expect(stream.status).toBe('open');
-        });
-        it('should maintain stream state consistency under concurrent access', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Interleave getOrCreateStream and postTransmit calls
-            const stream1 = await connection.getOrCreateStream();
-            const postTransmit1 = connection.postTransmit(stream1);
-            const stream2Promise = connection.getOrCreateStream();
-            await postTransmit1;
-            const stream2 = await stream2Promise;
-            // Should reuse the same stream
-            expect(stream2).toBe(stream1);
-            expect(stream2.p2pStream.status).toBe('open');
-        });
-    });
-    describe('Stream State Edge Cases', () => {
-        it('should not reuse streams that become invalid after selection', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            // Add a stream that starts open
-            const stream1 = createMockStream('stream-1', testProtocol, {
-                status: 'open',
-                writeStatus: 'writable',
-                remoteReadStatus: 'readable',
-            });
-            mockConnection.addStream(stream1);
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // First call gets the stream
-            const firstStream = await connection.getOrCreateStream();
-            expect(firstStream).toBe(stream1);
-            // Simulate stream being reset externally
-            stream1.reset();
-            // Next call should create a new stream (not reuse the reset one)
-            const secondStream = await connection.getOrCreateStream();
-            expect(secondStream).not.toBe(stream1);
-            expect(secondStream.p2pStream.status).toBe('open');
-        });
-        it('should handle stream that becomes non-writable', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const stream = createMockStream('stream-1', testProtocol, {
-                status: 'open',
-                writeStatus: 'writable',
-                remoteReadStatus: 'readable',
-            });
-            mockConnection.addStream(stream);
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Simulate stream becoming non-writable
-            stream.writeStatus = 'closed';
-            // Should create new stream instead of using non-writable one
-            const newStream = await connection.getOrCreateStream();
-            expect(newStream).not.toBe(stream);
-            expect(newStream.p2pStream.writeStatus).toBe('writable');
-        });
-        it('should handle stream where remote side closes read', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const stream = createMockStream('stream-1', testProtocol, {
-                status: 'open',
-                writeStatus: 'writable',
-                remoteReadStatus: 'readable',
-            });
-            mockConnection.addStream(stream);
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Simulate remote closing read side
-            stream.remoteReadStatus = 'closed';
-            // Should create new stream
-            const newStream = await connection.getOrCreateStream();
-            expect(newStream).not.toBe(stream);
-            expect(newStream.p2pStream.remoteReadStatus).toBe('readable');
-        });
-    });
-    describe('Resource Cleanup', () => {
-        it('should not leak streams when reusing', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Create and reuse stream multiple times
-            const stream1 = await connection.getOrCreateStream();
-            await connection.postTransmit(stream1);
-            const stream2 = await connection.getOrCreateStream();
-            await connection.postTransmit(stream2);
-            const stream3 = await connection.getOrCreateStream();
-            await connection.postTransmit(stream3);
-            // Should have only created ONE stream (reused for all)
-            expect(mockConnection.streams.length).toBe(1);
-            expect(stream1).toBe(stream2);
-            expect(stream2).toBe(stream3);
-            // Stream should still be open (not leaked, not closed)
-            expect(stream1.status).toBe('open');
-            expect(stream1.abortCallCount).toBe(0);
-        });
-        it('should track streams created but not closed prematurely', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Make 100 requests (should all reuse the same stream)
-            for (let i = 0; i < 100; i++) {
-                const stream = await connection.getOrCreateStream();
-                await connection.postTransmit(stream);
-            }
-            // Should still only have 1 stream
-            expect(mockConnection.streams.length).toBe(1);
-            const stream = mockConnection.streams[0];
-            expect(stream.status).toBe('open');
-            // Stream should NEVER have been aborted/closed
-            expect(stream.abortCallCount).toBe(0);
-            expect(stream.closeCallCount).toBe(0);
-        });
-        it('should handle postTransmit being called without prior getOrCreateStream', async () => {
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            // Create a standalone stream
-            const externalStream = createMockStream('external', testProtocol);
-            // Call postTransmit with it (shouldn't error)
-            await expect(connection.postTransmit(externalStream)).resolves.not.toThrow();
-            // Verify close was called with reuse policy
-            expect(mockStreamHandler.closeCalls.length).toBe(1);
-            expect(mockStreamHandler.getLastCloseConfig()?.reusePolicy).toBe('reuse');
-        });
-    });
-    describe('Environment Variable Edge Cases', () => {
-        it('should handle very large MAX_OUTBOUND_STREAMS values', async () => {
-            process.env.MAX_OUTBOUND_STREAMS = '999999';
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            await connection.getOrCreateStream();
-            const config = mockStreamHandler.getLastGetOrCreateConfig();
-            expect(config?.maxOutboundStreams).toBe(999999);
-            delete process.env.MAX_OUTBOUND_STREAMS;
-        });
-        it('should handle MAX_OUTBOUND_STREAMS = 0', async () => {
-            process.env.MAX_OUTBOUND_STREAMS = '0';
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            await connection.getOrCreateStream();
-            const config = mockStreamHandler.getLastGetOrCreateConfig();
-            expect(config?.maxOutboundStreams).toBe(0);
-            delete process.env.MAX_OUTBOUND_STREAMS;
-        });
-        it('should handle negative MAX_OUTBOUND_STREAMS values', async () => {
-            process.env.MAX_OUTBOUND_STREAMS = '-100';
-            const mockConnection = createMockP2PConnection('test-conn', 'open');
-            const mockStreamHandler = createMockStreamHandler();
-            const connection = new oLimitedConnection({
-                nextHopAddress,
-                address: testAddress,
-                p2pConnection: mockConnection,
-                callerAddress: testAddress,
-                runOnLimitedConnection: true,
-            });
-            connection.streamHandler = mockStreamHandler;
-            connection.nextHopAddress = { protocol: testProtocol };
-            await connection.getOrCreateStream();
-            const config = mockStreamHandler.getLastGetOrCreateConfig();
-            // parseInt('-100') returns -100
-            expect(config?.maxOutboundStreams).toBe(-100);
-            delete process.env.MAX_OUTBOUND_STREAMS;
-        });
-    });
-});

package/dist/test/helpers/mock-p2p-connection.d.ts

@@ -1,38 +0,0 @@
-import { Connection } from '@olane/o-config';
-import { MockStream } from './mock-stream.js';
-/**
- * Mock P2P Connection for testing
- */
-export declare class MockP2PConnection implements Partial<Connection> {
-    id: string;
-    status: 'open' | 'closing' | 'closed';
-    streams: any[];
-    private streamIdCounter;
-    constructor(id?: string, status?: 'open' | 'closing' | 'closed');
-    /**
-     * Mock newStream method that creates a new MockStream
-     */
-    newStream(protocol: string | string[], options?: any): Promise<any>;
-    /**
-     * Add a pre-existing stream to this connection
-     */
-    addStream(stream: MockStream): void;
-    /**
-     * Get all streams matching criteria
-     */
-    getStreams(criteria?: {
-        status?: string;
-        protocol?: string;
-        writeStatus?: string;
-        remoteReadStatus?: string;
-    }): MockStream[];
-    /**
-     * Close the connection and all streams
-     */
-    close(options?: any): Promise<void>;
-}
-/**
- * Create a mock P2P connection with optional pre-configured streams
- */
-export declare function createMockP2PConnection(id?: string, status?: 'open' | 'closing' | 'closed', streams?: MockStream[]): MockP2PConnection;
-//# sourceMappingURL=mock-p2p-connection.d.ts.map

package/dist/test/helpers/mock-p2p-connection.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock-p2p-connection.d.ts","sourceRoot":"","sources":["../../../test/helpers/mock-p2p-connection.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC7C,OAAO,EAAE,UAAU,EAAoB,MAAM,kBAAkB,CAAC;AAEhE;;GAEG;AACH,qBAAa,iBAAkB,YAAW,OAAO,CAAC,UAAU,CAAC;IACpD,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAC;IACtC,OAAO,EAAE,GAAG,EAAE,CAAM;IAC3B,OAAO,CAAC,eAAe,CAAK;gBAG1B,EAAE,GAAE,MAA0B,EAC9B,MAAM,GAAE,MAAM,GAAG,SAAS,GAAG,QAAiB;IAMhD;;OAEG;IACG,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;IAazE;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI;IAInC;;OAEG;IACH,UAAU,CAAC,QAAQ,CAAC,EAAE;QACpB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,WAAW,CAAC,EAAE,MAAM,CAAC;QACrB,gBAAgB,CAAC,EAAE,MAAM,CAAC;KAC3B,GAAG,UAAU,EAAE;IAoBhB;;OAEG;IACG,KAAK,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;CAI1C;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,EAAE,GAAE,MAA0B,EAC9B,MAAM,GAAE,MAAM,GAAG,SAAS,GAAG,QAAiB,EAC9C,OAAO,GAAE,UAAU,EAAO,GACzB,iBAAiB,CAInB"}

package/dist/test/helpers/mock-p2p-connection.js

@@ -1,66 +0,0 @@
-import { createMockStream } from './mock-stream.js';
-/**
- * Mock P2P Connection for testing
- */
-export class MockP2PConnection {
-    constructor(id = 'test-connection', status = 'open') {
-        this.streams = [];
-        this.streamIdCounter = 0;
-        this.id = id;
-        this.status = status;
-    }
-    /**
-     * Mock newStream method that creates a new MockStream
-     */
-    async newStream(protocol, options) {
-        if (this.status !== 'open') {
-            throw new Error(`Connection is ${this.status}, cannot create new stream`);
-        }
-        const protocolStr = Array.isArray(protocol) ? protocol[0] : protocol;
-        const streamId = `stream-${this.id}-${this.streamIdCounter++}`;
-        const stream = createMockStream(streamId, protocolStr);
-        this.streams.push(stream);
-        return stream;
-    }
-    /**
-     * Add a pre-existing stream to this connection
-     */
-    addStream(stream) {
-        this.streams.push(stream);
-    }
-    /**
-     * Get all streams matching criteria
-     */
-    getStreams(criteria) {
-        if (!criteria) {
-            return this.streams;
-        }
-        return this.streams.filter((stream) => {
-            if (criteria.status && stream.status !== criteria.status)
-                return false;
-            if (criteria.protocol && stream.protocol !== criteria.protocol)
-                return false;
-            if (criteria.writeStatus && stream.writeStatus !== criteria.writeStatus)
-                return false;
-            if (criteria.remoteReadStatus &&
-                stream.remoteReadStatus !== criteria.remoteReadStatus)
-                return false;
-            return true;
-        });
-    }
-    /**
-     * Close the connection and all streams
-     */
-    async close(options) {
-        this.status = 'closed';
-        await Promise.all(this.streams.map((stream) => stream.close()));
-    }
-}
-/**
- * Create a mock P2P connection with optional pre-configured streams
- */
-export function createMockP2PConnection(id = 'test-connection', status = 'open', streams = []) {
-    const connection = new MockP2PConnection(id, status);
-    streams.forEach((stream) => connection.addStream(stream));
-    return connection;
-}

package/dist/test/helpers/mock-stream-handler.d.ts

@@ -1,43 +0,0 @@
-import { Stream, Connection } from '@olane/o-config';
-import type { StreamHandlerConfig } from '@olane/o-node/src/connection/stream-handler.config.js';
-/**
- * Mock StreamHandler for testing stream reuse behavior
- */
-export declare class MockStreamHandler {
-    getOrCreateStreamCalls: Array<{
-        connection: Connection;
-        protocol: string;
-        config: StreamHandlerConfig;
-    }>;
-    closeCalls: Array<{
-        stream: Stream;
-        config: StreamHandlerConfig | undefined;
-    }>;
-    /**
-     * Mock getOrCreateStream implementation
-     * Mimics the real behavior of checking for reusable streams
-     */
-    getOrCreateStream(connection: Connection, protocol: string, config: StreamHandlerConfig): Promise<Stream>;
-    /**
-     * Mock close implementation
-     * If reusePolicy is 'reuse', doesn't actually close the stream
-     */
-    close(stream: Stream, config?: StreamHandlerConfig): Promise<void>;
-    /**
-     * Reset call tracking
-     */
-    reset(): void;
-    /**
-     * Get the last getOrCreateStream call config
-     */
-    getLastGetOrCreateConfig(): StreamHandlerConfig | undefined;
-    /**
-     * Get the last close call config
-     */
-    getLastCloseConfig(): StreamHandlerConfig | undefined;
-}
-/**
- * Create a mock stream handler
- */
-export declare function createMockStreamHandler(): MockStreamHandler;
-//# sourceMappingURL=mock-stream-handler.d.ts.map

package/dist/test/helpers/mock-stream-handler.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock-stream-handler.d.ts","sourceRoot":"","sources":["../../../test/helpers/mock-stream-handler.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAC;AACrD,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uDAAuD,CAAC;AAIjG;;GAEG;AACH,qBAAa,iBAAiB;IACrB,sBAAsB,EAAE,KAAK,CAAC;QACnC,UAAU,EAAE,UAAU,CAAC;QACvB,QAAQ,EAAE,MAAM,CAAC;QACjB,MAAM,EAAE,mBAAmB,CAAC;KAC7B,CAAC,CAAM;IAED,UAAU,EAAE,KAAK,CAAC;QACvB,MAAM,EAAE,MAAM,CAAC;QACf,MAAM,EAAE,mBAAmB,GAAG,SAAS,CAAC;KACzC,CAAC,CAAM;IAER;;;OAGG;IACG,iBAAiB,CACrB,UAAU,EAAE,UAAU,EACtB,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,mBAAmB,GAC1B,OAAO,CAAC,MAAM,CAAC;IAyBlB;;;OAGG;IACG,KAAK,CACT,MAAM,EAAE,MAAM,EACd,MAAM,CAAC,EAAE,mBAAmB,GAC3B,OAAO,CAAC,IAAI,CAAC;IAchB;;OAEG;IACH,KAAK,IAAI,IAAI;IAKb;;OAEG;IACH,wBAAwB,IAAI,mBAAmB,GAAG,SAAS;IAK3D;;OAEG;IACH,kBAAkB,IAAI,mBAAmB,GAAG,SAAS;CAGtD;AAED;;GAEG;AACH,wBAAgB,uBAAuB,IAAI,iBAAiB,CAE3D"}

package/dist/test/helpers/mock-stream-handler.js

@@ -1,71 +0,0 @@
-/**
- * Mock StreamHandler for testing stream reuse behavior
- */
-export class MockStreamHandler {
-    constructor() {
-        this.getOrCreateStreamCalls = [];
-        this.closeCalls = [];
-    }
-    /**
-     * Mock getOrCreateStream implementation
-     * Mimics the real behavior of checking for reusable streams
-     */
-    async getOrCreateStream(connection, protocol, config) {
-        // Track the call
-        this.getOrCreateStreamCalls.push({ connection, protocol, config });
-        const mockConnection = connection;
-        // If reuse policy is 'reuse', try to find an existing stream
-        if (config.reusePolicy === 'reuse') {
-            const reusableStream = mockConnection.streams.find((stream) => stream.protocol === protocol &&
-                stream.status === 'open' &&
-                stream.writeStatus === 'writable' &&
-                stream.remoteReadStatus === 'readable');
-            if (reusableStream) {
-                return reusableStream;
-            }
-        }
-        // Otherwise create a new stream
-        return mockConnection.newStream(protocol);
-    }
-    /**
-     * Mock close implementation
-     * If reusePolicy is 'reuse', doesn't actually close the stream
-     */
-    async close(stream, config) {
-        // Track the call
-        this.closeCalls.push({ stream, config });
-        // If reuse policy is 'reuse', don't close the stream
-        if (config?.reusePolicy === 'reuse') {
-            return; // Stream stays open for reuse
-        }
-        // Otherwise, close the stream
-        const mockStream = stream;
-        await mockStream.close();
-    }
-    /**
-     * Reset call tracking
-     */
-    reset() {
-        this.getOrCreateStreamCalls = [];
-        this.closeCalls = [];
-    }
-    /**
-     * Get the last getOrCreateStream call config
-     */
-    getLastGetOrCreateConfig() {
-        return this.getOrCreateStreamCalls[this.getOrCreateStreamCalls.length - 1]
-            ?.config;
-    }
-    /**
-     * Get the last close call config
-     */
-    getLastCloseConfig() {
-        return this.closeCalls[this.closeCalls.length - 1]?.config;
-    }
-}
-/**
- * Create a mock stream handler
- */
-export function createMockStreamHandler() {
-    return new MockStreamHandler();
-}

package/dist/test/helpers/mock-stream.d.ts

@@ -1,46 +0,0 @@
-/// <reference types="node" />
-import { Stream } from '@olane/o-config';
-import { EventEmitter } from 'events';
-/**
- * Mock Stream implementation for testing
- */
-export declare class MockStream extends EventEmitter implements Partial<Stream> {
-    id: string;
-    protocol: string;
-    status: 'open' | 'closing' | 'closed' | 'aborted' | 'reset';
-    writeStatus: 'writable' | 'closing' | 'closed';
-    readStatus: 'readable' | 'closing' | 'closed';
-    remoteReadStatus: 'readable' | 'closing' | 'closed';
-    timeline: {
-        open: number;
-        close?: number;
-    };
-    direction: 'inbound' | 'outbound';
-    abortCallCount: number;
-    closeCallCount: number;
-    constructor(id: string, protocol: string, options?: {
-        status?: 'open' | 'closing' | 'closed' | 'aborted' | 'reset';
-        writeStatus?: 'writable' | 'closing' | 'closed';
-        readStatus?: 'readable' | 'closing' | 'closed';
-        remoteReadStatus?: 'readable' | 'closing' | 'closed';
-        direction?: 'inbound' | 'outbound';
-    });
-    abort(err?: Error): void;
-    close(options?: any): Promise<void>;
-    reset(): void;
-}
-/**
- * Create a mock stream with default open/writable/readable state
- */
-export declare function createMockStream(id?: string, protocol?: string, options?: {
-    status?: 'open' | 'closing' | 'closed' | 'aborted' | 'reset';
-    writeStatus?: 'writable' | 'closing' | 'closed';
-    readStatus?: 'readable' | 'closing' | 'closed';
-    remoteReadStatus?: 'readable' | 'closing' | 'closed';
-    direction?: 'inbound' | 'outbound';
-}): MockStream;
-/**
- * Create multiple mock streams
- */
-export declare function createMockStreams(count: number, protocol?: string): MockStream[];
-//# sourceMappingURL=mock-stream.d.ts.map

package/dist/test/helpers/mock-stream.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mock-stream.d.ts","sourceRoot":"","sources":["../../../test/helpers/mock-stream.ts"],"names":[],"mappings":";AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAC;AACzC,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC;;GAEG;AACH,qBAAa,UAAW,SAAQ,YAAa,YAAW,OAAO,CAAC,MAAM,CAAC;IAC9D,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;IAC5D,WAAW,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC/C,UAAU,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC9C,gBAAgB,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IACpD,QAAQ,EAAE;QACf,IAAI,EAAE,MAAM,CAAC;QACb,KAAK,CAAC,EAAE,MAAM,CAAC;KAChB,CAAC;IACK,SAAS,EAAE,SAAS,GAAG,UAAU,CAAC;IAClC,cAAc,EAAE,MAAM,CAAK;IAC3B,cAAc,EAAE,MAAM,CAAK;gBAGhC,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,MAAM,EAChB,OAAO,GAAE;QACP,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;QAC7D,WAAW,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;QAChD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;QAC/C,gBAAgB,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;QACrD,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;KAC/B;IAeR,KAAK,CAAC,GAAG,CAAC,EAAE,KAAK,GAAG,IAAI;IAUlB,KAAK,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,IAAI,CAAC;IAUzC,KAAK,IAAI,IAAI;CAQd;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,EAAE,GAAE,MAAsB,EAC1B,QAAQ,GAAE,MAAsB,EAChC,OAAO,CAAC,EAAE;IACR,MAAM,CAAC,EAAE,MAAM,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;IAC7D,WAAW,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAChD,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IAC/C,gBAAgB,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,QAAQ,CAAC;IACrD,SAAS,CAAC,EAAE,SAAS,GAAG,UAAU,CAAC;CACpC,GACA,UAAU,CAEZ;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,EACb,QAAQ,GAAE,MAAsB,GAC/B,UAAU,EAAE,CAId"}