@libp2p/interface-compliance-tests 3.0.7-6fdaa7dc → 3.0.7-791f56f0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-compliance-tests",
-  "version": "3.0.7-6fdaa7dc",
+  "version": "3.0.7-791f56f0",
   "description": "Compliance tests for JS libp2p interfaces",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/interface-compliance-tests#readme",
@@ -68,6 +68,10 @@
       "types": "./dist/src/peers.d.ts",
       "import": "./dist/src/peers.js"
     },
+    "./pubsub": {
+      "types": "./dist/src/pubsub/index.d.ts",
+      "import": "./dist/src/pubsub/index.js"
+    },
     "./stream-muxer": {
       "types": "./dist/src/stream-muxer/index.d.ts",
       "import": "./dist/src/stream-muxer/index.js"
@@ -88,6 +92,7 @@
     "lint": "aegir lint",
     "dep-check": "aegir dep-check",
     "build": "aegir build",
+    "generate": "protons src/stream-muxer/fixtures/pb/message.proto",
     "test": "aegir test",
     "test:chrome": "aegir test -t browser --cov",
     "test:chrome-webworker": "aegir test -t webworker",
@@ -97,16 +102,15 @@
     "test:electron-main": "aegir test -t electron-main"
   },
   "dependencies": {
-    "@libp2p/interface": "0.0.1-6fdaa7dc",
-    "@libp2p/interface-internal": "0.0.1-6fdaa7dc",
-    "@libp2p/logger": "2.1.1-6fdaa7dc",
-    "@libp2p/multistream-select": "3.1.9-6fdaa7dc",
-    "@libp2p/peer-collections": "3.0.2-6fdaa7dc",
-    "@libp2p/peer-id": "2.0.3-6fdaa7dc",
-    "@libp2p/peer-id-factory": "2.0.3-6fdaa7dc",
+    "@libp2p/interface": "0.0.1-791f56f0",
+    "@libp2p/interface-internal": "0.0.1-791f56f0",
+    "@libp2p/logger": "2.1.1-791f56f0",
+    "@libp2p/multistream-select": "3.1.9-791f56f0",
+    "@libp2p/peer-collections": "3.0.2-791f56f0",
+    "@libp2p/peer-id": "2.0.3-791f56f0",
+    "@libp2p/peer-id-factory": "2.0.3-791f56f0",
     "@multiformats/multiaddr": "^12.1.3",
     "abortable-iterator": "^5.0.1",
-    "any-signal": "^4.1.1",
     "delay": "^6.0.0",
     "it-all": "^3.0.2",
     "it-drain": "^3.0.2",
@@ -114,20 +118,25 @@
     "it-map": "^3.0.3",
     "it-ndjson": "^1.0.3",
     "it-pair": "^2.0.6",
+    "it-protobuf-stream": "^1.0.0",
     "it-pipe": "^3.0.1",
-    "it-pushable": "^3.1.3",
+    "it-pushable": "^3.2.0",
     "it-stream-types": "^2.0.1",
+    "it-to-buffer": "^4.0.2",
     "merge-options": "^3.0.4",
     "p-defer": "^4.0.0",
+    "p-event": "^6.0.0",
     "p-limit": "^4.0.0",
     "p-wait-for": "^5.0.2",
+    "protons-runtime": "^5.0.0",
     "sinon": "^15.1.2",
     "ts-sinon": "^2.0.2",
     "uint8arraylist": "^2.4.3",
     "uint8arrays": "^4.0.4"
   },
   "devDependencies": {
-    "aegir": "^39.0.10"
+    "aegir": "^39.0.13",
+    "protons": "^7.0.2"
   },
   "typedoc": {
     "entryPoint": "./src/index.ts"

package/src/connection/index.ts

@@ -22,21 +22,19 @@ export default (test: TestSetup<Connection>): void => {
         expect(connection.id).to.exist()
         expect(connection.remotePeer).to.exist()
         expect(connection.remoteAddr).to.exist()
-        expect(connection.stat.status).to.equal('OPEN')
-        expect(connection.stat.timeline.open).to.exist()
-        expect(connection.stat.timeline.close).to.not.exist()
-        expect(connection.stat.direction).to.exist()
+        expect(connection.status).to.equal('open')
+        expect(connection.timeline.open).to.exist()
+        expect(connection.timeline.close).to.not.exist()
+        expect(connection.direction).to.exist()
         expect(connection.streams).to.eql([])
         expect(connection.tags).to.eql([])
       })
 
       it('should get the metadata of an open connection', () => {
-        const stat = connection.stat
-
-        expect(stat.status).to.equal('OPEN')
-        expect(stat.direction).to.exist()
-        expect(stat.timeline.open).to.exist()
-        expect(stat.timeline.close).to.not.exist()
+        expect(connection.status).to.equal('open')
+        expect(connection.direction).to.exist()
+        expect(connection.timeline.open).to.exist()
+        expect(connection.timeline.close).to.not.exist()
       })
 
       it('should return an empty array of streams', () => {
@@ -51,7 +49,7 @@ export default (test: TestSetup<Connection>): void => {
         const protocolToUse = '/echo/0.0.1'
         const stream = await connection.newStream([protocolToUse])
 
-        expect(stream).to.have.nested.property('stat.protocol', protocolToUse)
+        expect(stream).to.have.property('protocol', protocolToUse)
 
         const connStreams = connection.streams
 
@@ -79,7 +77,7 @@ export default (test: TestSetup<Connection>): void => {
         }, proxyHandler)
 
         connection = await test.setup()
-        connection.stat.timeline = timelineProxy
+        connection.timeline = timelineProxy
       })
 
       afterEach(async () => {
@@ -87,11 +85,11 @@ export default (test: TestSetup<Connection>): void => {
       })
 
       it('should be able to close the connection after being created', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         await connection.close()
 
-        expect(connection.stat.timeline.close).to.exist()
-        expect(connection.stat.status).to.equal('CLOSED')
+        expect(connection.timeline.close).to.exist()
+        expect(connection.status).to.equal('closed')
       })
 
       it('should be able to close the connection after opening a stream', async () => {
@@ -100,21 +98,21 @@ export default (test: TestSetup<Connection>): void => {
         await connection.newStream([protocol])
 
         // Close connection
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         await connection.close()
 
-        expect(connection.stat.timeline.close).to.exist()
-        expect(connection.stat.status).to.equal('CLOSED')
+        expect(connection.timeline.close).to.exist()
+        expect(connection.status).to.equal('closed')
       })
 
       it('should properly track streams', async () => {
         // Open stream
         const protocol = '/echo/0.0.1'
         const stream = await connection.newStream([protocol])
-        expect(stream).to.have.nested.property('stat.protocol', protocol)
+        expect(stream).to.have.property('protocol', protocol)
 
         // Close stream
-        stream.close()
+        await stream.close()
 
         expect(connection.streams.filter(s => s.id === stream.id)).to.be.empty()
       })
@@ -123,7 +121,7 @@ export default (test: TestSetup<Connection>): void => {
         // Open stream
         const protocol = '/echo/0.0.1'
         const stream = await connection.newStream(protocol)
-        expect(stream).to.have.nested.property('stat.direction', 'outbound')
+        expect(stream).to.have.property('direction', 'outbound')
       })
 
       it.skip('should track inbound streams', async () => {
@@ -135,20 +133,20 @@ export default (test: TestSetup<Connection>): void => {
 
       it('should support a proxy on the timeline', async () => {
         sinon.spy(proxyHandler, 'set')
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
 
         await connection.close()
         // @ts-expect-error - fails to infer callCount
         expect(proxyHandler.set.callCount).to.equal(1)
         // @ts-expect-error - fails to infer getCall
         const [obj, key, value] = proxyHandler.set.getCall(0).args
-        expect(obj).to.eql(connection.stat.timeline)
+        expect(obj).to.eql(connection.timeline)
         expect(key).to.equal('close')
-        expect(value).to.be.a('number').that.equals(connection.stat.timeline.close)
+        expect(value).to.be.a('number').that.equals(connection.timeline.close)
       })
 
       it('should fail to create a new stream if the connection is closing', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         const p = connection.close()
 
         try {
@@ -165,7 +163,7 @@ export default (test: TestSetup<Connection>): void => {
       })
 
       it('should fail to create a new stream if the connection is closed', async () => {
-        expect(connection.stat.timeline.close).to.not.exist()
+        expect(connection.timeline.close).to.not.exist()
         await connection.close()
 
         try {

package/src/connection-encryption/utils/index.ts

@@ -10,6 +10,7 @@ export function createMaConnPair (): [MultiaddrConnection, MultiaddrConnection]
     const output: MultiaddrConnection = {
       ...duplex,
       close: async () => {},
+      abort: () => {},
       remoteAddr: multiaddr('/ip4/127.0.0.1/tcp/4001'),
       timeline: {
         open: Date.now()

package/src/mocks/connection-manager.ts

@@ -4,11 +4,12 @@ import { PeerMap } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { isMultiaddr, type Multiaddr } from '@multiformats/multiaddr'
 import { connectionPair } from './connection.js'
-import type { Libp2pEvents } from '@libp2p/interface'
+import type { Libp2pEvents, PendingDial } from '@libp2p/interface'
 import type { Connection } from '@libp2p/interface/connection'
 import type { EventEmitter } from '@libp2p/interface/events'
+import type { PubSub } from '@libp2p/interface/pubsub'
 import type { Startable } from '@libp2p/interface/startable'
-import type { ConnectionManager, PendingDial } from '@libp2p/interface-internal/connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Registrar } from '@libp2p/interface-internal/registrar'
 
 export interface MockNetworkComponents {
@@ -16,6 +17,7 @@ export interface MockNetworkComponents {
   registrar: Registrar
   connectionManager: ConnectionManager
   events: EventEmitter<Libp2pEvents>
+  pubsub?: PubSub
 }
 
 class MockNetwork {

package/src/mocks/connection.ts

@@ -1,4 +1,3 @@
-import * as STATUS from '@libp2p/interface/connection/status'
 import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import * as mss from '@libp2p/multistream-select'
@@ -9,7 +8,7 @@ import { mockMultiaddrConnection } from './multiaddr-connection.js'
 import { mockMuxer } from './muxer.js'
 import { mockRegistrar } from './registrar.js'
 import type { AbortOptions } from '@libp2p/interface'
-import type { MultiaddrConnection, Connection, Stream, ConnectionStat, Direction } from '@libp2p/interface/connection'
+import type { MultiaddrConnection, Connection, Stream, Direction, ConnectionTimeline, ConnectionStatus } from '@libp2p/interface/connection'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
 import type { Registrar } from '@libp2p/interface-internal/registrar'
@@ -38,7 +37,10 @@ class MockConnection implements Connection {
   public remoteAddr: Multiaddr
   public remotePeer: PeerId
   public direction: Direction
-  public stat: ConnectionStat
+  public timeline: ConnectionTimeline
+  public multiplexer?: string
+  public encryption?: string
+  public status: ConnectionStatus
   public streams: Stream[]
   public tags: string[]
 
@@ -52,13 +54,11 @@ class MockConnection implements Connection {
     this.remoteAddr = remoteAddr
     this.remotePeer = remotePeer
     this.direction = direction
-    this.stat = {
-      status: STATUS.OPEN,
-      direction,
-      timeline: maConn.timeline,
-      multiplexer: 'test-multiplexer',
-      encryption: 'yes-yes-very-secure'
-    }
+    this.status = 'open'
+    this.direction = direction
+    this.timeline = maConn.timeline
+    this.multiplexer = 'test-multiplexer'
+    this.encryption = 'yes-yes-very-secure'
     this.streams = []
     this.tags = []
     this.muxer = muxer
@@ -74,7 +74,7 @@ class MockConnection implements Connection {
       throw new Error('protocols must have a length')
     }
 
-    if (this.stat.status !== STATUS.OPEN) {
+    if (this.status !== 'open') {
       throw new CodeError('connection must be open to create streams', 'ERR_CONNECTION_CLOSED')
     }
 
@@ -82,19 +82,14 @@ class MockConnection implements Connection {
     const stream = await this.muxer.newStream(id)
     const result = await mss.select(stream, protocols, options)
 
-    const streamWithProtocol: Stream = {
-      ...stream,
-      ...result.stream,
-      stat: {
-        ...stream.stat,
-        direction: 'outbound',
-        protocol: result.protocol
-      }
-    }
+    stream.protocol = result.protocol
+    stream.direction = 'outbound'
+    stream.sink = result.stream.sink
+    stream.source = result.stream.source
 
-    this.streams.push(streamWithProtocol)
+    this.streams.push(stream)
 
-    return streamWithProtocol
+    return stream
   }
 
   addStream (stream: Stream): void {
@@ -105,14 +100,24 @@ class MockConnection implements Connection {
     this.streams = this.streams.filter(stream => stream.id !== id)
   }
 
-  async close (): Promise<void> {
-    this.stat.status = STATUS.CLOSING
+  async close (options?: AbortOptions): Promise<void> {
+    this.status = 'closing'
+    await Promise.all(
+      this.streams.map(async s => s.close(options))
+    )
     await this.maConn.close()
+    this.status = 'closed'
+    this.timeline.close = Date.now()
+  }
+
+  abort (err: Error): void {
+    this.status = 'closing'
     this.streams.forEach(s => {
-      s.close()
+      s.abort(err)
     })
-    this.stat.status = STATUS.CLOSED
-    this.stat.timeline.close = Date.now()
+    this.maConn.abort(err)
+    this.status = 'closed'
+    this.timeline.close = Date.now()
   }
 }
 
@@ -136,8 +141,9 @@ export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectio
         mss.handle(muxedStream, registrar.getProtocols())
           .then(({ stream, protocol }) => {
             log('%s: incoming stream opened on %s', direction, protocol)
-            muxedStream = { ...muxedStream, ...stream }
-            muxedStream.stat.protocol = protocol
+            muxedStream.protocol = protocol
+            muxedStream.sink = stream.sink
+            muxedStream.source = stream.source
 
             connection.addStream(muxedStream)
             const { handler } = registrar.getHandler(protocol)
@@ -173,20 +179,20 @@ export function mockConnection (maConn: MultiaddrConnection, opts: MockConnectio
 export function mockStream (stream: Duplex<AsyncGenerator<Uint8ArrayList>, Source<Uint8ArrayList | Uint8Array>, Promise<void>>): Stream {
   return {
     ...stream,
-    close: () => {},
-    closeRead: () => {},
-    closeWrite: () => {},
+    close: async () => {},
+    closeRead: async () => {},
+    closeWrite: async () => {},
     abort: () => {},
-    reset: () => {},
-    stat: {
-      direction: 'outbound',
-      protocol: '/foo/1.0.0',
-      timeline: {
-        open: Date.now()
-      }
+    direction: 'outbound',
+    protocol: '/foo/1.0.0',
+    timeline: {
+      open: Date.now()
     },
     metadata: {},
-    id: `stream-${Date.now()}`
+    id: `stream-${Date.now()}`,
+    status: 'open',
+    readStatus: 'ready',
+    writeStatus: 'ready'
   }
 }
 

package/src/mocks/multiaddr-connection.ts

@@ -11,6 +11,7 @@ export function mockMultiaddrConnection (source: Duplex<AsyncGenerator<Uint8Arra
     async close () {
 
     },
+    abort: () => {},
     timeline: {
       open: Date.now()
     },
@@ -44,6 +45,10 @@ export function mockMultiaddrConnPair (opts: MockMultiaddrConnPairOptions): { in
     close: async () => {
       outbound.timeline.close = Date.now()
       controller.abort()
+    },
+    abort: (err: Error) => {
+      outbound.timeline.close = Date.now()
+      controller.abort(err)
     }
   }
 
@@ -56,6 +61,10 @@ export function mockMultiaddrConnPair (opts: MockMultiaddrConnPairOptions): { in
     close: async () => {
       inbound.timeline.close = Date.now()
       controller.abort()
+    },
+    abort: (err: Error) => {
+      outbound.timeline.close = Date.now()
+      controller.abort(err)
     }
   }