chore: tests

package.json

@@ -51,15 +51,15 @@
     "streaming-iterables": "^4.1.2"
   },
   "peerDependencies": {
-    "libp2p": "libp2p/js-libp2p#feat/certified-addressbook"
+    "libp2p": "libp2p/js-libp2p#0.29.x"
   },
   "devDependencies": {
     "aegir": "^25.0.0",
     "chai": "^4.2.0",
     "chai-as-promised": "^7.1.1",
     "delay": "^4.3.0",
     "dirty-chai": "^2.0.1",
-    "libp2p": "libp2p/js-libp2p#feat/certified-addressbook",
+    "libp2p": "libp2p/js-libp2p#0.29.x",
     "libp2p-mplex": "^0.9.5",
     "libp2p-noise": "^1.1.2",
     "libp2p-websockets": "^0.13.6",

src/index.js

@@ -355,38 +355,42 @@ class Rendezvous {
       })
 
       // Send discover message and wait for response
-      const { stream } = await rp.connection.newStream(PROTOCOL_MULTICODEC)
-      const [response] = await pipe(
-        [message],
-        lp.encode(),
-        stream,
-        lp.decode(),
-        toBuffer,
-        collect
-      )
-
-      const recMessage = Message.decode(response)
-
-      if (!recMessage.type === MESSAGE_TYPE.DISCOVER_RESPONSE) {
-        throw new Error('unexpected message received')
-      }
-
-      // Iterate over registrations response
-      for (const r of recMessage.discoverResponse.registrations) {
-        // track registrations
-        yield registrationTransformer(r)
-
-        // Store cookie
-        rpCookies.set(ns, recMessage.discoverResponse.cookie.toString())
-        this._rendezvousPoints.set(id, {
-          connection: rp.connection,
-          cookies: rpCookies
-        })
+      try {
+        const { stream } = await rp.connection.newStream(PROTOCOL_MULTICODEC)
+        const [response] = await pipe(
+          [message],
+          lp.encode(),
+          stream,
+          lp.decode(),
+          toBuffer,
+          collect
+        )
+
+        const recMessage = Message.decode(response)
+
+        if (!recMessage.type === MESSAGE_TYPE.DISCOVER_RESPONSE) {
+          throw new Error('unexpected message received')
+        }
 
-        limit--
-        if (limit === 0) {
-          return
+        // Iterate over registrations response
+        for (const r of recMessage.discoverResponse.registrations) {
+          // track registrations
+          yield registrationTransformer(r)
+
+          // Store cookie
+          rpCookies.set(ns, recMessage.discoverResponse.cookie.toString())
+          this._rendezvousPoints.set(id, {
+            connection: rp.connection,
+            cookies: rpCookies
+          })
+
+          limit--
+          if (limit === 0) {
+            return
+          }
         }
+      } catch (err) {
+        log.error(err)
       }
     }
   }

test/discovery.spec.js

@@ -76,7 +76,7 @@ describe('rendezvous discovery', () => {
     await defer.promise
   })
 
-  it.skip('peer1 should not discover peer2 if it registers in a different namespace', async () => {
+  it('peer1 should not discover peer2 if it registers in a different namespace', async () => {
     const namespace1 = 'test-namespace1'
     const namespace2 = 'test-namespace2'
     await peers[1].rendezvous.register(namespace1)
@@ -88,11 +88,11 @@ describe('rendezvous discovery', () => {
     peers[1].rendezvous.discovery.start()
 
     // Register
-    expect(peers[0].rendezvous._server.nsRegistrations.size).to.eql(0)
     await peers[2].rendezvous.register(namespace2)
-    expect(peers[0].rendezvous._server.nsRegistrations.size).to.eql(1)
 
-    await delay(1500)
+    await delay(1000)
+
+    peers[1].rendezvous.discovery.removeAllListeners()
   })
 })
 

test/rendezvous.spec.js

@@ -6,14 +6,18 @@ chai.use(require('dirty-chai'))
 chai.use(require('chai-as-promised'))
 const { expect } = chai
 const sinon = require('sinon')
+const pWaitFor = require('p-wait-for')
 
+const multiaddr = require('multiaddr')
 const Envelope = require('libp2p/src/record/envelope')
 const PeerRecord = require('libp2p/src/record/peer-record')
 
 const Rendezvous = require('../src')
 const { codes: errCodes } = require('../src/errors')
 
 const { createPeer, connectPeers } = require('./utils')
+const { MULTIADDRS_WEBSOCKETS } = require('./fixtures/browser')
+const relayAddr = MULTIADDRS_WEBSOCKETS[0]
 
 const namespace = 'ns'
 
@@ -243,4 +247,93 @@ describe('rendezvous', () => {
       expect(registers).to.have.lengthOf(1)
     })
   })
