feat: peerStore persistence

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

@@ -4,9 +4,11 @@
 const chai = require('chai')
 chai.use(require('dirty-chai'))
 const { expect } = chai
+const sinon = require('sinon')
 
 const PeerStore = require('../../src/peer-store')
 const multiaddr = require('multiaddr')
+const { MemoryDatastore } = require('interface-datastore')
 
 const peerUtils = require('../utils/creators/peer')
 
@@ -150,3 +152,157 @@ describe('peer-store', () => {
     })
   })
 })
+
+describe('libp2p.peerStore', () => {
+  let libp2p
+  let memoryDatastore
+
+  beforeEach(async () => {
+    memoryDatastore = new MemoryDatastore()
+    ;[libp2p] = await peerUtils.createPeer({
+      started: false,
+      config: {
+        datastore: memoryDatastore,
+        peerStore: {
+          persistance: true
+        }
+      }
+    })
+  })
+
+  it('should try to load content from an empty datastore', async () => {
+    const spyPeerStore = sinon.spy(libp2p.peerStore, 'load')
+    const spyDs = sinon.spy(memoryDatastore, 'query')
+
+    await libp2p.start()
+    expect(spyPeerStore).to.have.property('callCount', 1)
+    // Should be called for AddressBook and ProtoBook
+    expect(spyDs).to.have.property('callCount', 2)
+    // No data to populate
+    expect(libp2p.peerStore.peers.size).to.eq(0)
+  })
+
+  it('should store peerStore content on datastore', async () => {
+    const [peer] = await peerUtils.createPeerId({ number: 2 })
+    const multiaddrs = [multiaddr('/ip4/156.10.1.22/tcp/1000')]
+    const protocols = ['/ping/1.0.0']
+    const spyDs = sinon.spy(memoryDatastore, 'put')
+
+    await libp2p.start()
+
+    // AddressBook
+    await libp2p.peerStore.addressBook.set(peer, multiaddrs)
+
+    expect(spyDs).to.have.property('callCount', 1)
+
+    // ProtoBook
+    await libp2p.peerStore.protoBook.set(peer, protocols)
+
+    expect(spyDs).to.have.property('callCount', 2)
+
+    // Should have two peer records stored in the datastore
+    const queryParams = {
+      prefix: '/peers/'
+    }
+    let count = 0
+    for await (const _ of memoryDatastore.query(queryParams)) { // eslint-disable-line
+      count++
+    }
+    expect(count).to.equal(2)
+  })
+
+  it('should load content to the peerStore when restart but not put in datastore again', async () => {
+    const spyDs = sinon.spy(memoryDatastore, 'put')
+    const peers = await peerUtils.createPeerId({ number: 2 })
+    const multiaddrs = [
+      multiaddr('/ip4/156.10.1.22/tcp/1000'),
+      multiaddr('/ip4/156.10.1.23/tcp/1000')
+    ]
+    const protocols = ['/ping/1.0.0']
+
+    await libp2p.start()
+
+    // AddressBook
+    await libp2p.peerStore.addressBook.set(peers[0], [multiaddrs[0]])
+    await libp2p.peerStore.addressBook.set(peers[1], [multiaddrs[1]])
+
+    // ProtoBook
+    await libp2p.peerStore.protoBook.set(peers[0], protocols)
+    await libp2p.peerStore.protoBook.set(peers[1], protocols)
+
+    expect(spyDs).to.have.property('callCount', 4)
+    expect(libp2p.peerStore.peers.size).to.equal(2)
+
+    await libp2p.stop()
+
+    // Load on restart
+    const spyAb = sinon.spy(libp2p.peerStore.addressBook, '_loadData')
+    const spyPb = sinon.spy(libp2p.peerStore.protoBook, '_loadData')
+
+    await libp2p.start()
+
+    expect(spyAb).to.have.property('callCount', 1)
+    expect(spyPb).to.have.property('callCount', 1)
+    expect(spyDs).to.have.property('callCount', 4)
+    expect(libp2p.peerStore.peers.size).to.equal(2)
+  })
+
+  it('should load content to the peerStore when a new node is started with the same datastore', async () => {
+    const peers = await peerUtils.createPeerId({ number: 2 })
+    const multiaddrs = [
+      multiaddr('/ip4/156.10.1.22/tcp/1000'),
+      multiaddr('/ip4/156.10.1.23/tcp/1000')
+    ]
+    const protocols = ['/ping/1.0.0']
+
+    await libp2p.start()
+
+    // AddressBook
+    await libp2p.peerStore.addressBook.set(peers[0], [multiaddrs[0]])
+    await libp2p.peerStore.addressBook.set(peers[1], [multiaddrs[1]])
+
+    // ProtoBook
+    await libp2p.peerStore.protoBook.set(peers[0], protocols)
+    await libp2p.peerStore.protoBook.set(peers[1], protocols)
+
+    expect(libp2p.peerStore.peers.size).to.equal(2)
+
+    await libp2p.stop()
+
+    // Use a new node with the previously populated datastore
+    const [newNode] = await peerUtils.createPeer({
+      started: false,
+      config: {
+        datastore: memoryDatastore,
+        peerStore: {
+          persistance: true
+        }
+      }
+    })
+
+    expect(newNode.peerStore.peers.size).to.equal(0)
+
+    const spyAb = sinon.spy(newNode.peerStore.addressBook, '_loadData')
+    const spyPb = sinon.spy(newNode.peerStore.protoBook, '_loadData')
+
+    await newNode.start()
+
+    expect(spyAb).to.have.property('callCount', 1)
+    expect(spyPb).to.have.property('callCount', 1)
+
+    expect(newNode.peerStore.peers.size).to.equal(2)
+
+    // Validate data
+    const peer0 = newNode.peerStore.get(peers[0])
+    expect(peer0.id.toB58String()).to.eql(peers[0].toB58String())
+    expect(peer0.protocols).to.have.members(protocols)
+    expect(peer0.addresses.map((a) => a.multiaddr.toString())).to.have.members([multiaddrs[0].toString()])
+
+    const peer1 = newNode.peerStore.get(peers[1])
+    expect(peer1.id.toB58String()).to.eql(peers[1].toB58String())
+    expect(peer1.protocols).to.have.members(protocols)
+    expect(peer1.addresses.map((a) => a.multiaddr.toString())).to.have.members([multiaddrs[1].toString()])
+
+    await newNode.stop()
+  })
+})