feat: address and proto books (#590)

* feat: address and proto books

* chore: apply suggestions from code review

Co-Authored-By: Jacob Heun <jacobheun@gmail.com>

* chore: minor fixes and initial tests added

* chore: integrate new peer-store with code using adapters for other modules

* chore: do not use peerstore.put on get-peer-info

* chore: apply suggestions from code review

Co-Authored-By: Jacob Heun <jacobheun@gmail.com>

* chore: add new peer store tests

* chore: apply suggestions from code review

Co-Authored-By: Jacob Heun <jacobheun@gmail.com>

Co-authored-by: Jacob Heun <jacobheun@gmail.com>

test/peer-store/proto-book.spec.js

@@ -0,0 +1,310 @@
+'use strict'
+/* eslint-env mocha */
+
+const chai = require('chai')
+chai.use(require('dirty-chai'))
+const { expect } = chai
+
+const { EventEmitter } = require('events')
+const pDefer = require('p-defer')
+
+const ProtoBook = require('../../src/peer-store/proto-book')
+
+const peerUtils = require('../utils/creators/peer')
+const {
+  ERR_INVALID_PARAMETERS
+} = require('../../src/errors')
+
+const arraysAreEqual = (a, b) => a.length === b.length && a.sort().every((item, index) => b[index] === item)
+
+describe('protoBook', () => {
+  let peerId
+
+  before(async () => {
+    [peerId] = await peerUtils.createPeerId()
+  })
+
+  describe('protoBook.set', () => {
+    let ee, pb
+
+    beforeEach(() => {
+      ee = new EventEmitter()
+      pb = new ProtoBook(ee)
+    })
+
+    afterEach(() => {
+      ee.removeAllListeners()
+    })
+
+    it('throwns invalid parameters error if invalid PeerId is provided', () => {
+      expect(() => {
+        pb.set('invalid peerId')
+      }).to.throw(ERR_INVALID_PARAMETERS)
+    })
+
+    it('throwns invalid parameters error if no protocols provided', () => {
+      expect(() => {
+        pb.set(peerId)
+      }).to.throw(ERR_INVALID_PARAMETERS)
+    })
+
+    it('replaces the stored content by default and emit change event', () => {
+      const defer = pDefer()
+      const supportedProtocols = ['protocol1', 'protocol2']
+
+      ee.once('change:protocols', ({ peerId, protocols }) => {
+        expect(peerId).to.exist()
+        expect(protocols).to.have.deep.members(supportedProtocols)
+        defer.resolve()
+      })
+
+      pb.set(peerId, supportedProtocols)
+      const protocols = pb.get(peerId)
+      expect(protocols).to.have.deep.members(supportedProtocols)
+
+      return defer.promise
+    })
+
+    it('emits on set if not storing the exact same content', () => {
+      const defer = pDefer()
+
+      const supportedProtocolsA = ['protocol1', 'protocol2']
+      const supportedProtocolsB = ['protocol2']
+
+      let changeCounter = 0
+      ee.on('change:protocols', () => {
+        changeCounter++
+        if (changeCounter > 1) {
+          defer.resolve()
+        }
+      })
+
+      // set 1
+      pb.set(peerId, supportedProtocolsA)
+
+      // set 2 (same content)
+      pb.set(peerId, supportedProtocolsB)
+      const protocols = pb.get(peerId)
+      expect(protocols).to.have.deep.members(supportedProtocolsB)
+
+      return defer.promise
+    })
+
+    it('does not emit on set if it is storing the exact same content', () => {
+      const defer = pDefer()
+
+      const supportedProtocols = ['protocol1', 'protocol2']
+
+      let changeCounter = 0
+      ee.on('change:protocols', () => {
+        changeCounter++
+        if (changeCounter > 1) {
+          defer.reject()
+        }
+      })
+
+      // set 1
+      pb.set(peerId, supportedProtocols)
+
+      // set 2 (same content)
+      pb.set(peerId, supportedProtocols)
+
+      // Wait 50ms for incorrect second event
+      setTimeout(() => {
+        defer.resolve()
+      }, 50)
+
+      return defer.promise
+    })
+  })
+
+  describe('protoBook.add', () => {
+    let ee, pb
+
+    beforeEach(() => {
+      ee = new EventEmitter()
+      pb = new ProtoBook(ee)
+    })
+
+    afterEach(() => {
+      ee.removeAllListeners()
+    })
+
+    it('throwns invalid parameters error if invalid PeerId is provided', () => {
+      expect(() => {
+        pb.add('invalid peerId')
+      }).to.throw(ERR_INVALID_PARAMETERS)
+    })
+
+    it('throwns invalid parameters error if no protocols provided', () => {
+      expect(() => {
+        pb.add(peerId)
+      }).to.throw(ERR_INVALID_PARAMETERS)
+    })
+
+    it('adds the new content and emits change event', () => {
+      const defer = pDefer()
+
+      const supportedProtocolsA = ['protocol1', 'protocol2']
+      const supportedProtocolsB = ['protocol3']
+      const finalProtocols = supportedProtocolsA.concat(supportedProtocolsB)
+
+      let changeTrigger = 2
+      ee.on('change:protocols', ({ protocols }) => {
+        changeTrigger--
+        if (changeTrigger === 0 && arraysAreEqual(protocols, finalProtocols)) {
+          defer.resolve()
+        }
+      })
+
+      // Replace
+      pb.set(peerId, supportedProtocolsA)
+      let protocols = pb.get(peerId)
+      expect(protocols).to.have.deep.members(supportedProtocolsA)
+
+      // Add
+      pb.add(peerId, supportedProtocolsB)
+      protocols = pb.get(peerId)
+      expect(protocols).to.have.deep.members(finalProtocols)
+
+      return defer.promise
+    })
+
+    it('emits on add if the content to add not exists', () => {
+      const defer = pDefer()
+
+      const supportedProtocolsA = ['protocol1']
+      const supportedProtocolsB = ['protocol2']
+      const finalProtocols = supportedProtocolsA.concat(supportedProtocolsB)
+
+      let changeCounter = 0
+      ee.on('change:protocols', () => {
+        changeCounter++
+        if (changeCounter > 1) {
+          defer.resolve()
+        }
+      })
+
+      // set 1
+      pb.set(peerId, supportedProtocolsA)
+
+      // set 2 (content already existing)
+      pb.add(peerId, supportedProtocolsB)
+      const protocols = pb.get(peerId)
+      expect(protocols).to.have.deep.members(finalProtocols)
+
+      return defer.promise
+    })
+
+    it('does not emit on add if the content to add already exists', () => {
+      const defer = pDefer()
+
+      const supportedProtocolsA = ['protocol1', 'protocol2']
+      const supportedProtocolsB = ['protocol2']
+
+      let changeCounter = 0
+      ee.on('change:protocols', () => {
+        changeCounter++
+        if (changeCounter > 1) {
+          defer.reject()
+        }
+      })
+
+      // set 1
+      pb.set(peerId, supportedProtocolsA)
+
+      // set 2 (content already existing)
+      pb.add(peerId, supportedProtocolsB)
+
+      // Wait 50ms for incorrect second event
+      setTimeout(() => {
+        defer.resolve()
+      }, 50)
+
+      return defer.promise
+    })
+  })
+
+  describe('protoBook.get', () => {
+    let ee, pb
+
+    beforeEach(() => {
+      ee = new EventEmitter()
+      pb = new ProtoBook(ee)
+    })
+
+    it('throwns invalid parameters error if invalid PeerId is provided', () => {
+      expect(() => {
+        pb.get('invalid peerId')
+      }).to.throw(ERR_INVALID_PARAMETERS)
+    })
+
+    it('returns undefined if no protocols are known for the provided peer', () => {
+      const protocols = pb.get(peerId)
+
+      expect(protocols).to.not.exist()
+    })
+
+    it('returns the protocols stored', () => {
+      const supportedProtocols = ['protocol1', 'protocol2']
+
+      pb.set(peerId, supportedProtocols)
+
+      const protocols = pb.get(peerId)
+      expect(protocols).to.have.deep.members(supportedProtocols)
+    })
+  })
+
+  describe('protoBook.delete', () => {
+    let ee, pb
+
+    beforeEach(() => {
+      ee = new EventEmitter()
+      pb = new ProtoBook(ee)
+    })
+
+    it('throwns invalid parameters error if invalid PeerId is provided', () => {
+      expect(() => {
+        pb.delete('invalid peerId')
+      }).to.throw(ERR_INVALID_PARAMETERS)
+    })
+
+    it('returns false if no records exist for the peer and no event is emitted', () => {
+      const defer = pDefer()
+
+      ee.on('change:protocols', () => {
+        defer.reject()
+      })
+
+      const deleted = pb.delete(peerId)
+
+      expect(deleted).to.equal(false)
+
+      // Wait 50ms for incorrect invalid event
+      setTimeout(() => {
+        defer.resolve()
+      }, 50)
+
+      return defer.promise
+    })
+
+    it('returns true if the record exists and an event is emitted', () => {
+      const defer = pDefer()
+
+      const supportedProtocols = ['protocol1', 'protocol2']
+      pb.set(peerId, supportedProtocols)
+
+      // Listen after set
+      ee.on('change:protocols', ({ protocols }) => {
+        expect(protocols.length).to.eql(0)
+        defer.resolve()
+      })
+
+      const deleted = pb.delete(peerId)
+
+      expect(deleted).to.equal(true)
+
+      return defer.promise
+    })
+  })
+})