@libp2p/interface-compliance-tests 3.0.7-7b5c54dd → 3.0.7-7debe031

package/src/stream-muxer/close-test.ts

@@ -6,9 +6,12 @@ import all from 'it-all'
 import drain from 'it-drain'
 import { duplexPair } from 'it-pair/duplex'
 import { pipe } from 'it-pipe'
+import { pbStream } from 'it-protobuf-stream'
+import toBuffer from 'it-to-buffer'
 import pDefer from 'p-defer'
 import { Uint8ArrayList } from 'uint8arraylist'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
+import { Message } from './fixtures/pb/message.js'
 import type { TestSetup } from '../index.js'
 import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
 
@@ -61,9 +64,9 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
 
       expect(dialer.streams).to.have.lengthOf(expectedStreams)
 
-      // Pause, and then send some data and close the dialer
+      // Pause, and then close the dialer
       await delay(50)
-      await pipe([randomBuffer()], dialer, drain)
+      await pipe([], dialer, drain)
 
       expect(openedStreams).to.have.equal(expectedStreams)
       expect(dialer.streams).to.have.lengthOf(0)
@@ -106,7 +109,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       // Pause, and then close the dialer
       await delay(50)
 
-      dialer.close()
+      await dialer.close()
 
       expect(openedStreams, 'listener - number of opened streams should match number of calls to newStream').to.have.equal(expectedStreams)
       expect(dialer.streams, 'all tracked streams should be deleted after the muxer has called close').to.have.lengthOf(0)
@@ -148,7 +151,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       await delay(50)
 
       // close _with an error_
