helia-coord 1.7.2 → 1.8.0

package/lib/adapters/encryption-adapter.js

@@ -72,6 +72,9 @@ class EncryptionAdapter {
       if (!peer || !peer.data) {
         throw new Error('Peer public key is not available yet.')
       }
+      if (!msg || typeof msg !== 'string') {
+        throw new Error('Message is required.')
+      }
 
       const pubKey = peer.data.encryptPubKey
       // console.log('msg to encrypt: ', msg)

package/lib/adapters/pubsub-adapter/messaging.js

@@ -237,10 +237,9 @@ class Messaging {
       }
 
       const peerData = thisNode.peerData.filter(x => x.from === receiver)
-
       // 3/24/24 CT - Debugging issue with passing data between ipfs-bch-wallet
       // -service and -consumer.
-      if (!peerData || !peerData[0].data) {
+      if (!peerData || !peerData[0] || !peerData[0].data) {
         console.log(`peerData[0]: ${JSON.stringify(peerData[0])}`)
         throw new Error('Required encryption information for peer is not available.')
       }
@@ -275,7 +274,7 @@ class Messaging {
 
       return outMsgObj
     } catch (err) {
-      console.error('Error in generateAckMsg()')
+      console.error('Error in generateAckMsg()', err)
       throw err
     }
   }

package/lib/use-cases/peer-use-cases.js

@@ -240,7 +240,6 @@ class PeerUseCases {
         if (!thisPeerData) return false
 
         const dataIndex = this.thisNode.peerData.indexOf(thisPeerData)
-        // console.log(`dataIndex: ${dataIndex}`)
 
         // If the new announceObj is older than the last announceObj, then
         // ignore it.
@@ -386,24 +385,19 @@ class PeerUseCases {
           // the multiaddrs in the announcement object.
           const filteredMultiaddrs = this.utils.filterMultiaddrs(peerData.data.ipfsMultiaddrs)
           this.adapters.log.statusLog(1, 'filteredMultiaddrs: ', filteredMultiaddrs)
-
           for (let j = 0; j < filteredMultiaddrs.length; j++) {
             const multiaddr = filteredMultiaddrs[j]
             this.adapters.log.statusLog(1,
               `Trying a direct connection to peer ${thisPeer} with this multiaddr: ${multiaddr}.`
             )
-
             // Attempt to connect to the node through a circuit relay.
             connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
-            // console.log('direct connection connected: ', connected)
-
             // If the connection was successful, break out of the relay loop.
             // Otherwise try to connect through the next relay.
             if (connected.success) {
               this.adapters.log.statusLog(1,
                 `Successfully connected to peer ${thisPeer} through direct connection: ${multiaddr}.`
               )
-
               // Add the connection multiaddr for this peer to the thisNode object.
               this.updatePeerConnectionInfo({ thisPeer })
 
@@ -422,7 +416,6 @@ class PeerUseCases {
             }
           }
         }
-
         if (connected.success) {
           continue
         }
@@ -443,7 +436,6 @@ class PeerUseCases {
           for (let j = 0; j < filteredMultiaddrs.length; j++) {
             const multiaddr = filteredMultiaddrs[j]
             this.adapters.log.statusLog(1, `Trying to connect to peer ${thisPeer} through webRTC multiaddr: ${multiaddr}.`)
-
             connected = await this.adapters.ipfs.connectToPeer({ multiaddr })
 
             // If the connection was successful, break out of the relay loop.
@@ -545,7 +537,7 @@ class PeerUseCases {
 
       return true
     } catch (err) {
-      console.error('Error in refreshPeerConnections()')
+      console.error('Error in refreshPeerConnections()', err)
       throw err
     }
   }
@@ -694,20 +686,18 @@ class PeerUseCases {
 
       // Get multiaddrs that can be used to connect to this node.
       const addrs = this.adapters.ipfs.ipfs.libp2p.getMultiaddrs()
-
       const webRtcAddrs = addrs.filter(x => WebRTC.matches(x))
-      // console.log('webRTC addrs: ', webRtcAddrs)
 
       // If there are any webRTC multiaddrs, add them to the announcement object.
       if (webRtcAddrs.length) {
         // Remove any previous webRTC multiaddrs from the announcement object.
         const existingMultiaddrs = thisNode.ipfsMultiaddrs
         const noRtcAddrs = existingMultiaddrs.filter(x => !x.includes('/p2p-circuit/webrtc'))
-
         // Add the new webRTC multiaddrs to the announcement object.
         webRtcAddrs.forEach(x => {
           noRtcAddrs.push(x.toString())
         })
+        console.log('noRtcAddrs: ', noRtcAddrs)
 
         // Add the new webRTC multiaddrs to the announcement object.
         thisNode.ipfsMultiaddrs = noRtcAddrs

package/lib/use-cases/relay-use-cases.js

@@ -204,7 +204,7 @@ class RelayUseCases {
           }
         } else {
           // Not connected. Connect to the relay.
-
+          console.log('Handling zero connected peers')
           // console.log('peerData: ', peerData)
 
           // If this node is not connected, try to connect again.
@@ -216,6 +216,7 @@ class RelayUseCases {
           // console.log(`thisRelay.connected: ${thisRelay.connected}`)
 
           // Debugging: Trying to figure out the best way to select the multiaddr
+          console.log('relay multiaddr: ', thisRelay.multiaddr)
           if (thisRelay.connected && !thisRelay.multiaddr.includes('/tcp/')) {
             console.log('DEBUG: thisRelay.multiaddr: ', thisRelay.multiaddr)
 
@@ -477,6 +478,7 @@ class RelayUseCases {
         let peerData = thisNode.peerData.filter(x => {
           if (!x.data) {
             console.log('broken peer data: ', x)
+            return false
           }
           // console.log(`x.data.ipfsId: ${x.data.ipfsId}`)
           // console.log(`thisRelay.ipfsId: ${thisRelay.ipfsId}`)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "helia-coord",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "description": "A JS library for helping IPFS peers coordinate, find a common interest, and stay connected around that interest.",
   "main": "./index.js",
   "type": "module",

package/test/unit/adapters/encryption-adapter-unit.js

@@ -126,6 +126,45 @@ describe('#Adapters - Encryption', () => {
         assert.include(err.message, 'pubkey must be a hex string')
       }
     })
+    it('should throw an error is peer is not provided', async () => {
+      try {
+        await uut.encryptMsg()
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Peer public key is not available yet.')
+      }
+    })
+    it('should throw an error is msg is not provided', async () => {
+      try {
+        const peer = {
+          data: {
+            encryptionKey: 'abc123'
+          }
+        }
+
+        await uut.encryptMsg(peer)
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Message is required.')
+      }
+    })
+    it('should throw an error is peer data is not provided', async () => {
+      try {
+        const peer = {
+        }
+
+        await uut.encryptMsg(peer, 'testMsg')
+        // console.log('result: ', result)
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        assert.include(err.message, 'Peer public key is not available yet.')
+      }
+    })
 
     it('should encrypt a string', async () => {
       // Mock dependencies

package/test/unit/adapters/gist.unit.adapters.js

@@ -49,6 +49,41 @@ describe('#Adapter-Gist', () => {
 
         await uut.getCRList()
 
+        assert.fail('Unexpected result')
+      } catch (err) {
+        assert.include(err.message, 'test error')
+      }
+    })
+  })
+  describe('#getCRList2', () => {
+    it('should get data from GitHub', async () => {
+      // Mock network dependencies
+      sandbox.stub(uut.axios, 'get').resolves({
+        data: {
+          browser: [],
+          node: [],
+          recommendedPeers: []
+        }
+      })
+
+      const result = await uut.getCRList2()
+      // console.log('result: ', result)
+
+      assert.property(result, 'browser')
+      assert.property(result, 'node')
+      assert.property(result, 'recommendedPeers')
+      assert.isArray(result.browser)
+      assert.isArray(result.node)
+      assert.isArray(result.recommendedPeers)
+    })
+
+    it('should catch and throw errors', async () => {
+      try {
+        // Force desired code path
+        sandbox.stub(uut.axios, 'get').rejects(new Error('test error'))
+
+        await uut.getCRList2()
+
         assert.fail('Unexpected result')
       } catch (err) {
         assert.include(err.message, 'test error')

package/test/unit/adapters/pubsub/messaging-adapter-unit.js

@@ -166,6 +166,22 @@ describe('#messaging-adapter', () => {
       assert.property(result, 'payload')
     })
   })
+  it('should throws error if sender is not found', async () => {
+    try {
+      const ipfsId = 'unknowPeerId'
+      const data = {
+        sender: ipfsId,
+        uuid: 'fake-uuid'
+      }
+
+      await uut.generateAckMsg(data, thisNode)
+
+      assert.fail('Unexpected code path')
+    } catch (err) {
+      console.log(err)
+      assert.include(err.message, 'Required encryption information for peer is not available.')
+    }
+  })
 
   it('should catch and throw errors', async () => {
     try {

package/test/unit/adapters/pubsub/pubsub-adapter-unit.js

@@ -113,7 +113,7 @@ describe('#Adapter - Pubsub', () => {
       // Mock dependencies
       sandbox.stub(uut, 'checkForDuplicateMsg').returns(true)
 
-      const handler = () => {}
+      const handler = () => { }
 
       const msg = {
         detail: {
@@ -133,7 +133,7 @@ describe('#Adapter - Pubsub', () => {
       // Mock dependencies
       sandbox.stub(uut, 'checkForDuplicateMsg').returns(true)
 
-      const handler = () => {}
+      const handler = () => { }
 
       const msg = {
         detail: {
@@ -197,7 +197,7 @@ describe('#Adapter - Pubsub', () => {
     })
 
     it('should throw an error if data can not be parsed', async () => {
-      const handler = () => {}
+      const handler = () => { }
 
       // Force desired code path
       mockData.mockMsg.data = Buffer.from('54234', 'hex')
@@ -212,7 +212,7 @@ describe('#Adapter - Pubsub', () => {
       // Mock dependencies
       sandbox.stub(uut, 'checkForDuplicateMsg').returns(false)
 
-      const handler = () => {}
+      const handler = () => { }
 
       const msg = {
         detail: {
@@ -362,8 +362,8 @@ describe('#Adapter - Pubsub', () => {
       // sandbox.stub(uut.ipfs.ipfs.pubsub, 'subscribe').resolves()
 
       // const chanName = 'test'
-      const handler = () => {}
-      const parsePubsubMessage = async () => {}
+      const handler = () => { }
+      const parsePubsubMessage = async () => { }
 
       // Instantiate the Broadcast message router library
       const bRouterOptions = {
@@ -388,8 +388,8 @@ describe('#Adapter - Pubsub', () => {
       // sandbox.stub(uut.ipfs.ipfs.pubsub, 'subscribe').resolves()
 
       // const chanName = 'test'
-      const handler = () => {}
-      const parsePubsubMessage = async () => {}
+      const handler = () => { }
+      const parsePubsubMessage = async () => { }
 
       // Instantiate the Broadcast message router library
       const bRouterOptions = {
@@ -411,7 +411,7 @@ describe('#Adapter - Pubsub', () => {
 
     it('should catch and handle errors, and return false', async () => {
       // Force and error
-      const handler = () => {}
+      const handler = () => { }
       const parsePubsubMessage = async () => {
         throw new Error('test error')
       }
@@ -440,7 +440,7 @@ describe('#Adapter - Pubsub', () => {
       const pRouterOptions = {
         thisNode,
         messaging: uut.messaging,
-        handleNewMessage: async () => {}
+        handleNewMessage: async () => { }
       }
       const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
@@ -460,7 +460,7 @@ describe('#Adapter - Pubsub', () => {
       const pRouterOptions = {
         thisNode,
         messaging: uut.messaging,
-        handleNewMessage: async () => {}
+        handleNewMessage: async () => { }
       }
       const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
@@ -480,7 +480,7 @@ describe('#Adapter - Pubsub', () => {
       const pRouterOptions = {
         thisNode,
         messaging: uut.messaging,
-        handleNewMessage: async () => {}
+        handleNewMessage: async () => { }
       }
       const privateRouter = new PrivateChannelRouter(pRouterOptions)
 
@@ -516,7 +516,7 @@ describe('#Adapter - Pubsub', () => {
     it('should subscribe to the coordination channel', async () => {
       const inObj = {
         chanName: globalConfig.DEFAULT_COORDINATION_ROOM,
-        handler: () => {}
+        handler: () => { }
       }
 
       const result = await uut.subscribeToCoordChannel(inObj)
@@ -538,4 +538,33 @@ describe('#Adapter - Pubsub', () => {
       }
     })
   })
+  describe('checkForDuplicateMsg', () => {
+    it('should return true if msg is not duplicated', () => {
+      const msgMock = { detail: { sequenceNumber: 1 } }
+      const res = uut.checkForDuplicateMsg(msgMock)
+      assert.isTrue(res)
+      assert.equal(uut.trackedMsgs.length, 1)
+    })
+    it('should return falase if msg is duplicated', () => {
+      const msgMock = { detail: { sequenceNumber: 1 } }
+
+      uut.trackedMsgs = [msgMock.detail.sequenceNumber]
+      const res = uut.checkForDuplicateMsg(msgMock)
+      assert.isFalse(res)
+    })
+  })
+  describe('manageMsgCache', () => {
+    it('should shift the trackedMsgs if it exceed the limit', () => {
+      uut.TRACKED_MSG_SIZE = 2
+      uut.trackedMsgs = [1, 2, 3]
+      uut.manageMsgCache()
+      assert.equal(uut.trackedMsgs.length, 2)
+    })
+    it('should keep the trackedMsgs length if it does not exceed the limit', () => {
+      uut.TRACKED_MSG_SIZE = 4
+      uut.trackedMsgs = [1, 2, 3]
+      uut.manageMsgCache()
+      assert.equal(uut.trackedMsgs.length, 3)
+    })
+  })
 })

package/test/unit/controllers/pubsub-controller.unit.js

@@ -59,9 +59,11 @@ describe('#Pubsub-Controller', () => {
     })
 
     it('should overwrite default coinjoin channel handler', () => {
-      const coinjoinPubsubHandler = () => {}
+      const coinjoinPubsubHandler = sandbox.spy()
 
-      uut = new PubsubController({ adapters, useCases, coinjoinPubsubHandler })
+      const uut = new PubsubController({ adapters, useCases, coinjoinPubsubHandler })
+      uut.coinjoinPubsubHandler()
+      assert.isTrue(coinjoinPubsubHandler.called)
     })
   })
 
@@ -104,4 +106,11 @@ describe('#Pubsub-Controller', () => {
       assert.equal(result, false)
     })
   })
+  describe('#coinjoinPubsubHandler (default)', () => {
+    it('should return true', async () => {
+      const result = await uut.coinjoinPubsubHandler()
+
+      assert.isTrue(result)
+    })
+  })
 })

package/test/unit/use-cases/peer.unit.use-cases.js

@@ -262,6 +262,34 @@ describe('#Use-Cases-Peer', () => {
       // peerData array should only have one peer.
       assert.equal(uut.thisNode.peerData.length, 1)
     })
+    it('should persit the multiaddr if it exist', async () => {
+      // Mock dependencies
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+
+      const announceObj = {
+        from: 'peerId',
+        data: {
+          jsonLd: {
+            name: 'test'
+          },
+          orbitdb: 'orbitdbId'
+        },
+        multiaddr: ['/ip4/123.45.6.7/p2p/ipfs-id']
+      }
+      uut.updateThisNode({ thisNode })
+
+      // Add the new peer
+      uut.thisNode.peerList.push(announceObj.from)
+      uut.thisNode.peerData.push(announceObj)
+
+      const result = await uut.addSubnetPeer(announceObj)
+      // console.log('result: ', result)
+
+      assert.equal(result, true)
+
+      // peerData array should only have one peer.
+      assert.equal(uut.thisNode.peerData.length, 1)
+    })
 
     it('should return false if existing peer can not be found', async () => {
       // Mock dependencies
@@ -399,6 +427,13 @@ describe('#Use-Cases-Peer', () => {
 
       assert.equal(result, true)
     })
+    it('should handle Error', () => {
+      try {
+        uut.isFreshPeer(null)
+      } catch (error) {
+        assert.include(error.message, 'Cannot read properties of null')
+      }
+    })
   })
 
   describe('#refreshPeerConnections', () => {
@@ -622,6 +657,84 @@ describe('#Use-Cases-Peer', () => {
         assert.include(err.message, 'test error')
       }
     })
+    it('should update logs on fails direct connection', async () => {
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: { ipfsMultiaddrs: [] } }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves({ success: false })
+        .resolves({ success: true })
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+      sandbox.stub(uut, 'updatePeerConnectionInfo').returns()
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+    it('should connect to circuit relay ', async () => {
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: { ipfsMultiaddrs: ['/p2p-circuit/ip4/123.45.6.7/tcp/4001/p2p/ipfs-id'] } }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves({ success: false })
+        .resolves({ success: true })
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+      sandbox.stub(uut, 'updatePeerConnectionInfo').returns()
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
+    it('should update logs on fails circuit relay connection', async () => {
+      // Add a circuit relay peer with advertised IP and port.
+      const ipfsId = 'QmbyYXKbnAmMbMGo8LRBZ58jYs58anqUzY1m4jxDmhDsje'
+      uut.thisNode.peerList = [ipfsId]
+      uut.thisNode.peerData = [{ from: ipfsId, data: { ipfsMultiaddrs: ['/p2p-circuit/ip4/123.45.6.7/tcp/4001/p2p/ipfs-id'] } }]
+
+      // Add a peer
+      await uut.addSubnetPeer(mockData.announceObj)
+
+      // Force circuit relay to be used.
+      uut.thisNode.relayData = mockData.mockRelayData
+
+      // Mock dependencies
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.swarmPeers)
+      sandbox.stub(uut, 'isFreshPeer').returns(true)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer')
+        .onCall(0).resolves({ success: false })
+        .resolves({ success: false })
+      sandbox.stub(uut.utils, 'filterMultiaddrs').returns(['/ip4/123.45.6.7/p2p/ipfs-id'])
+      sandbox.stub(uut, 'updatePeerConnectionInfo').returns()
+
+      // Connect to that peer.
+      const result = await uut.refreshPeerConnections()
+
+      assert.equal(result, true)
+    })
   })
 
   describe('#sendRPC', () => {
@@ -733,4 +846,102 @@ describe('#Use-Cases-Peer', () => {
       assert.equal(result, false)
     })
   })
+
+  describe('#updatePeerConnectionInfo', () => {
+    it('should update the peer connection info', async () => {
+      uut.thisNode.peerData = [{ from: 'peerId' }]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{ remoteAddr: '/ip4/123.45.6.7/p2p/ipfs-id' }])
+      const result = await uut.updatePeerConnectionInfo({ thisPeer: 'peerId' })
+      assert.equal(result, true)
+      assert.equal(uut.thisNode.peerData[0].multiaddr, '/ip4/123.45.6.7/p2p/ipfs-id')
+    })
+    it('should return false if the peer is not connected', async () => {
+      uut.thisNode.peerData = [{ from: 'peerId' }]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([])
+      const result = await uut.updatePeerConnectionInfo({ thisPeer: 'peerId' })
+      assert.equal(result, false)
+    })
+    it('should return false if the peer is not found', async () => {
+      uut.thisNode.peerData = [{ from: 'peerId' }]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{ remoteAddr: '/ip4/123.45.6.7/p2p/ipfs-id' }])
+      const result = await uut.updatePeerConnectionInfo({ thisPeer: 'peerId2' })
+      assert.equal(result, false)
+    })
+    it('should handle errors', async () => {
+      try {
+        uut.thisNode.peerData = [{ from: 'peerId' }]
+        sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').throws(new Error('test error'))
+        await uut.updatePeerConnectionInfo({ thisPeer: 'peerId' })
+        assert.fail('Unexpected code path')
+      } catch (error) {
+        assert.include(error.message, 'test error')
+      }
+    })
+  })
+  describe('#getWebRtcMultiaddr', () => {
+    it('should return the webRTC multiaddr', async () => {
+      const thisNodeMock = thisNode
+      const webRtcMultiaddr1 = '/ip4/127.0.0.1/tcp/5000/ws/p2p-circuit/webrtc/p2p/ipfs-id'
+      const webRtcMultiaddr2 = '/ip4/127.0.0.1/tcp/5001/ws/p2p-circuit/webrtc/p2p/ipfs-id2'
+
+      thisNodeMock.ipfsMultiaddrs = ['/ip4/123.45.6.7/p2p/ipfs-id', webRtcMultiaddr1, webRtcMultiaddr2]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getMultiaddrs').returns([webRtcMultiaddr2])
+
+      await uut.getWebRtcMultiaddr({ thisNode: thisNodeMock })
+
+      assert.equal(thisNodeMock.ipfsMultiaddrs.length, 2)
+      assert.equal(thisNodeMock.ipfsMultiaddrs[0], '/ip4/123.45.6.7/p2p/ipfs-id')
+      assert.equal(thisNodeMock.ipfsMultiaddrs[1], webRtcMultiaddr2, 'expected webRTC multiaddr to be updated')
+    })
+    it('should return false on error', async () => {
+      const result = await uut.getWebRtcMultiaddr(null)
+      assert.equal(result, false)
+    })
+  })
+  describe('#getMultiaddrs', () => {
+    it('should filter multiaddrs with a low chance of success', async () => {
+      const webRtcMultiaddr1 = '/ip4/157.178.192.100/tcp/5000/ws/p2p-circuit/webrtc/p2p/ipfs-id'
+      const lowChanceMultiaddrsExamples = [
+        '/ip4/127.0.0.1/tcp/4001/p2p/QmHash', // localhost
+        '/ip4/192.168.1.100/tcp/4001/p2p/QmHash', // private network (192.168.x.x)
+        '/ip4/172.16.0.100/tcp/4001/p2p/QmHash', // private network (172.16-31.x.x)
+        '/ip4/10.0.0.100/tcp/4001/p2p/QmHash', // private network (10.x.x.x)
+        '/ip4/1.2.3.4/p2p/4001/quic/p2p/QmHash', // QUIC protocol
+        '/ip4/1.2.3.4/udp/4001/p2p/QmHash', // UDP protocol
+        '/ip4/192.168.0.100/udp/4001/quic/p2p/QmHash', // private network with QUIC
+        '/ip4/172.20.0.100/udp/4001/p2p/QmHash' // private network with UDP
+
+      ]
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getMultiaddrs').returns([...lowChanceMultiaddrsExamples, webRtcMultiaddr1])
+      const result = await uut.getMultiaddrs()
+      assert.equal(result.length, 1)
+      assert.equal(result[0], webRtcMultiaddr1)
+    })
+    it('should return empty array on error', async () => {
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getMultiaddrs').throws(new Error('test error'))
+      const result = await uut.getMultiaddrs()
+      assert.equal(result.length, 0)
+    })
+  })
+  describe('relayMetricsHandler', () => {
+    it('should return true', async () => {
+      uut.incomingData = 'data'
+      await uut.relayMetricsHandler('updated data')
+      assert.equal(uut.incomingData, 'updated data')
+    })
+  })
+
+  describe('updateThisNode', () => {
+    it('should update the thisNode object', async () => {
+      const thisNodeMock = { data: 'mock node' }
+      const result = await uut.updateThisNode({ thisNode: thisNodeMock })
+      assert.equal(result, true)
+      assert.equal(uut.thisNode.data, 'mock node')
+    })
+    it('should keep as default if no data is provided', async () => {
+      const result = await uut.updateThisNode()
+      assert.equal(result, true)
+      assert.isUndefined(uut.thisNode)
+    })
+  })
 })

package/test/unit/use-cases/pubsub.unit.use-cases.js

@@ -107,6 +107,22 @@ describe('#pubsub-Use-Cases', () => {
 
       assert.equal(result, true)
     })
+    it('should throw an error if controllers are not provided', async () => {
+      try {
+        sandbox.stub(uut.adapters.pubsub, 'subscribeToCoordChannel').resolves()
+
+        uut.updateThisNode({
+          pubsubChannels: []
+        })
+
+        await uut.initializePubsub()
+
+        assert.fail('Unexpected code path')
+      } catch (err) {
+        // console.log(err)
+        assert.include(err.message, 'Instance of controllers must be passed to initializePubsub()')
+      }
+    })
 
     it('should catch and throw an error', async () => {
       try {

package/test/unit/use-cases/relay-use-cases-unit.js

@@ -172,6 +172,35 @@ describe('#relay-Use-Cases', () => {
       // Assert function executed successfully.
       assert.equal(result, true)
     })
+    it('Should debug when relay connection is not over tcp', async () => {
+      // Add a relay that is not over tcp
+      thisNode.relayData.push(
+        {
+          multiaddr:
+            '/ip4/139.162.76.54/udp/5269/ws/p2p/QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          connected: true,
+          updatedAt: '2021-09-20T15:59:12.961Z',
+          ipfsId: 'QmaKzQTAtoJWYMiG5ATx41uWsMajr1kSxRdtg919s8fK77',
+          isBootstrap: false,
+          metrics: { aboutLatency: [] },
+          latencyScore: 10000
+        }
+      )
+
+      // Mock dependencies
+      sandbox.stub(uut, 'sortRelays').returns(thisNode.relayData)
+      sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.connectedPeerList01)
+      sandbox.stub(uut.adapters.ipfs, 'connectToPeer').resolves({ success: true })
+      sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{
+        remoteAddr: '/ip4/116.203.193.74/udp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit'
+      }])
+
+      // uut.state.relays = crMockData.circuitRelays
+      const result = await uut.connectToCRs(thisNode)
+
+      // Assert function executed successfully.
+      assert.equal(result, true)
+    })
 
     it('Should skip relays that are already connected', async () => {
       // Force circuit relay to be used.
@@ -246,7 +275,7 @@ describe('#relay-Use-Cases', () => {
       sandbox.stub(uut, 'sortRelays').returns(thisNode.relayData)
       sandbox.stub(uut.adapters.ipfs, 'getPeers').resolves(mockData.connectedPeerList01)
       sandbox.stub(uut.adapters.ipfs.ipfs.libp2p, 'getConnections').returns([{
-        remoteAddr: '/ip4/116.203.193.74/tcp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL'
+        remoteAddr: '/ip4/116.203.193.74/tcp/4001/ipfs/QmNZktxkfScScnHCFSGKELH3YRqdxHQ3Le9rAoRLhZ6vgL/p2p-circuit'
       }])
 
       // uut.state.relays = crMockData.circuitRelays
@@ -628,7 +657,7 @@ describe('#relay-Use-Cases', () => {
 
       // Mock dependencies
       sandbox.stub(uut.adapters.bch.bchjs.Util, 'sleep').resolves()
-      sandbox.stub(uut.adapters.pubsub.about, 'queryAbout').resolves(true)
+      sandbox.stub(uut.peerUseCases, 'queryAbout').resolves(true)
 
       await uut.measureRelays(thisNode)
       // console.log(
@@ -674,6 +703,33 @@ describe('#relay-Use-Cases', () => {
       // First element of '1' should have been shifted out and replaced by '2'
       assert.equal(thisNode.relayData[0].metrics.aboutLatency[0], 2)
     })
+
+    it('should ignore a broken peer data', async () => {
+      // Mock test data
+      const thisNode = {
+        relayData: [
+          {
+            ipfsId: 'testId',
+            isBootstrap: false,
+            connected: false,
+            metrics: {
+              aboutLatency: []
+            }
+          }
+        ],
+        peerData: [
+
+          {
+            data: null
+          }
+        ]
+      }
+
+      await uut.measureRelays(thisNode)
+      // console.log('thisNode: ', thisNode)
+
+      assert.equal(thisNode.relayData[0].metrics.aboutLatency.length, 0)
+    })
   })
 
   describe('#sortRelays', () => {