@libp2p/interface-compliance-tests 1.1.7 → 1.1.8

package/src/pubsub/messages.ts

@@ -1,23 +1,30 @@
 import { expect } from 'aegir/utils/chai.js'
 import sinon from 'sinon'
-import * as PeerIdFactory from '@libp2p/peer-id-factory'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import * as utils from '@libp2p/pubsub/utils'
+import { noSignMsgId } from '@libp2p/pubsub/utils'
 import { PeerStreams } from '@libp2p/pubsub/peer-streams'
 import type { TestSetup } from '../index.js'
-import type { PubSub } from '@libp2p/interfaces/pubsub'
+import type { PubSub, PubSubOptions, RPC } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import { mockRegistrar } from '../mocks/registrar.js'
+import pDefer from 'p-defer'
+import delay from 'delay'
 
 const topic = 'foo'
 const data = uint8ArrayFromString('bar')
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
   describe('messages', () => {
     let pubsub: PubSub<EventMap>
 
     // Create pubsub router
     beforeEach(async () => {
-      pubsub = await common.setup()
+      pubsub = await common.setup({
+        peerId: await createEd25519PeerId(),
+        registrar: mockRegistrar(),
+        emitSelf: true
+      })
       await pubsub.start()
     })
 
@@ -29,14 +36,14 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
 
     it('should emit normalized signed messages on publish', async () => {
       pubsub.globalSignaturePolicy = 'StrictSign'
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
+
+      const spy = sinon.spy(pubsub, 'emitMessage')
 
       await pubsub.publish(topic, data)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage.callCount).to.eql(1)
-      // @ts-expect-error protected field
-      const [messageToEmit] = pubsub._emitMessage.getCall(0).args
+
+      expect(spy).to.have.property('callCount', 1)
+
+      const [messageToEmit] = spy.getCall(0).args
 
       expect(messageToEmit.seqno).to.not.eql(undefined)
       expect(messageToEmit.key).to.not.eql(undefined)
@@ -44,68 +51,75 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
     })
 
     it('should drop unsigned messages', async () => {
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_publish')
+      const emitMessageSpy = sinon.spy(pubsub, 'emitMessage')
+      // @ts-expect-error protected abstract field
+      const publishSpy = sinon.spy(pubsub, '_publish')
       sinon.spy(pubsub, 'validate')
 
       const peerStream = new PeerStreams({
-        id: await PeerIdFactory.createEd25519PeerId(),
+        id: await createEd25519PeerId(),
         protocol: 'test'
       })
-      const rpc = {
+      const rpc: RPC = {
         subscriptions: [],
         msgs: [{
-          receivedFrom: peerStream.id.toString(),
           from: peerStream.id.toBytes(),
           data,
-          seqno: utils.randomSeqno(),
+          seqno: await noSignMsgId(data),
           topicIDs: [topic]
         }]
       }
 
       pubsub.subscribe(topic)
-      // @ts-expect-error protected field
-      await pubsub._processRpc(peerStream.id.toString(), peerStream, rpc)
+
+      await pubsub.processRpc(peerStream.id, peerStream, rpc)
+
+      // message should not be delivered
+      await delay(1000)
 
       expect(pubsub.validate).to.have.property('callCount', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage).to.have.property('called', false)
-      // @ts-expect-error protected field
-      expect(pubsub._publish).to.have.property('called', false)
+      expect(emitMessageSpy).to.have.property('called', false)
+      expect(publishSpy).to.have.property('called', false)
     })
 
     it('should not drop unsigned messages if strict signing is disabled', async () => {
       pubsub.globalSignaturePolicy = 'StrictNoSign'
+
+      const emitMessageSpy = sinon.spy(pubsub, 'emitMessage')
       // @ts-expect-error protected field
-      sinon.spy(pubsub, '_emitMessage')
-      // @ts-expect-error protected field
-      sinon.spy(pubsub, '_publish')
+      const publishSpy = sinon.spy(pubsub, '_publish')
       sinon.spy(pubsub, 'validate')
 
       const peerStream = new PeerStreams({
-        id: await PeerIdFactory.createEd25519PeerId(),
+        id: await createEd25519PeerId(),
         protocol: 'test'
       })
 
-      const rpc = {
+      const rpc: RPC = {
         subscriptions: [],
         msgs: [{
+          from: peerStream.id.toBytes(),
           data,
           topicIDs: [topic]
         }]
       }
 
       pubsub.subscribe(topic)
-      // @ts-expect-error protected field
-      await pubsub._processRpc(peerStream.id.toString(), peerStream, rpc)
+
+      const deferred = pDefer()
+
+      await pubsub.processRpc(peerStream.id, peerStream, rpc)
+
+      pubsub.addEventListener(topic, () => {
+        deferred.resolve()
+      })
+
+      // await message delivery
+      await deferred.promise
 
       expect(pubsub.validate).to.have.property('callCount', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._emitMessage).to.have.property('called', 1)
-      // @ts-expect-error protected field
-      expect(pubsub._publish).to.have.property('called', 1)
+      expect(emitMessageSpy).to.have.property('callCount', 1)
+      expect(publishSpy).to.have.property('callCount', 1)
     })
   })
 }