-      dialer.close(new Error())
+      dialer.abort(new Error('Oh no!'))
 
       const timeoutError = new Error('timeout')
       for (const pipe of streamPipes) {
@@ -173,7 +176,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       const dialerFactory = await common.setup()
       const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
 
-      dialer.close()
+      await dialer.close()
 
       try {
         await dialer.newStream()
@@ -246,7 +249,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
         onIncomingStream: (stream) => {
           void Promise.resolve().then(async () => {
             // Immediate close for write
-            stream.closeWrite()
+            await stream.closeWrite()
 
             const results = await pipe(stream, async (source) => {
               const data = []
@@ -275,16 +278,16 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       await stream.sink(data)
 
       const err = await deferred.promise
-      expect(err).to.have.property('message').that.matches(/stream closed for writing/)
+      expect(err).to.have.property('code', 'ERR_SINK_INVALID_STATE')
     })
 
     it('can close a stream for reading', async () => {
-      const deferred = pDefer<any>()
-
+      const deferred = pDefer<Uint8ArrayList[]>()
       const p = duplexPair<Uint8Array>()
       const dialerFactory = await common.setup()
       const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
       const data = [randomBuffer(), randomBuffer()].map(d => new Uint8ArrayList(d))
+      const expected = toBuffer(data.map(d => d.subarray()))
 
       const listenerFactory = await common.setup()
       const listener = listenerFactory.createStreamMuxer({
@@ -298,7 +301,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       void pipe(p[1], listener, p[1])
 
       const stream = await dialer.newStream()
-      stream.closeRead()
+      await stream.closeRead()
 
       // Source should be done
       void Promise.resolve().then(async () => {
@@ -307,7 +310,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
       })
 
       const results = await deferred.promise
-      expect(results).to.eql(data)
+      expect(toBuffer(results.map(b => b.subarray()))).to.equalBytes(expected)
     })
 
     it('calls onStreamEnd for closed streams not previously written', async () => {
@@ -322,7 +325,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
 
       const stream = await dialer.newStream()
 
-      stream.close()
+      await stream.close()
       await deferred.promise
     })
 
@@ -338,9 +341,102 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
 
       const stream = await dialer.newStream()
 
-      stream.closeWrite()
-      stream.closeRead()
+      await stream.closeWrite()
+      await stream.closeRead()
+      await deferred.promise
+    })
+
+    it('should wait for all data to be sent when closing streams', async () => {
+      const deferred = pDefer<Message>()
+
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          const pb = pbStream(stream)
+
+          void pb.read(Message)
+            .then(async message => {
+              deferred.resolve(message)
+              await pb.unwrap().close()
+            })
+            .catch(err => {
+              deferred.reject(err)
+            })
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const message = {
+        message: 'hello world',
+        value: 5,
+        flag: true
+      }
+
+      const stream = await dialer.newStream()
+
+      const pb = pbStream(stream)
+      await pb.write(message, Message)
+      await pb.unwrap().close()
+
+      await expect(deferred.promise).to.eventually.deep.equal(message)
+    })
+    /*
+    it('should abort closing a stream with outstanding data to read', async () => {
+      const deferred = pDefer<Message>()
+
+      const p = duplexPair<Uint8Array>()
+      const dialerFactory = await common.setup()
+      const dialer = dialerFactory.createStreamMuxer({ direction: 'outbound' })
+
+      const listenerFactory = await common.setup()
+      const listener = listenerFactory.createStreamMuxer({
+        direction: 'inbound',
+        onIncomingStream: (stream) => {
+          const pb = pbStream(stream)
+
+          void pb.read(Message)
+            .then(async message => {
+              await pb.write(message, Message)
+              await pb.unwrap().close()
+              deferred.resolve(message)
+            })
+            .catch(err => {
+              deferred.reject(err)
+            })
+        }
+      })
+
+      void pipe(p[0], dialer, p[0])
+      void pipe(p[1], listener, p[1])
+
+      const message = {
+        message: 'hello world',
+        value: 5,
+        flag: true
+      }
+
+      const stream = await dialer.newStream()
+
+      const pb = pbStream(stream)
+      await pb.write(message, Message)
+
+      console.info('await write back')
       await deferred.promise
+
+      // let message arrive
+      await delay(100)
+
+      // close should time out as message is never read
+      await expect(pb.unwrap().close()).to.eventually.be.rejected
+        .with.property('code', 'ERR_CLOSE_READ_ABORTED')
     })
+    */
   })
 }

package/src/stream-muxer/fixtures/pb/message.proto

@@ -0,0 +1,7 @@
+syntax = "proto3";
+
+message Message {
+  string message = 1;
+  uint32 value = 2;
+  bool flag = 3;
+}

package/src/stream-muxer/fixtures/pb/message.ts

@@ -0,0 +1,87 @@
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+
+import { encodeMessage, decodeMessage, message } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export interface Message {
+  message: string
+  value: number
+  flag: boolean
+}
+
+export namespace Message {
+  let _codec: Codec<Message>
+
+  export const codec = (): Codec<Message> => {
+    if (_codec == null) {
+      _codec = message<Message>((obj, w, opts = {}) => {
+        if (opts.lengthDelimited !== false) {
+          w.fork()
+        }
+
+        if ((obj.message != null && obj.message !== '')) {
+          w.uint32(10)
+          w.string(obj.message)
+        }
+
+        if ((obj.value != null && obj.value !== 0)) {
+          w.uint32(16)
+          w.uint32(obj.value)
+        }
+
+        if ((obj.flag != null && obj.flag !== false)) {
+          w.uint32(24)
+          w.bool(obj.flag)
+        }
+
+        if (opts.lengthDelimited !== false) {
+          w.ldelim()
+        }
+      }, (reader, length) => {
+        const obj: any = {
+          message: '',
+          value: 0,
+          flag: false
+        }
+
+        const end = length == null ? reader.len : reader.pos + length
+
+        while (reader.pos < end) {
+          const tag = reader.uint32()
+
+          switch (tag >>> 3) {
+            case 1:
+              obj.message = reader.string()
+              break
+            case 2:
+              obj.value = reader.uint32()
+              break
+            case 3:
+              obj.flag = reader.bool()
+              break
+            default:
+              reader.skipType(tag & 7)
+              break
+          }
+        }
+
+        return obj
+      })
+    }
+
+    return _codec
+  }
+
+  export const encode = (obj: Partial<Message>): Uint8Array => {
+    return encodeMessage(obj, Message.codec())
+  }
+
+  export const decode = (buf: Uint8Array | Uint8ArrayList): Message => {
+    return decodeMessage(buf, Message.codec())
+  }
+}

package/src/stream-muxer/spawner.ts

@@ -19,9 +19,10 @@ export default async (createMuxer: (init?: StreamMuxerInit) => Promise<StreamMux
       void pipe(
         stream,
         drain
-      ).then(() => {
-        stream.close()
+      ).then(async () => {
+        await stream.close()
       })
+        .catch(err => { stream.abort(err) })
     }
   })
   const dialer = await createMuxer({ direction: 'outbound' })

package/src/stream-muxer/stress-test.ts

@@ -9,7 +9,7 @@ export default (common: TestSetup<StreamMuxerFactory>): void => {
   }
 
   describe('stress test', function () {
-    this.timeout(800000)
+    this.timeout(1600000)
 
     it('1 stream with 1 msg', async () => { await spawn(createMuxer, 1, 1) })
     it('1 stream with 10 msg', async () => { await spawn(createMuxer, 1, 10) })

package/src/transport/dial-test.ts

@@ -85,7 +85,7 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
       expect(upgradeSpy.callCount).to.equal(1)
       await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
       await conn.close()
-      expect(isValidTick(conn.stat.timeline.close)).to.equal(true)
+      expect(isValidTick(conn.timeline.close)).to.equal(true)
     })
 
     it('to non existent listener', async () => {

package/src/transport/listen-test.ts

@@ -93,12 +93,12 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
         listener.close()
       ])
 
-      stream1.close()
+      await stream1.close()
       await conn1.close()
 
-      expect(isValidTick(conn1.stat.timeline.close)).to.equal(true)
+      expect(isValidTick(conn1.timeline.close)).to.equal(true)
       listenerConns.forEach(conn => {
-        expect(isValidTick(conn.stat.timeline.close)).to.equal(true)
+        expect(isValidTick(conn.timeline.close)).to.equal(true)
       })
 
       // 2 dials = 2 connections upgraded
@@ -120,7 +120,7 @@ export default (common: TestSetup<TransportTestFixtures>): void => {
         upgrader
       })
 
-      await pWaitFor(() => typeof conn.stat.timeline.close === 'number')
+      await pWaitFor(() => typeof conn.timeline.close === 'number')
       await listener.close()
     })