1  const async = require('async')
  2  const test = require('tape')
  3  const util = require('./util.js')
  4  
  5  async function delay (ms) {
  6    await new Promise((resolve) => setTimeout(resolve, ms))
  7  }
  8  
  9  test('DPT: new working node', async (t) => {
 10    const dpts = util.initTwoPeerDPTSetup()
 11  
 12    dpts[0].on('peer:new', function (peer) {
 13      t.equal(peer.address, '127.0.0.1', 'should have added peer on peer:new')
 14      util.destroyDPTs(dpts)
 15      t.end()
 16    })
 17  })
 18  
 19  test('DPT: working node added', async (t) => {
 20    const dpts = util.initTwoPeerDPTSetup()
 21  
 22    dpts[0].on('peer:added', function (peer) {
 23      t.equal(dpts[0].getPeers().length, 1, 'should have added peer to k-bucket on peer:added')
 24      util.destroyDPTs(dpts)
 25      t.end()
 26    })
 27  })
 28  
 29  test('DPT: remove node', async (t) => {
 30    const dpts = util.initTwoPeerDPTSetup()
 31  
 32    async.series([
 33      function (cb) {
 34        dpts[0].on('peer:added', function (peer) {
 35          dpts[0].removePeer(peer)
 36          cb(null)
 37        })
 38      },
 39      function (cb) {
 40        dpts[0].on('peer:removed', function (peer) {
 41          t.equal(dpts[0].getPeers().length, 0, 'should have removed peer from k-bucket on peer:removed')
 42          cb(null)
 43        })
 44      }
 45    ],
 46    function (err, results) {
 47      if (err) {
 48        t.fail('An unexpected error occured.')
 49      }
 50      util.destroyDPTs(dpts)
 51      t.end()
 52    })
 53  })
 54  
 55  test('DPT: ban node', async (t) => {
 56    const dpts = util.initTwoPeerDPTSetup()
 57  
 58    async.series([
 59      function (cb) {
 60        dpts[0].on('peer:added', function (peer) {
 61          dpts[0].banPeer(peer)
 62          cb(null)
 63        })
 64      },
 65      function (cb) {
 66        dpts[0].on('peer:removed', function (peer) {
 67          t.equal(dpts[0]._banlist.has(peer), true, 'ban-list should contain peer')
 68          t.equal(dpts[0].getPeers().length, 0, 'should have removed peer from k-bucket on peer:removed')
 69          cb(null)
 70        })
 71      }
 72    ],
 73    function (err, results) {
 74      if (err) {
 75        t.fail('An unexpected error occured.')
 76      }
 77      util.destroyDPTs(dpts)
 78      t.end()
 79    })
 80  })
 81  
 82  test('DPT: k-bucket ping', async (t) => {
 83    const dpts = util.initTwoPeerDPTSetup()
 84  
 85    async.series([
 86      function (cb) {
 87        dpts[0].on('peer:added', function (peer) {
 88          dpts[0]._onKBucketPing([peer], peer)
 89          setTimeout(function () {
 90            cb(null)
 91          }, 400)
 92        })
 93      },
 94      function (cb) {
 95        t.equal(dpts[0].getPeers().length, 1, 'should still have one peer in k-bucket')
 96        cb(null)
 97      }
 98    ],
 99    function (err, results) {
100      if (err) {
101        t.fail('An unexpected error occured.')
102      }
103      util.destroyDPTs(dpts)
104      t.end()
105    })
106  })
107  
108  test('DPT: add non-available node', async (t) => {
109    const dpts = util.getTestDPTs(1)
110    const peer = { address: util.localhost, udpPort: util.basePort + 1 }
111  
112    await dpts[0].addPeer(peer).catch((e) => {
113      t.equal(e.message, 'Timeout error: ping 127.0.0.1:30307', 'should throw Timeout error')
114      util.destroyDPTs(dpts)
115      t.end()
116    })
117  })
118  
119  test('DPT: simulate bootstrap', async (t) => {
120    const numDPTs = 6
121    const dpts = util.getTestDPTs(numDPTs)
122  
123    await delay(250)
124    await dpts[0].addPeer({ address: util.localhost, udpPort: util.basePort + 1 })
125    await delay(100)
126  
127    for (let dpt of dpts.slice(2)) {
128      await dpt.bootstrap({ address: util.localhost, udpPort: util.basePort + 1 })
129    }
130  
131    for (let dpt of dpts) {
132      dpt.refresh()
133      await delay(400)
134    }
135  
136    await delay(250)
137    util.destroyDPTs(dpts)
138  
139    // dpts.forEach((dpt, i) => console.log(`${i}:${dpt.getPeers().length}`))
140    for (let dpt of dpts) t.equal(dpt.getPeers().length, numDPTs, 'Peers should be distributed to all DPTs')
141  
142    t.end()
143  })