orbitdb/test/counterdb.test.js

import assert from 'assert'
import mapSeries from 'p-each-series'
import rmrf from 'rimraf'
import OrbitDB from '../src/OrbitDB.js'
// Include test utilities
import {
  config,
  startIpfs,
  stopIpfs,
  testAPIs,
  connectPeers,
  waitForPeers
} from 'orbit-db-test-utils'

const orbitdbPath1 = './orbitdb/tests/counters/1'
const orbitdbPath2 = './orbitdb/tests/counters/2'
const dbPath1 = './orbitdb/tests/counters/db1'
const dbPath2 = './orbitdb/tests/counters/db2'

Object.keys(testAPIs).forEach(API => {
  describe(`orbit-db - Counters (${API})`, function () {
    this.timeout(config.timeout)

    let orbitdb1, orbitdb2
    let ipfsd1, ipfsd2, ipfs1, ipfs2

    before(async () => {
      rmrf.sync(dbPath1)
      rmrf.sync(dbPath2)
      rmrf.sync(orbitdbPath1)
      rmrf.sync(orbitdbPath2)
      ipfsd1 = await startIpfs(API, config.daemon1)
      ipfsd2 = await startIpfs(API, config.daemon2)
      ipfs1 = ipfsd1.api
      ipfs2 = ipfsd2.api
      // Connect the peers manually to speed up test times
      const isLocalhostAddress = (addr) => addr.toString().includes('127.0.0.1')
      await connectPeers(ipfs1, ipfs2, { filter: isLocalhostAddress })
    })

    after(async () => {
      if (orbitdb1)
        await orbitdb1.stop()

      if (orbitdb2)
        await orbitdb2.stop()

      if (ipfsd1)
        await stopIpfs(ipfsd1)

      if (ipfsd2)
        await stopIpfs(ipfsd2)
    })

    beforeEach(async () => {
      orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: './orbitdb/1' })
      orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: './orbitdb/2' })
    })

    afterEach(async () => {
      if (orbitdb1)
        await orbitdb1.stop()

      if (orbitdb2)
        await orbitdb2.stop()
    })

    describe('counters', function() {
      let address

      it('creates and opens a database', async () => {
        const db = await orbitdb1.counter('counter database')
        assert.notEqual(db, null)
        assert.equal(db.type, 'counter')
        assert.equal(db.dbname, 'counter database')
      })

      it('value is zero when it\'s a fresh database', async () => {
        const db = await orbitdb1.counter('counter database')
        assert.equal(db.value, 0)
        await db.close()
      })

      it('increases a counter value', async () => {
        const counter = await orbitdb1.counter('counter test', { path: dbPath1 })
        address = counter.address.toString()
        await mapSeries([13, 1], (f) => counter.inc(f))
        assert.equal(counter.value, 14)
        await counter.close()
      })

      it('opens a saved counter', async () => {
        const counter = await orbitdb1.counter(address, { path: dbPath1 })
        await counter.load()
        assert.equal(counter.value, 14)
        await counter.drop()
      })

      it('syncs counters', async () => {
        console.log("Sync counters")

        let options = {
          accessController: {
            // Set write access for both clients
            write: [
              orbitdb1.identity.id,
              orbitdb2.identity.id
            ]
          }
        }

        const dbName = new Date().getTime().toString()

        const numbers = [[13, 10], [2, 5]]
        const increaseCounter = (counterDB, i) => mapSeries(numbers[i], n => counterDB.inc(n))

        // Create a new counter database in the first client
        options = Object.assign({}, options, { path: dbPath1 })
        const counter1 = await orbitdb1.counter(dbName, options)

        // Open the database in the second client
        options = Object.assign({}, options, { path: dbPath2 })
        const counter2 = await orbitdb2.counter(dbName, options)

        // Make sure database addresses match since they're built deterministically
        assert.equal(counter1.address.toString(), counter2.address.toString())

        // Wait for peers to connect
        console.log("Waiting for peers to connect")
        await waitForPeers(ipfs1, [orbitdb2.id], counter1.address.toString())
        await waitForPeers(ipfs2, [orbitdb1.id], counter1.address.toString())

        let finished1 = counter1.value === 30
        let finished2 = counter2.value === 30

        counter1.events.on('replicated', () => {
          finished1 = (counter1.value === 30)
          finished2 = (counter2.value === 30)
        })
        counter2.events.on('replicated', () => {
          finished1 = (counter1.value === 30)
          finished2 = (counter2.value === 30)
        })
        counter1.events.on('write', () => {
          finished1 = (counter1.value === 30)
          finished2 = (counter2.value === 30)
        })
        counter2.events.on('write', () => {
          finished1 = (counter1.value === 30)
          finished2 = (counter2.value === 30)
        })

        // Increase the counters sequentially
        await mapSeries([counter1, counter2], increaseCounter)
        console.log("Waiting for replication to finish")

        return new Promise((resolve, reject) => {
          let timer = setInterval(async () => {
            if (finished1 && finished2) {
              try {
                clearInterval(timer)
                assert.equal(counter1.value, 30)
                assert.equal(counter2.value, 30)
                await counter1.close()
                await counter2.close()
                resolve()
              } catch (e) {
                reject(e)
              }
            }
          }, 100)
        })
      })
    })
  })
})