+
+  describe('flows with 3 rendezvous all acting as rendezvous point', () => {
+    let peers
+
+    const connectPeers = async (peer, otherPeer) => {
+      // Connect each other via relay node
+      const m = multiaddr(`${relayAddr}/p2p-circuit/p2p/${otherPeer.peerId.toB58String()}`)
+      await peer.dial(m)
+
+      // Wait event propagation
+      await pWaitFor(() => peer.rendezvous._rendezvousPoints.size === 1)
+    }
+
+    beforeEach(async () => {
+      // Create libp2p nodes
+      peers = await createPeer({
+        number: 3
+      })
+
+      // Create 3 rendezvous peers
+      peers.forEach((peer) => {
+        const rendezvous = new Rendezvous({
+          libp2p: peer
+        })
+        rendezvous.start()
+        peer.rendezvous = rendezvous
+      })
+
+      // Connect to testing relay node
+      await Promise.all(peers.map((libp2p) => libp2p.dial(relayAddr)))
+    })
+
+    afterEach(() => peers.map(async (libp2p) => {
+      await libp2p.rendezvous.stop()
+      await libp2p.stop()
+    }))
+
+    it('discover find registered peer for namespace only when registered', async () => {
+      await connectPeers(peers[0], peers[1])
+      await connectPeers(peers[2], peers[1])
+
+      const registers = []
+
+      // Peer2 does not discovery any peer registered
+      for await (const reg of peers[2].rendezvous.discover(namespace)) { // eslint-disable-line
+        throw new Error('no registers should exist')
+      }
+
+      // Peer0 register itself on namespace (connected to Peer1)
+      await peers[0].rendezvous.register(namespace)
+
+      // Peer2 discovers Peer0 registered in Peer1
+      for await (const reg of peers[2].rendezvous.discover(namespace)) {
+        registers.push(reg)
+      }
+      expect(registers).to.have.lengthOf(1)
+      expect(registers[0].signedPeerRecord).to.exist()
+      expect(registers[0].ns).to.eql(namespace)
+      expect(registers[0].ttl).to.exist()
+
+      // Peer0 unregister itself on namespace (connected to Peer1)
+      await peers[0].rendezvous.unregister(namespace)
+
+      // Peer2 does not discovery any peer registered
+      for await (const reg of peers[2].rendezvous.discover(namespace)) { // eslint-disable-line
+        throw new Error('no registers should exist')
+      }
+    })
+
+    it('discovers locally first, and if limit achieved, not go to the network', async () => {
+      await connectPeers(peers[0], peers[1])
+      await connectPeers(peers[2], peers[1])
+
+      // Peer0 register itself on namespace (connected to Peer1)
+      await peers[1].rendezvous.register(namespace)
+
+      const spyRendezvousPoints = sinon.spy(peers[2].rendezvous._rendezvousPoints, 'entries')
+
+      const registers = []
+      // Peer2 discovers Peer0 registered in Peer1
+      for await (const reg of peers[2].rendezvous.discover(namespace, 1)) {
+        registers.push(reg)
+      }
+
+      // No need to get the rendezvousPoints connections
+      expect(spyRendezvousPoints).to.have.property('callCount', 0)
+      expect(registers).to.have.lengthOf(1)
+    })
+  })
 })