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

package/src/connection/index.ts

@@ -1,166 +0,0 @@
-import { expect } from 'aegir/chai'
-import sinon from 'sinon'
-import type { TestSetup } from '../index.js'
-import type { Connection } from '@libp2p/interface'
-
-export default (test: TestSetup<Connection>): void => {
-  describe('connection', () => {
-    describe('open connection', () => {
-      let connection: Connection
-
-      beforeEach(async () => {
-        connection = await test.setup()
-      })
-
-      afterEach(async () => {
-        await connection.close()
-        await test.teardown()
-      })
-
-      it('should have properties set', () => {
-        expect(connection.id).to.exist()
-        expect(connection.remotePeer).to.exist()
-        expect(connection.remoteAddr).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', () => {
-        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', () => {
-        const streams = connection.streams
-
-        expect(streams).to.eql([])
-      })
-
-      it('should be able to create a new stream', async () => {
-        expect(connection.streams).to.be.empty()
-
-        const protocolToUse = '/echo/0.0.1'
-        const stream = await connection.newStream([protocolToUse])
-
-        expect(stream).to.have.property('protocol', protocolToUse)
-
-        const connStreams = connection.streams
-
-        expect(stream).to.exist()
-        expect(connStreams).to.exist()
-        expect(connStreams).to.have.lengthOf(1)
-        expect(connStreams[0]).to.equal(stream)
-      })
-    })
-
-    describe('close connection', () => {
-      let connection: Connection
-      let timelineProxy
-      const proxyHandler = {
-        set () {
-          // @ts-expect-error - TS fails to infer here
-          return Reflect.set(...arguments)
-        }
-      }
-
-      beforeEach(async () => {
-        timelineProxy = new Proxy({
-          open: Date.now() - 10,
-          upgraded: Date.now()
-        }, proxyHandler)
-
-        connection = await test.setup()
-        connection.timeline = timelineProxy
-      })
-
-      afterEach(async () => {
-        await test.teardown()
-      })
-
-      it('should be able to close the connection after being created', async () => {
-        expect(connection.timeline.close).to.not.exist()
-        await connection.close()
-
-        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 () => {
-        // Open stream
-        const protocol = '/echo/0.0.1'
-        await connection.newStream([protocol])
-
-        // Close connection
-        expect(connection.timeline.close).to.not.exist()
-        await connection.close()
-
-        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.property('protocol', protocol)
-
-        // Close stream
-        await stream.close()
-
-        expect(connection.streams.filter(s => s.id === stream.id)).to.be.empty()
-      })
-
-      it('should track outbound streams', async () => {
-        // Open stream
-        const protocol = '/echo/0.0.1'
-        const stream = await connection.newStream(protocol)
-        expect(stream).to.have.property('direction', 'outbound')
-      })
-
-      it('should support a proxy on the timeline', async () => {
-        sinon.spy(proxyHandler, 'set')
-        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.timeline)
-        expect(key).to.equal('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.timeline.close).to.not.exist()
-        const p = connection.close()
-
-        try {
-          const protocol = '/echo/0.0.1'
-          await connection.newStream([protocol])
-        } catch (err: any) {
-          expect(err).to.exist()
-          return
-        } finally {
-          await p
-        }
-
-        throw new Error('should fail to create a new stream if the connection is closing')
-      })
-
-      it('should fail to create a new stream if the connection is closed', async () => {
-        expect(connection.timeline.close).to.not.exist()
-        await connection.close()
-
-        await expect(connection.newStream(['/echo/0.0.1'])).to.eventually.be.rejected
-          .with.property('name', 'ConnectionClosedError')
-      })
-    })
-  })
-}

package/src/transport/dial-test.ts

@@ -1,125 +0,0 @@
-import { TypedEventEmitter } from '@libp2p/interface'
-import { expect } from 'aegir/chai'
-import all from 'it-all'
-import drain from 'it-drain'
-import { pipe } from 'it-pipe'
-import sinon from 'sinon'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { isValidTick } from '../is-valid-tick.js'
-import { mockUpgrader, mockRegistrar } from '../mocks/index.js'
-import type { TransportTestFixtures, Connector } from './index.js'
-import type { TestSetup } from '../index.js'
-import type { Listener, Transport, Upgrader } from '@libp2p/interface'
-import type { Registrar } from '@libp2p/interface-internal'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export default (common: TestSetup<TransportTestFixtures>): void => {
-  describe('dial', () => {
-    let upgrader: Upgrader
-    let registrar: Registrar
-    let listenAddrs: Multiaddr[]
-    let dialAddrs: Multiaddr[]
-    let dialer: Transport
-    let listener: Transport
-    let connector: Connector
-    let listen: Listener
-
-    before(async () => {
-      registrar = mockRegistrar()
-      upgrader = mockUpgrader({
-        registrar,
-        events: new TypedEventEmitter()
-      });
-
-      ({ listenAddrs, dialAddrs, dialer, listener, connector } = await common.setup())
-    })
-
-    after(async () => {
-      await common.teardown()
-    })
-
-    beforeEach(async () => {
-      listen = listener.createListener({
-        upgrader
-      })
-      await listen.listen(listenAddrs[0])
-    })
-
-    afterEach(async () => {
-      sinon.restore()
-      connector.restore()
-      await listen.close()
-    })
-
-    it('simple', async () => {
-      const protocol = '/hello/1.0.0'
-      void registrar.handle(protocol, (data) => {
-        void pipe([
-          uint8ArrayFromString('hey')
-        ],
-        data.stream,
-        drain
-        )
-      })
-
-      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-      const conn = await dialer.dial(dialAddrs[0], {
-        upgrader
-      })
-
-      const stream = await conn.newStream([protocol])
-      const result = await all(stream.source)
-
-      expect(upgradeSpy.callCount).to.equal(1)
-      await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
-      expect(result.length).to.equal(1)
-      expect(result[0].subarray()).to.equalBytes(uint8ArrayFromString('hey'))
-      await conn.close()
-    })
-
-    it('can close connections', async () => {
-      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-      const conn = await dialer.dial(dialAddrs[0], {
-        upgrader
-      })
-
-      expect(upgradeSpy.callCount).to.equal(1)
-      await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
-      await conn.close()
-      expect(isValidTick(conn.timeline.close)).to.equal(true)
-    })
-
-    it('to non existent listener', async () => {
-      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-
-      await expect(dialer.dial(dialAddrs[1], {
-        upgrader
-      })).to.eventually.be.rejected()
-      expect(upgradeSpy.callCount).to.equal(0)
-    })
-
-    it('abort before dialing throws AbortError', async () => {
-      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-      const controller = new AbortController()
-      controller.abort()
-      const conn = dialer.dial(dialAddrs[0], { signal: controller.signal, upgrader })
-
-      await expect(conn).to.eventually.be.rejected().with.property('name', 'AbortError')
-      expect(upgradeSpy.callCount).to.equal(0)
-    })
-
-    it('abort while dialing throws AbortError', async () => {
-      const upgradeSpy = sinon.spy(upgrader, 'upgradeOutbound')
-      // Add a delay to connect() so that we can abort while the dial is in
-      // progress
-      connector.delay(100)
-
-      const controller = new AbortController()
-      const conn = dialer.dial(dialAddrs[0], { signal: controller.signal, upgrader })
-      setTimeout(() => { controller.abort() }, 50)
-
-      await expect(conn).to.eventually.be.rejected().with.property('name', 'AbortError')
-      expect(upgradeSpy.callCount).to.equal(0)
-    })
-  })
-}

package/src/transport/filter-test.ts

@@ -1,32 +0,0 @@
-import { expect } from 'aegir/chai'
-import type { TransportTestFixtures } from './index.js'
-import type { TestSetup } from '../index.js'
-import type { Transport } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export default (common: TestSetup<TransportTestFixtures>): void => {
-  describe('filter', () => {
-    let listenAddrs: Multiaddr[]
-    let dialAddrs: Multiaddr[]
-    let dialer: Transport
-    let listener: Transport
-
-    before(async () => {
-      ({ listenAddrs, dialAddrs, dialer, listener } = await common.setup())
-    })
-
-    after(async () => {
-      await common.teardown()
-    })
-
-    it('filters listen addresses', () => {
-      const filteredAddrs = listener.listenFilter(listenAddrs)
-      expect(filteredAddrs).to.eql(listenAddrs)
-    })
-
-    it('filters dial addresses', () => {
-      const filteredAddrs = dialer.dialFilter(dialAddrs)
-      expect(filteredAddrs).to.eql(dialAddrs)
-    })
-  })
-}

package/src/transport/listen-test.ts

@@ -1,192 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-import { TypedEventEmitter } from '@libp2p/interface'
-import { expect } from 'aegir/chai'
-import drain from 'it-drain'
-import { pipe } from 'it-pipe'
-import defer from 'p-defer'
-import pWaitFor from 'p-wait-for'
-import sinon from 'sinon'
-import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { isValidTick } from '../is-valid-tick.js'
-import { mockUpgrader, mockRegistrar } from '../mocks/index.js'
-import type { TransportTestFixtures } from './index.js'
-import type { TestSetup } from '../index.js'
-import type { Connection, Transport, Upgrader } from '@libp2p/interface'
-import type { Registrar } from '@libp2p/interface-internal'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-export default (common: TestSetup<TransportTestFixtures>): void => {
-  describe('listen', () => {
-    let upgrader: Upgrader
-    let listenAddrs: Multiaddr[]
-    let dialAddrs: Multiaddr[]
-    let dialer: Transport
-    let listener: Transport
-    let registrar: Registrar
-
-    before(async () => {
-      registrar = mockRegistrar()
-      upgrader = mockUpgrader({
-        registrar,
-        events: new TypedEventEmitter()
-      });
-
-      ({ dialer, listener, listenAddrs, dialAddrs } = await common.setup())
-    })
-
-    after(async () => {
-      await common.teardown()
-    })
-
-    afterEach(() => {
-      sinon.restore()
-    })
-
-    it('simple', async () => {
-      const listen = listener.createListener({
-        upgrader
-      })
-      await listen.listen(listenAddrs[0])
-      await listen.close()
-    })
-
-    it('close listener with connections, through timeout', async () => {
-      const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
-      const listenerConns: Connection[] = []
-
-      const protocol = '/test/protocol'
-      void registrar.handle(protocol, (data) => {
-        void drain(data.stream.source)
-      })
-
-      const listen = listener.createListener({
-        upgrader,
-        handler: (conn) => {
-          listenerConns.push(conn)
-        }
-      })
-
-      // Listen
-      await listen.listen(listenAddrs[0])
-
-      // Create two connections to the listener
-      const [conn1] = await Promise.all([
-        dialer.dial(dialAddrs[0], {
-          upgrader
-        }),
-        dialer.dial(dialAddrs[0], {
-          upgrader
-        })
-      ])
-
-      // Give the listener a chance to finish its upgrade
-      await pWaitFor(() => listenerConns.length === 2)
-
-      const stream1 = await conn1.newStream([protocol])
-
-      // Wait for the data send and close to finish
-      await Promise.all([
-        pipe(
-          [uint8ArrayFromString('Some data that is never handled')],
-          stream1
-        ),
-        // Closer the listener (will take a couple of seconds to time out)
-        listen.close()
-      ])
-
-      await stream1.close()
-      await conn1.close()
-
-      expect(isValidTick(conn1.timeline.close)).to.equal(true)
-      listenerConns.forEach(conn => {
-        expect(isValidTick(conn.timeline.close)).to.equal(true)
-      })
-
-      // 2 dials = 2 connections upgraded
-      expect(upgradeSpy.callCount).to.equal(2)
-    })
-
-    it('should not handle connection if upgradeInbound rejects', async () => {
-      sinon.stub(upgrader, 'upgradeInbound').rejects()
-
-      const listen = listener.createListener({
-        upgrader
-      })
-
-      // Listen
-      await listen.listen(listenAddrs[0])
-
-      // Create a connection to the listener
-      const conn = await dialer.dial(dialAddrs[0], {
-        upgrader
-      })
-
-      await pWaitFor(() => typeof conn.timeline.close === 'number')
-      await listen.close()
-    })
-
-    describe('events', () => {
-      it('connection', async () => {
-        const upgradeSpy = sinon.spy(upgrader, 'upgradeInbound')
-        const listen = listener.createListener({
-          upgrader
-        })
-        const deferred = defer()
-        let conn
-
-        listen.addEventListener('connection', (evt) => {
-          conn = evt.detail
-          deferred.resolve()
-        })
-
-        void (async () => {
-          await listen.listen(listenAddrs[0])
-          await dialer.dial(dialAddrs[0], {
-            upgrader
-          })
-        })()
-
-        await deferred.promise
-
-        await expect(upgradeSpy.getCall(0).returnValue).to.eventually.equal(conn)
-        expect(upgradeSpy.callCount).to.equal(1)
-        await listen.close()
-      })
-
-      it('listening', (done) => {
-        const listen = listener.createListener({
-          upgrader
-        })
-        listen.addEventListener('listening', () => {
-          listen.close().then(done, done)
-        })
-        void listen.listen(listenAddrs[0])
-      })
-
-      it('error', (done) => {
-        const listen = listener.createListener({
-          upgrader
-        })
-        listen.addEventListener('error', (evt) => {
-          expect(evt.detail).to.be.an.instanceOf(Error)
-          listen.close().then(done, done)
-        })
-        listen.dispatchEvent(new CustomEvent('error', {
-          detail: new Error('my err')
-        }))
-      })
-
-      it('close', (done) => {
-        const listen = listener.createListener({
-          upgrader
-        })
-        listen.addEventListener('close', () => { done() })
-
-        void (async () => {
-          await listen.listen(listenAddrs[0])
-          await listen.close()
-        })()
-      })
-    })
-  })
-}