@libp2p/interface-compliance-tests 6.1.8-32ca76fcb → 6.1.8-432955390

package/dist/src/transport/index.js

@@ -1,43 +1,46 @@
-import { echo } from '@libp2p/echo';
 import { stop } from '@libp2p/interface';
 import { expect } from 'aegir/chai';
 import delay from 'delay';
+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 { isValidTick } from '../is-valid-tick.js';
 import { createPeer, getTransportManager, getUpgrader, slowNetwork } from './utils.js';
+async function getSetup(common) {
+    const setup = await common.setup();
+    const dialer = await createPeer(setup.dialer);
+    let listener;
+    if (setup.listener != null) {
+        listener = await createPeer(setup.listener);
+    }
+    const dialAddrs = listener?.getMultiaddrs() ?? setup.dialAddrs;
+    if (dialAddrs == null) {
+        throw new Error('Listener config or dial addresses must be specified');
+    }
+    return {
+        dialer,
+        listener,
+        dialAddrs: dialAddrs.filter(ma => setup.dialMultiaddrMatcher.exactMatch(ma)),
+        dialMultiaddrMatcher: setup.dialMultiaddrMatcher,
+        listenMultiaddrMatcher: setup.listenMultiaddrMatcher
+    };
+}
 export default (common) => {
     describe('interface-transport', () => {
-        let dialAddrs;
-        let listenAddrs;
-        let transport;
         let dialer;
         let listener;
-        let dialOnly;
-        beforeEach(async () => {
-            ({ dialAddrs, listenAddrs = dialAddrs, transport, dialOnly = false } = await common.setup());
-        });
+        let dialAddrs;
+        let dialMultiaddrMatcher;
         afterEach(async () => {
             await stop(dialer, listener);
             await common.teardown();
         });
         it('simple', async () => {
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
-                });
-            }
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
             const input = Uint8Array.from([0, 1, 2, 3, 4]);
             const output = await dialer.services.echo.echo(dialAddrs[0], input, {
                 signal: AbortSignal.timeout(5000)
@@ -45,24 +48,7 @@ export default (common) => {
             expect(output).to.equalBytes(input);
         });
         it('should listen on multiple addresses', async () => {
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [
-                            listenAddrs[0].toString(),
-                            listenAddrs[1].toString()
-                        ]
-                    },
-                    transports: [
-                        transport
-                    ]
-                });
-            }
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
             const input = Uint8Array.from([0, 1, 2, 3, 4]);
             await expect(dialer.services.echo.echo(dialAddrs[0], input, {
                 signal: AbortSignal.timeout(5000)
@@ -72,21 +58,7 @@ export default (common) => {
             })).to.eventually.deep.equal(input);
         });
         it('can close connections', async () => {
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
-                });
-            }
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
             const conn = await dialer.dial(dialAddrs[0], {
                 signal: AbortSignal.timeout(5000)
             });