package/src/pubsub/multiple-nodes.ts

@@ -6,12 +6,15 @@ import pDefer from 'p-defer'
 import pWaitFor from 'p-wait-for'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { expectSet } from './utils.js'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message } from '@libp2p/interfaces/pubsub'
+import type { PubSub, Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
   describe('pubsub with multiple nodes', function () {
     describe('every peer subscribes to the topic', () => {
       describe('line', () => {
@@ -21,36 +24,62 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         let psA: PubSub<EventMap>
         let psB: PubSub<EventMap>
         let psC: PubSub<EventMap>
+        let peerIdA: PeerId
+        let peerIdB: PeerId
+        let peerIdC: PeerId
+        let registrarA: Registrar
+        let registrarB: Registrar
+        let registrarC: Registrar
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          psA = await common.setup()
-          psB = await common.setup()
-          psC = await common.setup()
+          peerIdA = await createEd25519PeerId()
+          peerIdB = await createEd25519PeerId()
+          peerIdC = await createEd25519PeerId()
+
+          registrarA = mockRegistrar()
+          registrarB = mockRegistrar()
+          registrarC = mockRegistrar()
+
+          psA = await common.setup({
+            peerId: peerIdA,
+            registrar: registrarA
+          })
+          psB = await common.setup({
+            peerId: peerIdB,
+            registrar: registrarB
+          })
+          psC = await common.setup({
+            peerId: peerIdC,
+            registrar: registrarC
+          })
 
           // Start pubsub modes
-          ;[psA, psB, psC].map((p) => p.start())
+          await Promise.all(
+            [psA, psB, psC].map((p) => p.start())
+          )
         })
 
         // Connect nodes
         beforeEach(async () => {
-          // @ts-expect-error protected field
-          await psA._libp2p.dial(psB.peerId)
-          // @ts-expect-error protected field
-          await psB._libp2p.dial(psC.peerId)
+          await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerIdA, peerIdB)
+          await connectPeers(psB.multicodecs[0], registrarB, registrarC, peerIdB, peerIdC)
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
-            psA.peers.size === 1 &&
-            psC.peers.size === 1 &&
-            psA.peers.size === 1
+            psA.getPeers().length === 1 &&
+            psC.getPeers().length === 1 &&
+            psA.getPeers().length === 1
           )
         })
 
         afterEach(async () => {
           sinon.restore()
 
-          ;[psA, psB, psC].map((p) => p.stop())
+          await Promise.all(
+            [psA, psB, psC].map((p) => p.stop())
+          )
+
           await common.teardown()
         })
 
@@ -58,24 +87,23 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const topic = 'Z'
 
           psA.subscribe(topic)
-          expectSet(psA.subscriptions, [topic])
+          expect(psA.getTopics()).to.deep.equal([topic])
 
           await new Promise((resolve) => psB.addEventListener('pubsub:subscription-change', resolve, {
             once: true
           }))
-          expect(psB.peers.size).to.equal(2)
+          expect(psB.getPeers().length).to.equal(2)
 
-          const aPeerId = psA.peerId.toString()
-          expectSet(psB.topics.get(topic), [aPeerId])
+          expect(psB.getSubscribers(topic)).to.deep.equal([peerIdA])
 
-          expect(psC.peers.size).to.equal(1)
-          expect(psC.topics.get(topic)).to.eql(undefined)
+          expect(psC.getPeers().length).to.equal(1)
+          expect(psC.getSubscribers(topic)).to.be.empty()
         })
 
         it('subscribe to the topic on node b', async () => {
           const topic = 'Z'
           psB.subscribe(topic)
-          expectSet(psB.subscriptions, [topic])
+          expect(psB.getTopics()).to.deep.equal([topic])
 
           await Promise.all([
             new Promise((resolve) => psA.addEventListener('pubsub:subscription-change', resolve, {
@@ -86,11 +114,11 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
             }))
           ])
 
-          expect(psA.peers.size).to.equal(1)
-          expectSet(psA.topics.get(topic), [psB.peerId.toString()])
+          expect(psA.getPeers().length).to.equal(1)
+          expect(psA.getSubscribers(topic)).to.deep.equal([peerIdB])
 
-          expect(psC.peers.size).to.equal(1)
-          expectSet(psC.topics.get(topic), [psB.peerId.toString()])
+          expect(psC.getPeers().length).to.equal(1)
+          expect(psC.getSubscribers(topic)).to.deep.equal([peerIdB])
         })
 
         it('subscribe to the topic on node c', async () => {
@@ -98,12 +126,12 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
           const defer = pDefer()
 
           psC.subscribe(topic)
-          expectSet(psC.subscriptions, [topic])
+          expect(psC.getTopics()).to.deep.equal([topic])
 
           psB.addEventListener('pubsub:subscription-change', () => {
-            expect(psA.peers.size).to.equal(1)
-            expect(psB.peers.size).to.equal(2)
-            expectSet(psB.topics.get(topic), [psC.peerId.toString()])
+            expect(psA.getPeers().length).to.equal(1)
+            expect(psB.getPeers().length).to.equal(2)
+            expect(psB.getSubscribers(topic)).to.deep.equal([peerIdC])
 
             defer.resolve()
           }, {
@@ -236,56 +264,93 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
         let psC: PubSub<EventMap>
         let psD: PubSub<EventMap>
         let psE: PubSub<EventMap>
+        let peerIdA: PeerId
+        let peerIdB: PeerId
+        let peerIdC: PeerId
+        let peerIdD: PeerId
+        let peerIdE: PeerId
+        let registrarA: Registrar
+        let registrarB: Registrar
+        let registrarC: Registrar
+        let registrarD: Registrar
+        let registrarE: Registrar
 
         // Create and start pubsub nodes
         beforeEach(async () => {
-          psA = await common.setup()
-          psB = await common.setup()
-          psC = await common.setup()
-          psD = await common.setup()
-          psE = await common.setup()
+          peerIdA = await createEd25519PeerId()
+          peerIdB = await createEd25519PeerId()
+          peerIdC = await createEd25519PeerId()
+          peerIdD = await createEd25519PeerId()
+          peerIdE = await createEd25519PeerId()
+
+          registrarA = mockRegistrar()
+          registrarB = mockRegistrar()
+          registrarC = mockRegistrar()
+          registrarD = mockRegistrar()
+          registrarE = mockRegistrar()
+
+          psA = await common.setup({
+            peerId: peerIdA,
+            registrar: registrarA
+          })
+          psB = await common.setup({
+            peerId: peerIdB,
+            registrar: registrarB
+          })
+          psC = await common.setup({
+            peerId: peerIdC,
+            registrar: registrarC
+          })
+          psD = await common.setup({
+            peerId: peerIdD,
+            registrar: registrarD
+          })
+          psE = await common.setup({
+            peerId: peerIdE,
+            registrar: registrarE
+          })
 
           // Start pubsub nodes
-          ;[psA, psB, psC, psD, psE].map((p) => p.start())
+          await Promise.all(
+            [psA, psB, psC, psD, psE].map((p) => p.start())
+          )
         })
 
         // connect nodes
         beforeEach(async () => {
-          // @ts-expect-error protected field
-          await psA._libp2p.dial(psB.peerId)
-          // @ts-expect-error protected field
-          await psB._libp2p.dial(psC.peerId)
-          // @ts-expect-error protected field
-          await psC._libp2p.dial(psD.peerId)
-          // @ts-expect-error protected field
-          await psD._libp2p.dial(psE.peerId)
+          await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerIdA, peerIdB)
+          await connectPeers(psA.multicodecs[0], registrarB, registrarC, peerIdB, peerIdC)
+          await connectPeers(psA.multicodecs[0], registrarC, registrarD, peerIdC, peerIdD)
+          await connectPeers(psA.multicodecs[0], registrarD, registrarE, peerIdD, peerIdE)
 
           // Wait for peers to be ready in pubsub
           await pWaitFor(() =>
-            psA.peers.size === 1 &&
-            psB.peers.size === 2 &&
-            psC.peers.size === 2 &&
-            psD.peers.size === 2 &&
-            psE.peers.size === 1
+            psA.getPeers().length === 1 &&
+            psB.getPeers().length === 2 &&
+            psC.getPeers().length === 2 &&
+            psD.getPeers().length === 2 &&
+            psE.getPeers().length === 1
           )
         })
 
         afterEach(async () => {
-          [psA, psB, psC, psD, psE].map((p) => p.stop())
+          await Promise.all(
+            [psA, psB, psC, psD, psE].map((p) => p.stop())
+          )
           await common.teardown()
         })
 
         it('subscribes', () => {
           psA.subscribe('Z')
-          expectSet(psA.subscriptions, ['Z'])
+          expect(psA.getTopics()).to.deep.equal(['Z'])
           psB.subscribe('Z')
-          expectSet(psB.subscriptions, ['Z'])
+          expect(psB.getTopics()).to.deep.equal(['Z'])
           psC.subscribe('Z')
-          expectSet(psC.subscriptions, ['Z'])
+          expect(psC.getTopics()).to.deep.equal(['Z'])
           psD.subscribe('Z')
-          expectSet(psD.subscriptions, ['Z'])
+          expect(psD.getTopics()).to.deep.equal(['Z'])
           psE.subscribe('Z')
-          expectSet(psE.subscriptions, ['Z'])
+          expect(psE.getTopics()).to.deep.equal(['Z'])
         })
 
         it('publishes from c', async function () {

package/src/pubsub/two-nodes.ts

@@ -6,12 +6,12 @@ import pWaitFor from 'p-wait-for'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
 import type { TestSetup } from '../index.js'
-import type { PubSub, Message } from '@libp2p/interfaces/pubsub'
-import {
-  first,
-  expectSet
-} from './utils.js'
+import type { PubSub, Message, PubSubOptions } from '@libp2p/interfaces/pubsub'
 import type { EventMap } from './index.js'
+import { connectPeers, mockRegistrar } from '../mocks/registrar.js'
+import type { PeerId } from '@libp2p/interfaces/src/peer-id'
+import type { Registrar } from '@libp2p/interfaces/src/registrar'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 
 const topic = 'foo'
 
@@ -19,28 +19,43 @@ function shouldNotHappen () {
   expect.fail()
 }
 
-export default (common: TestSetup<PubSub<EventMap>>) => {
+export default (common: TestSetup<PubSub<EventMap>, PubSubOptions>) => {
   describe('pubsub with two nodes', () => {
     let psA: PubSub<EventMap>
     let psB: PubSub<EventMap>
+    let peerIdA: PeerId
+    let peerIdB: PeerId
+    let registrarA: Registrar
+    let registrarB: Registrar
 
     // Create pubsub nodes and connect them
     before(async () => {
-      psA = await common.setup()
-      psB = await common.setup()
+      peerIdA = await createEd25519PeerId()
+      peerIdB = await createEd25519PeerId()
 
-      expect(psA.peers.size).to.be.eql(0)
-      expect(psB.peers.size).to.be.eql(0)
+      registrarA = mockRegistrar()
+      registrarB = mockRegistrar()
+
+      psA = await common.setup({
+        peerId: peerIdA,
+        registrar: registrarA
+      })
+      psB = await common.setup({
+        peerId: peerIdB,
+        registrar: registrarB
+      })
 
       // Start pubsub and connect nodes
       await psA.start()
       await psB.start()
 
-      // @ts-expect-error protected property
-      await psA._libp2p.dial(psB.peerId)
+      expect(psA.getPeers()).to.be.empty()
+      expect(psB.getPeers()).to.be.empty()
+
+      await connectPeers(psA.multicodecs[0], registrarA, registrarB, peerIdA, peerIdB)
 
       // Wait for peers to be ready in pubsub
-      await pWaitFor(() => psA.peers.size === 1 && psB.peers.size === 1)
+      await pWaitFor(() => psA.getPeers().length === 1 && psB.getPeers().length === 1)
     })
 
     after(async () => {
@@ -57,10 +72,10 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
 
       psB.addEventListener('pubsub:subscription-change', (evt) => {
         const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
-        expectSet(psA.subscriptions, [topic])
-        expect(psB.peers.size).to.equal(1)
-        expectSet(psB.topics.get(topic), [psA.peerId.toString()])
-        expect(changedPeerId.toString()).to.equal(first(psB.peers).id.toString())
+        expect(psA.getTopics()).to.deep.equal([topic])
+        expect(psB.getPeers()).to.have.lengthOf(1)
+        expect(psB.getSubscribers(topic)).to.deep.equal([peerIdA])
+        expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
         expect(changedSubs).to.have.lengthOf(1)
         expect(changedSubs[0].topicID).to.equal(topic)
         expect(changedSubs[0].subscribe).to.equal(true)
@@ -135,7 +150,7 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       function receivedMsg (evt: CustomEvent<Message>) {
         const msg = evt.detail
         expect(uint8ArrayToString(msg.data)).to.equal('banana')
-        expect(msg.from).to.be.eql(psB.peerId.toString())
+        expect(msg.from).to.deep.equal(peerIdB)
         expect(msg.seqno).to.be.a('Uint8Array')
         expect(msg.topicIDs).to.be.eql([topic])
 
@@ -156,13 +171,13 @@ export default (common: TestSetup<PubSub<EventMap>>) => {
       const defer = pDefer()
 
       psA.unsubscribe(topic)
-      expect(psA.subscriptions.size).to.equal(0)
+      expect(psA.getTopics()).to.be.empty()
 
       psB.addEventListener('pubsub:subscription-change', (evt) => {
         const { peerId: changedPeerId, subscriptions: changedSubs } = evt.detail
-        expect(psB.peers.size).to.equal(1)
-        expectSet(psB.topics.get(topic), [])
-        expect(changedPeerId.toString()).to.equal(first(psB.peers).id.toString())
+        expect(psB.getPeers()).to.have.lengthOf(1)
+        expect(psB.getTopics()).to.be.empty()
+        expect(changedPeerId).to.deep.equal(psB.getPeers()[0])
         expect(changedSubs).to.have.lengthOf(1)
         expect(changedSubs[0].topicID).to.equal(topic)
         expect(changedSubs[0].subscribe).to.equal(false)

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

@@ -10,6 +10,7 @@ import { expect } from 'aegir/utils/chai.js'
 import delay from 'delay'
 import type { TestSetup } from '../index.js'
 import type { Muxer, MuxerOptions } from '@libp2p/interfaces/stream-muxer'
+import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 
 function randomBuffer () {
   return uint8ArrayFromString(Math.random().toString())
@@ -27,6 +28,8 @@ const infiniteRandom = {
 export default (common: TestSetup<Muxer, MuxerOptions>) => {
   describe('close', () => {
     it('closing underlying socket closes streams', async () => {
+      const localPeer = await createEd25519PeerId()
+      const remotePeer = await createEd25519PeerId()
       const muxer = await common.setup({
         onStream: (stream) => {
           void pipe(stream, drain)
@@ -40,8 +43,8 @@ export default (common: TestSetup<Muxer, MuxerOptions>) => {
         returnOnAbort: true
       })
 
-      await upgrader.upgradeInbound(mockMultiaddrConnection(abortableRemote))
-      const dialerConn = await upgrader.upgradeOutbound(mockMultiaddrConnection(local))
+      await upgrader.upgradeInbound(mockMultiaddrConnection(abortableRemote, localPeer))
+      const dialerConn = await upgrader.upgradeOutbound(mockMultiaddrConnection(local, remotePeer))
 
       const s1 = await dialerConn.newStream([''])
       const s2 = await dialerConn.newStream([''])

package/dist/src/pubsub/utils.d.ts

@@ -1,3 +0,0 @@
-export declare function first<V>(map: Map<any, V>): V;
-export declare function expectSet<T>(set?: Set<T>, subs?: T[]): void;
-//# sourceMappingURL=utils.d.ts.map

package/dist/src/pubsub/utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/pubsub/utils.ts"],"names":[],"mappings":"AAEA,wBAAgB,KAAK,CAAE,CAAC,EAAG,GAAG,EAAE,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC,GAAG,CAAC,CAE9C;AAED,wBAAgB,SAAS,CAAE,CAAC,EAAG,GAAG,CAAC,EAAE,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,EAAE,QAMtD"}

package/dist/src/pubsub/utils.js

@@ -1,11 +0,0 @@
-import { expect } from 'aegir/utils/chai.js';
-export function first(map) {
-    return map.values().next().value;
-}
-export function expectSet(set, subs) {
-    if ((set == null) || (subs == null)) {
-        throw new Error('No set or subs passed');
-    }
-    expect(Array.from(set.values())).to.eql(subs);
-}
-//# sourceMappingURL=utils.js.map

package/dist/src/pubsub/utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/pubsub/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAA;AAE5C,MAAM,UAAU,KAAK,CAAM,GAAgB;IACzC,OAAO,GAAG,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAA;AAClC,CAAC;AAED,MAAM,UAAU,SAAS,CAAM,GAAY,EAAE,IAAU;IACrD,IAAI,CAAC,GAAG,IAAI,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,IAAI,CAAC,EAAE;QACnC,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;KACzC;IAED,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;AAC/C,CAAC"}

package/src/pubsub/utils.ts

@@ -1,13 +0,0 @@
-import { expect } from 'aegir/utils/chai.js'
-
-export function first <V> (map: Map<any, V>): V {
-  return map.values().next().value
-}
-
-export function expectSet <T> (set?: Set<T>, subs?: T[]) {
-  if ((set == null) || (subs == null)) {
-    throw new Error('No set or subs passed')
-  }
-
-  expect(Array.from(set.values())).to.eql(subs)
-}