@libp2p/interface-compliance-tests 6.5.0-6059227cb → 6.5.0-87bc8d4fb

package/dist/src/transport/index.js

@@ -1,102 +1,40 @@
-import { stop, TimeoutError } from '@libp2p/interface';
-import { prefixLogger } from '@libp2p/logger';
+import { stop } from '@libp2p/interface';
 import { expect } from 'aegir/chai';
 import delay from 'delay';
-import all from 'it-all';
 import drain from 'it-drain';
 import { pushable } from 'it-pushable';
+import pDefer from 'p-defer';
 import { pEvent } from 'p-event';
 import pRetry from 'p-retry';
 import pWaitFor from 'p-wait-for';
 import { raceSignal } from 'race-signal';
-import { Uint8ArrayList } from 'uint8arraylist';
 import { isValidTick } from '../is-valid-tick.js';
 import { createPeer, getTransportManager, getUpgrader } from './utils.js';
 async function getSetup(common) {
     const setup = await common.setup();
-    const dialer = await createPeer({
-        logger: prefixLogger('dialer'),
-        ...setup.dialer
-    });
+    const dialer = await createPeer(setup.dialer);
     let listener;
     if (setup.listener != null) {
-        listener = await createPeer({
-            logger: prefixLogger('listener'),
-            ...setup.listener
-        });
+        listener = await createPeer(setup.listener);
     }
-    let dialAddrs = listener?.getMultiaddrs() ?? setup.dialAddrs;
+    const dialAddrs = listener?.getMultiaddrs() ?? setup.dialAddrs;
     if (dialAddrs == null) {
         throw new Error('Listener config or dial addresses must be specified');
     }
-    dialAddrs = dialAddrs.filter(ma => setup.dialMultiaddrMatcher.exactMatch(ma));
-    if (dialAddrs.length === 0) {
-        throw new Error('Listener was not listening on any addresses that the dialMultiaddrMatcher matched');
-    }
     return {
         dialer,
         listener,
-        dialAddrs,
+        dialAddrs: dialAddrs.filter(ma => setup.dialMultiaddrMatcher.exactMatch(ma)),
         dialMultiaddrMatcher: setup.dialMultiaddrMatcher,
         listenMultiaddrMatcher: setup.listenMultiaddrMatcher
     };
 }
 export default (common) => {
-    describe('transport events', () => {
-        let dialer;
-        let listener;
-        let listenMultiaddrMatcher;
-        afterEach(async () => {
-            await stop(dialer, listener);
-            await common.teardown();
-        });
-        it('emits listening', async function () {
-            ({ dialer, listener, listenMultiaddrMatcher } = await getSetup(common));
-            if (listener == null) {
-                return this.skip();
-            }
-            await listener.stop();
-            const transportListeningPromise = Promise.withResolvers();
-            listener.addEventListener('transport:listening', (event) => {
-                const transportListener = event.detail;
-                if (transportListener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma))) {
-                    transportListeningPromise.resolve();
-                }
-            });
-            await listener.start();
-            await raceSignal(transportListeningPromise.promise, AbortSignal.timeout(1000), {
-                translateError: () => {
-                    return new TimeoutError('Did not emit listening event');
-                }
-            });
-        });
-        it('emits close', async function () {
-            ({ dialer, listener } = await getSetup(common));
-            if (listener == null) {
-                return this.skip();
-            }
-            const transportManager = getTransportManager(listener);
-            const transportListener = transportManager.getListeners()
-                .filter(listener => listener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma)))
-                .pop();
-            if (transportListener == null) {
-                throw new Error('Could not find address listener');
-            }
-            const p = pEvent(transportListener, 'close');
-            await listener.stop();
-            await raceSignal(p, AbortSignal.timeout(1000), {
-                translateError: () => {
-                    return new TimeoutError('Did not emit close event');
-                }
-            });
-        });
-    });
     describe('interface-transport', () => {
         let dialer;
         let listener;
         let dialAddrs;
         let dialMultiaddrMatcher;
-        let listenMultiaddrMatcher;
         afterEach(async () => {
             await stop(dialer, listener);
             await common.teardown();
@@ -107,20 +45,17 @@ export default (common) => {
             const output = await dialer.services.echo.echo(dialAddrs[0], input, {
                 signal: AbortSignal.timeout(5000)
             });
-            expect(output.subarray()).to.equalBytes(input);
+            expect(output).to.equalBytes(input);
         });
         it('should listen on multiple addresses', async () => {
             ({ dialer, listener, dialAddrs } = await getSetup(common));
             const input = Uint8Array.from([0, 1, 2, 3, 4]);
-            const output1 = await dialer.services.echo.echo(dialAddrs[0], input, {
+            await expect(dialer.services.echo.echo(dialAddrs[0], input, {
                 signal: AbortSignal.timeout(5000)
-            });
-            expect(output1.subarray()).to.equalBytes(input);
-            const output2 = await dialer.services.echo.echo(dialAddrs[1], input, {
-                signal: AbortSignal.timeout(5000),
-                force: true
-            });
-            expect(output2.subarray()).to.equalBytes(input);
+            })).to.eventually.deep.equal(input);
+            await expect(dialer.services.echo.echo(dialAddrs[1], input, {
+                signal: AbortSignal.timeout(5000)
+            })).to.eventually.deep.equal(input);
         });
         it('can close connections', async () => {
             ({ dialer, listener, dialAddrs } = await getSetup(common));
@@ -140,15 +75,12 @@ export default (common) => {
                 .with.property('name', 'AbortError');
         });
         it('should close all streams when the connection closes', async () => {
-            ({ dialer, listener, dialAddrs, listenMultiaddrMatcher } = await getSetup(common));
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
             let incomingConnectionPromise;
             if (listener != null) {
-                incomingConnectionPromise = Promise.withResolvers();
+                incomingConnectionPromise = pDefer();
                 listener.addEventListener('connection:open', (event) => {
                     const conn = event.detail;
-                    if (!listenMultiaddrMatcher.matches(conn.remoteAddr)) {
-                        return;
-                    }
                     if (conn.remotePeer.equals(dialer.peerId)) {
                         incomingConnectionPromise?.resolve(conn);
                     }
@@ -164,25 +96,18 @@ export default (common) => {
                     maxOutboundStreams: 5
                 });
             }
-            expect(connection).to.have.property('streams').that.has.lengthOf(5);
-            if (remoteConn != null) {
-                await pWaitFor(() => remoteConn.streams.filter(s => s.protocol === '/echo/1.0.0').length === 5, {
-                    timeout: 5_000,
-                    interval: 1_000
-                });
-            }
+            const streams = connection.streams;
             // Close the connection and verify all streams have been closed
-            await Promise.all([
-                pEvent(connection, 'close'),
-                pEvent(remoteConn ?? connection, 'close'),
-                connection.close()
-            ]);
-            expect(connection).to.have.property('status', 'closed');
-            expect(connection).to.have.property('streams').that.is.empty();
+            await connection.close();
+            await pWaitFor(() => connection.streams.length === 0, {
+                timeout: 5000
+            });
             if (remoteConn != null) {
-                expect(remoteConn).to.have.property('status', 'closed');
-                expect(remoteConn).to.have.property('streams').that.is.empty();
+                await pWaitFor(() => remoteConn.streams.length === 0, {
+                    timeout: 5000
+                });
             }
+            expect(streams.find(stream => stream.status === 'open')).to.be.undefined();
         });
         it('should not handle connection if upgradeInbound rejects', async function () {
             ({ dialer, listener, dialAddrs, dialMultiaddrMatcher } = await getSetup(common));
@@ -223,219 +148,262 @@ export default (common) => {
                 }
             }
         });
-        it('should handle one small write', async function () {
-            const timeout = 120_000;
-            this.timeout(timeout);
-            ({ dialer, listener, dialAddrs } = await getSetup(common));
-            const connection = await dialer.dial(dialAddrs[0]);
-            const input = new Uint8Array(1024).fill(5);
-            const output = await dialer.services.echo.echo(connection.remotePeer, input, {
-                signal: AbortSignal.timeout(timeout)
-            });
-            expect(output.subarray()).to.equalBytes(input);
-            expect(connection.streams.filter(s => s.protocol === dialer.services.echo.protocol)).to.be.empty();
-        });
         it('should handle one big write', async function () {
-            const timeout = 540_000;
+            const timeout = 120_000;
             this.timeout(timeout);
             ({ dialer, listener, dialAddrs } = await getSetup(common));
-            const connection = await dialer.dial(dialAddrs[0]);
             const input = new Uint8Array(1024 * 1024 * 10).fill(5);
-            const output = await dialer.services.echo.echo(connection.remotePeer, input, {
+            const output = await dialer.services.echo.echo(dialAddrs[0], input, {
                 signal: AbortSignal.timeout(timeout)
             });
-            expect(output.subarray()).to.equalBytes(input);
-            expect(connection.streams.filter(s => s.protocol === dialer.services.echo.protocol)).to.be.empty();
+            expect(output).to.equalBytes(input);
         });
         it('should handle many small writes', async function () {
             const timeout = 360_000;
             this.timeout(timeout);
             ({ dialer, listener, dialAddrs } = await getSetup(common));
-            const connection = await dialer.dial(dialAddrs[0]);
-            const echoProtocol = dialer.services.echo.protocol;
-            for (let i = 0; i < 2_000; i++) {
+            for (let i = 0; i < 2000; i++) {
                 const input = new Uint8Array(1024).fill(5);
-                const output = await dialer.services.echo.echo(connection.remotePeer, input, {
+                const output = await dialer.services.echo.echo(dialAddrs[0], input, {
                     signal: AbortSignal.timeout(timeout)
                 });
-                expect(output.subarray()).to.equalBytes(input);
-                expect(connection.streams.filter(s => s.protocol === echoProtocol)).to.be.empty();
+                expect(output).to.equalBytes(input);
+            }
+        });
+        it('can close a stream for reading but send a large amount of data', async function () {
+            const timeout = 120_000;
+            this.timeout(timeout);
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
+            if (listener == null) {
+                return this.skip();
+            }
+            const protocol = '/send-data/1.0.0';
+            const chunkSize = 1024;
+            const bytes = chunkSize * 1024 * 10;
+            const deferred = pDefer();
+            await listener.handle(protocol, ({ stream }) => {
+                Promise.resolve().then(async () => {
+                    let read = 0;
+                    for await (const buf of stream.source) {
+                        read += buf.byteLength;
+                        if (read === bytes) {
+                            deferred.resolve();
+                            break;
+                        }
+                    }
+                })
+                    .catch(err => {
+                    deferred.reject(err);
+                    stream.abort(err);
+                });
+            });
+            const stream = await dialer.dialProtocol(dialAddrs[0], protocol);
+            await stream.closeRead();
+            await stream.sink((async function* () {
+                for (let i = 0; i < bytes; i += chunkSize) {
+                    yield new Uint8Array(chunkSize);
+                }
+            })());
+            await stream.close();
+            await deferred.promise;
+        });
+        it('can close a stream for writing but receive a large amount of data', async function () {
+            const timeout = 120_000;
+            this.timeout(timeout);
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
+            if (listener == null) {
+                return this.skip();
+            }
+            const protocol = '/receive-data/1.0.0';
+            const chunkSize = 1024;
+            const bytes = chunkSize * 1024 * 10;
+            const deferred = pDefer();
+            await listener.handle(protocol, ({ stream }) => {
+                Promise.resolve().then(async () => {
+                    await stream.sink((async function* () {
+                        for (let i = 0; i < bytes; i += chunkSize) {
+                            yield new Uint8Array(chunkSize);
+                        }
+                    })());
+                    await stream.close();
+                })
+                    .catch(err => {
+                    deferred.reject(err);
+                    stream.abort(err);
+                });
+            });
+            const stream = await dialer.dialProtocol(dialAddrs[0], protocol);
+            await stream.closeWrite();
+            let read = 0;
+            for await (const buf of stream.source) {
+                read += buf.byteLength;
             }
+            expect(read).to.equal(bytes);
         });
-        it('can close local stream while a remote stream is writing', async function () {
+        it('can close local stream for writing and reading while a remote stream is writing', async function () {
             ({ dialer, listener, dialAddrs } = await getSetup(common));
             if (listener == null) {
                 return this.skip();
             }
-            // 1. remote stream close read
-            // 2. local stream close write
-            // 3. remote stream close write
             /**
              * NodeA             NodeB
              * |   <--- STOP_SENDING |
              * | FIN --->            |
-             * |           <--- DATA |
              * |            <--- FIN |
              * | FIN_ACK --->        |
              * |        <--- FIN_ACK |
              */
-            const getRemoteStream = Promise.withResolvers();
+            const getRemoteStream = pDefer();
             const protocol = '/close-local-while-remote-writes/1.0.0';
-            const streamHandler = (stream) => {
-                getRemoteStream.resolve(stream);
+            const streamHandler = ({ stream }) => {
+                void Promise.resolve().then(async () => {
+                    getRemoteStream.resolve(stream);
+                });
             };
-            await listener.handle(protocol, streamHandler, {
+            await listener.handle(protocol, (info) => {
+                streamHandler(info);
+            }, {
                 runOnLimitedConnection: true
             });
             const connection = await dialer.dial(dialAddrs[0]);
-            const [localStream, remoteStream] = await Promise.all([
-                // open a stream on the echo protocol
-                connection.newStream(protocol, {
-                    runOnLimitedConnection: true
-                }),
-                getRemoteStream.promise
-            ]);
-            // ignore incoming data
-            void drain(localStream);
-            // close the remote readable end
+            // open a stream on the echo protocol
+            const stream = await connection.newStream(protocol, {
+                runOnLimitedConnection: true
+            });
+            // close the write end immediately
+            const p = stream.closeWrite();
+            const remoteStream = await getRemoteStream.promise;
+            // close the readable end of the remote stream
             await remoteStream.closeRead();
-            // send data from the remote to the local
+            // keep the remote write end open, this should delay the FIN_ACK reply to the local stream
             const remoteInputStream = pushable();
-            Promise.resolve().then(async () => {
-                for await (const buf of remoteInputStream) {
-                    const sendMore = remoteStream.send(buf);
-                    if (sendMore === false) {
-                        await pEvent(remoteStream, 'drain', {
-                            rejectionEvents: [
-                                'close'
-                            ]
-                        });
-                    }
+            void remoteStream.sink(remoteInputStream);
+            // wait for remote to receive local close-write
+            await pRetry(() => {
+                if (remoteStream.readStatus !== 'closed') {
+                    throw new Error('Remote stream read status ' + remoteStream.readStatus);
                 }
-                // close the remote writable end
-                await remoteStream.close();
+            }, {
+                minTimeout: 100
             });
-            await Promise.all([
-                // wait for remote to receive local FIN
-                pEvent(remoteStream, 'remoteCloseWrite'),
-                // wait to receive FIN_ACK
-                localStream.close()
-            ]);
-            // stop sending remote -> local
+            // remote closes write
             remoteInputStream.end();
+            // wait to receive FIN_ACK
+            await p;
             // wait for remote to notice closure
             await pRetry(() => {
                 if (remoteStream.status !== 'closed') {
                     throw new Error('Remote stream not closed');
                 }
             });
-            // both ends should be closed
-            assertStreamClosed(localStream);
+            assertStreamClosed(stream);
             assertStreamClosed(remoteStream);
         });
-        it('can close local stream for writing while a remote stream is reading', async function () {
+        it('can close local stream for writing and reading while a remote stream is writing using source/sink', async function () {
             ({ dialer, listener, dialAddrs } = await getSetup(common));
             if (listener == null) {
                 return this.skip();
             }
             /**
              * NodeA             NodeB
-             * | DATA --->           |
              * | FIN --->            |
              * |            <--- FIN |
              * | FIN_ACK --->        |
              * |        <--- FIN_ACK |
              */
-            const getRemoteStream = Promise.withResolvers();
+            const getRemoteStream = pDefer();
             const protocol = '/close-local-while-remote-reads/1.0.0';
-            const streamHandler = (stream) => {
-                getRemoteStream.resolve(stream);
+            const streamHandler = ({ stream }) => {
+                void Promise.resolve().then(async () => {
+                    getRemoteStream.resolve(stream);
+                });
             };
-            await listener.handle(protocol, streamHandler, {
+            await listener.handle(protocol, (info) => {
+                streamHandler(info);
+            }, {
                 runOnLimitedConnection: true
             });
             const connection = await dialer.dial(dialAddrs[0]);
-            const [localStream, remoteStream] = await Promise.all([
-                // open a stream on the echo protocol
-                connection.newStream(protocol, {
-                    runOnLimitedConnection: true
-                }),
-                getRemoteStream.promise
-            ]);
-            // ignore incoming data
-            void drain(remoteStream);
-            // close the remote stream writable end when the local sends a FIN
-            remoteStream.addEventListener('remoteCloseWrite', () => {
-                remoteStream.close()
-                    .catch(err => {
-                    remoteStream.abort(err);
-                });
+            // open a stream on the echo protocol
+            const stream = await connection.newStream(protocol, {
+                runOnLimitedConnection: true
             });
-            // send data to the remote then close the stream
-            const data = [
-                Uint8Array.from([0, 1, 2, 3]),
-                Uint8Array.from([4, 5, 6, 7]),
-                Uint8Array.from([8, 9, 0, 1])
-            ];
-            const [remoteCloseEvent, localCloseEvent] = await Promise.all([
-                // wait for the remote to close
-                pEvent(remoteStream, 'close'),
-                pEvent(localStream, 'close'),
-                (async () => {
-                    for (const buf of data) {
-                        if (!localStream.send(buf)) {
-                            await pEvent(localStream, 'drain', {
-                                rejectionEvents: [
-                                    'close'
-                                ]
-                            });
-                        }
-                    }
-                    // close the local writable end
-                    await localStream.close();
-                })()
-            ]);
-            expect(remoteCloseEvent).to.not.have.property('error', 'remote stream did not close cleanly');
-            expect(localCloseEvent).to.not.have.property('error', 'local stream did not close cleanly');
+            // keep the remote write end open, this should delay the FIN_ACK reply to the local stream
+            const p = stream.sink([]);
+            const remoteStream = await getRemoteStream.promise;
+            // close the readable end of the remote stream
+            await remoteStream.closeRead();
+            // readable end should finish
+            await drain(remoteStream.source);
+            // wait for remote to receive local close-write
+            await pRetry(() => {
+                if (remoteStream.readStatus !== 'closed') {
+                    throw new Error('Remote stream read status ' + remoteStream.readStatus);
+                }
+            }, {
+                minTimeout: 100
+            });
+            // remote closes write
+            await remoteStream.sink([]);
+            // wait to receive FIN_ACK
+            await p;
+            // close read end of stream
+            await stream.closeRead();
+            // readable end should finish
+            await drain(stream.source);
             // wait for remote to notice closure
             await pRetry(() => {
                 if (remoteStream.status !== 'closed') {
                     throw new Error('Remote stream not closed');
                 }
             });
-            // both ends should be closed
-            assertStreamClosed(localStream);
+            assertStreamClosed(stream);
             assertStreamClosed(remoteStream);
         });
-        it('can close a stream for writing but receive a large amount of data', async function () {
-            const timeout = 120_000;
-            this.timeout(timeout);
-            ({ dialer, listener, dialAddrs } = await getSetup(common));
+    });
+    describe('events', () => {
+        let dialer;
+        let listener;
+        let listenMultiaddrMatcher;
+        afterEach(async () => {
+            await stop(dialer, listener);
+            await common.teardown();
+        });
+        it('emits listening', async function () {
+            ({ dialer, listener, listenMultiaddrMatcher } = await getSetup(common));
             if (listener == null) {
                 return this.skip();
             }
-            const protocol = '/receive-data/1.0.0';
-            const chunkSize = 1024;
-            const bytes = chunkSize * 1024 * 10;
-            await listener.handle(protocol, async (stream) => {
-                for (let i = 0; i < bytes; i += chunkSize) {
-                    const sendMore = stream.send(new Uint8Array(chunkSize));
-                    if (!sendMore) {
-                        await pEvent(stream, 'drain', {
-                            rejectionEvents: [
-                                'close'
-                            ]
-                        });
-                    }
+            await listener.stop();
+            const transportListeningPromise = pDefer();
+            listener.addEventListener('transport:listening', (event) => {
+                const transportListener = event.detail;
+                if (transportListener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma))) {
+                    transportListeningPromise.resolve();
                 }
-                await stream.close();
             });
-            const stream = await dialer.dialProtocol(dialAddrs[0], protocol);
-            const [output] = await Promise.all([
-                all(stream),
-                stream.close()
-            ]);
-            expect(new Uint8ArrayList(...output).byteLength).to.equal(bytes);
+            await listener.start();
+            await raceSignal(transportListeningPromise.promise, AbortSignal.timeout(1000), {
+                errorMessage: 'Did not emit listening event'
+            });
+        });
+        it('emits close', async function () {
+            ({ dialer, listener } = await getSetup(common));
+            if (listener == null) {
+                return this.skip();
+            }
+            const transportManager = getTransportManager(listener);
+            const transportListener = transportManager.getListeners()
+                .filter(listener => listener.getAddrs().some(ma => listenMultiaddrMatcher.exactMatch(ma)))
+                .pop();
+            if (transportListener == null) {
+                throw new Error('Could not find address listener');
+            }
+            const p = pEvent(transportListener, 'close');
+            await listener.stop();
+            await raceSignal(p, AbortSignal.timeout(1000), {
+                errorMessage: 'Did not emit close event'
+            });
         });
     });
 };
@@ -444,5 +412,7 @@ function assertStreamClosed(stream) {
     expect(stream.readStatus).to.equal('closed');
     expect(stream.writeStatus).to.equal('closed');
     expect(stream.timeline.close).to.be.a('number');
+    expect(stream.timeline.closeRead).to.be.a('number');
+    expect(stream.timeline.closeWrite).to.be.a('number');
 }
 //# sourceMappingURL=index.js.map