@@ -94,21 +66,7 @@ export default (common) => {
             expect(isValidTick(conn.timeline.close)).to.equal(true);
         });
         it('abort before dialing throws AbortError', async () => {
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
-                });
-            }
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
             const controller = new AbortController();
             controller.abort();
             await expect(dialer.dial(dialAddrs[0], {
@@ -117,21 +75,7 @@ export default (common) => {
                 .with.property('name', 'AbortError');
         });
         it('abort while dialing throws AbortError', async () => {
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
-                });
-            }
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
             slowNetwork(dialer, 100);
             const controller = new AbortController();
             setTimeout(() => { controller.abort(); }, 50);
@@ -141,180 +85,325 @@ export default (common) => {
                 .with.property('name', 'AbortError');
         });
         it('should close all streams when the connection closes', async () => {
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ],
-                    services: {
-                        echo: echo({
-                            maxInboundStreams: 5
-                        })
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
+            let incomingConnectionPromise;
+            if (listener != null) {
+                incomingConnectionPromise = pDefer();
+                listener.addEventListener('connection:open', (event) => {
+                    const conn = event.detail;
+                    if (conn.remotePeer.equals(dialer.peerId)) {
+                        incomingConnectionPromise?.resolve(conn);
                     }
                 });
             }
-            const connection = await dialer.dial(listenAddrs[0]);
+            const connection = await dialer.dial(dialAddrs[0]);
             let remoteConn;
-            if (listener != null) {
-                const remoteConnections = listener.getConnections(dialer.peerId);
-                expect(remoteConnections).to.have.lengthOf(1);
-                remoteConn = remoteConnections[0];
+            if (incomingConnectionPromise != null) {
+                remoteConn = await incomingConnectionPromise.promise;
             }
-            const streams = [];
             for (let i = 0; i < 5; i++) {
-                streams.push(await connection.newStream('/echo/1.0.0', {
+                await connection.newStream('/echo/1.0.0', {
                     maxOutboundStreams: 5
-                }));
+                });
             }
+            const streams = connection.streams;
             // Close the connection and verify all streams have been closed
             await connection.close();
-            await pWaitFor(() => connection.streams.length === 0);
+            await pWaitFor(() => connection.streams.length === 0, {
+                timeout: 5000
+            });
             if (remoteConn != null) {
-                await pWaitFor(() => remoteConn.streams.length === 0);
+                await pWaitFor(() => remoteConn.streams.length === 0, {
+                    timeout: 5000
+                });
             }
-            expect(streams.find(stream => stream.status !== 'closed')).to.be.undefined();
+            expect(streams.find(stream => stream.status === 'open')).to.be.undefined();
         });
         it('should not handle connection if upgradeInbound rejects', async function () {
-            if (dialOnly) {
+            ({ dialer, listener, dialAddrs, dialMultiaddrMatcher } = await getSetup(common));
+            if (listener == null) {
                 return this.skip();
             }
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
-            });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
-                });
-            }
             const upgrader = getUpgrader(listener);
             upgrader.upgradeInbound = async () => {
                 await delay(100);
                 throw new Error('Oh noes!');
             };
-            await expect(dialer.dial(listenAddrs[0])).to.eventually.be.rejected
+            await expect(dialer.dial(dialAddrs[0])).to.eventually.be.rejected
                 .with.property('name', 'EncryptionFailedError');
-            expect(dialer.getConnections()).to.have.lengthOf(0);
+            expect(dialer.getConnections().filter(conn => {
+                return dialMultiaddrMatcher.exactMatch(conn.remoteAddr);
+            })).to.have.lengthOf(0);
             if (listener != null) {
-                expect(listener.getConnections()).to.have.lengthOf(0);
+                const remoteConnections = listener.getConnections(dialer.peerId)
+                    .filter(conn => dialMultiaddrMatcher.exactMatch(conn.remoteAddr));
+                expect(remoteConnections).to.have.lengthOf(0);
             }
         });
-    });
-    describe('events', () => {
-        let listenAddrs;
-        let dialAddrs;
-        let transport;
-        let dialer;
-        let listener;
-        let dialOnly;
-        beforeEach(async () => {
-            ({ dialAddrs, listenAddrs = dialAddrs, transport, dialOnly = false } = await common.setup());
-        });
-        afterEach(async () => {
-            await stop(dialer, listener);
-            await common.teardown();
-        });
-        it('emits connection', async function () {
-            if (dialOnly) {
+        it('should omit peerid in listening addresses', async function () {
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
+            if (listener == null) {
                 return this.skip();
             }
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
+            const tm = getTransportManager(listener);
+            const transportListeners = tm.getListeners();
+            for (const transportListener of transportListeners) {
+                for (const ma of transportListener.getAddrs()) {
+                    expect(ma.toString()).to.not.include(`/p2p/${listener.peerId}`);
+                }
+            }
+        });
+        it('should handle one big write', async function () {
+            const timeout = 120_000;
+            this.timeout(timeout);
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
+            const input = new Uint8Array(1024 * 1024 * 10).fill(5);
+            const output = await dialer.services.echo.echo(dialAddrs[0], input, {
+                signal: AbortSignal.timeout(timeout)
             });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
+            expect(output).to.equalBytes(input);
+        });
+        it('should handle many small writes', async function () {
+            const timeout = 120_000;
+            this.timeout(timeout);
+            ({ dialer, listener, dialAddrs } = await getSetup(common));
+            for (let i = 0; i < 2000; i++) {
+                const input = new Uint8Array(1024).fill(5);
+                const output = await dialer.services.echo.echo(dialAddrs[0], input, {
+                    signal: AbortSignal.timeout(timeout)
                 });
+                expect(output).to.equalBytes(input);
             }
-            const transportManager = getTransportManager(listener);
-            const transportListener = transportManager.getListeners()[0];
-            const p = pEvent(transportListener, 'connection');
-            await expect(dialer.dial(dialAddrs[0])).to.eventually.be.ok();
-            await raceSignal(p, AbortSignal.timeout(1000), {
-                errorMessage: 'Did not emit connection event'
-            });
         });
-        it('emits listening', async function () {
-            if (dialOnly) {
+        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();
             }
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
+            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);
+                });
             });
-            if (!dialOnly) {
-                listener = await createPeer({
-                    addresses: {
-                        listen: [listenAddrs[0].toString()]
-                    },
-                    transports: [
-                        transport
-                    ]
+            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;
             }
-            const transportManager = getTransportManager(listener);
-            const t = transportManager.dialTransportForMultiaddr(dialAddrs[0]);
-            if (t == null) {
-                throw new Error(`No transport configured for dial address ${dialAddrs[0]}`);
+            expect(read).to.equal(bytes);
+        });
+        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();
             }
-            let p;
-            const originalCreateListener = t.createListener.bind(t);
-            t.createListener = (opts) => {
-                const listener = originalCreateListener(opts);
-                p = pEvent(listener, 'listening');
-                return listener;
+            /**
+             * NodeA             NodeB
+             * |   <--- STOP_SENDING |
+             * | FIN --->            |
+             * |            <--- FIN |
+             * | FIN_ACK --->        |
+             * |        <--- FIN_ACK |
+             */
+            const getRemoteStream = pDefer();
+            const protocol = '/close-local-while-remote-writes/1.0.0';
+            const streamHandler = ({ stream }) => {
+                void Promise.resolve().then(async () => {
+                    getRemoteStream.resolve(stream);
+                });
             };
-            await transportManager.listen([
-                listenAddrs[1]
-            ]);
-            if (p == null) {
-                throw new Error('Listener was not created');
+            await listener.handle(protocol, (info) => {
+                streamHandler(info);
+            }, {
+                runOnLimitedConnection: true
+            });
+            const connection = await dialer.dial(dialAddrs[0]);
+            // 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();
+            // keep the remote write end open, this should delay the FIN_ACK reply to the local stream
+            const remoteInputStream = pushable();
+            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);
+                }
+            }, {
+                minTimeout: 100
+            });
+            // 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');
+                }
+            });
+            assertStreamClosed(stream);
+            assertStreamClosed(remoteStream);
+        });
+        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();
             }
-            await raceSignal(p, AbortSignal.timeout(1000), {
-                errorMessage: 'Did not emit connection event'
+            /**
+             * NodeA             NodeB
+             * | FIN --->            |
+             * |            <--- FIN |
+             * | FIN_ACK --->        |
+             * |        <--- FIN_ACK |
+             */
+            const getRemoteStream = pDefer();
+            const protocol = '/close-local-while-remote-reads/1.0.0';
+            const streamHandler = ({ stream }) => {
+                void Promise.resolve().then(async () => {
+                    getRemoteStream.resolve(stream);
+                });
+            };
+            await listener.handle(protocol, (info) => {
+                streamHandler(info);
+            }, {
+                runOnLimitedConnection: true
+            });
+            const connection = await dialer.dial(dialAddrs[0]);
+            // open a stream on the echo protocol
+            const stream = await connection.newStream(protocol, {
+                runOnLimitedConnection: true
             });
+            // 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');
+                }
+            });
+            assertStreamClosed(stream);
+            assertStreamClosed(remoteStream);
         });
-        it('emits close', async function () {
-            if (dialOnly) {
+    });
+    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();
             }
-            dialer = await createPeer({
-                transports: [
-                    transport
-                ]
+            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();
+                }
             });
-            listener = await createPeer({
-                addresses: {
-                    listen: [listenAddrs[0].toString()]
-                },
-                transports: [
-                    transport
-                ]
+            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()[0];
+            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), {
@@ -323,4 +412,12 @@ export default (common) => {
         });
     });
 };
+function assertStreamClosed(stream) {
+    expect(stream.status).to.equal('closed');
+    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