mirror of
https://github.com/orbitdb/orbitdb.git
synced 2025-03-30 15:08:28 +00:00
165 lines
5.5 KiB
JavaScript
165 lines
5.5 KiB
JavaScript
// 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/replicate-and-load/1'
|
|
// const orbitdbPath2 = './orbitdb/tests/replicate-and-load/2'
|
|
// const dbPath1 = './orbitdb/tests/replicate-and-load/1/db1'
|
|
// const dbPath2 = './orbitdb/tests/replicate-and-load/2/db2'
|
|
|
|
// Object.keys(testAPIs).forEach(API => {
|
|
// describe(`orbit-db - Replicate and Load (${API})`, function() {
|
|
// this.timeout(config.timeout)
|
|
|
|
// let ipfsd1, ipfsd2, ipfs1, ipfs2
|
|
// let orbitdb1, orbitdb2
|
|
|
|
// before(async () => {
|
|
// rmrf.sync(orbitdbPath1)
|
|
// rmrf.sync(orbitdbPath2)
|
|
// rmrf.sync(dbPath1)
|
|
// rmrf.sync(dbPath2)
|
|
// ipfsd1 = await startIpfs(API, config.daemon1)
|
|
// ipfsd2 = await startIpfs(API, config.daemon2)
|
|
// ipfs1 = ipfsd1.api
|
|
// ipfs2 = ipfsd2.api
|
|
// orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: orbitdbPath1 })
|
|
// orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: orbitdbPath2 })
|
|
// // 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 })
|
|
// console.log("Peers connected")
|
|
// })
|
|
|
|
// after(async () => {
|
|
// if(orbitdb1)
|
|
// await orbitdb1.stop()
|
|
|
|
// if(orbitdb2)
|
|
// await orbitdb2.stop()
|
|
|
|
// if (ipfsd1)
|
|
// await stopIpfs(ipfsd1)
|
|
|
|
// if (ipfsd2)
|
|
// await stopIpfs(ipfsd2)
|
|
|
|
// rmrf.sync(dbPath1)
|
|
// rmrf.sync(dbPath2)
|
|
// })
|
|
|
|
// describe('two peers', function() {
|
|
// let db1, db2
|
|
|
|
// const openDatabases = async (options = {}) => {
|
|
// // Set write access for both clients
|
|
// options.write = [
|
|
// orbitdb1.identity.publicKey,
|
|
// orbitdb2.identity.publicKey
|
|
// ]
|
|
|
|
// options = Object.assign({}, options, { path: dbPath1, create: true })
|
|
// db1 = await orbitdb1.eventlog('tests', options)
|
|
// // Set 'localOnly' flag on and it'll error if the database doesn't exist locally
|
|
// options = Object.assign({}, options, { path: dbPath2 })
|
|
// db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
|
// }
|
|
|
|
// before(async () => {
|
|
// await openDatabases()
|
|
|
|
// assert.equal(db1.address.toString(), db2.address.toString())
|
|
|
|
// console.log("Waiting for peers...")
|
|
// await waitForPeers(ipfs1, [orbitdb2.id], db1.address.toString())
|
|
// await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
|
// })
|
|
|
|
// after(async () => {
|
|
// if (db1) {
|
|
// await db1.drop()
|
|
// }
|
|
|
|
// if (db2) {
|
|
// await db2.drop()
|
|
// }
|
|
// })
|
|
|
|
// it('replicates database of 100 entries and loads it from the disk', async () => {
|
|
// const entryCount = 100
|
|
// const entryArr = []
|
|
// let timer
|
|
|
|
// for (let i = 0; i < entryCount; i ++)
|
|
// entryArr.push(i)
|
|
|
|
// console.log("Writing to database...")
|
|
// await mapSeries(entryArr, (i) => db1.add('hello' + i))
|
|
// console.log("Done")
|
|
|
|
// return new Promise((resolve, reject) => {
|
|
// timer = setInterval(async () => {
|
|
// if (db2._oplog.length === entryCount) {
|
|
// clearInterval(timer)
|
|
|
|
// const items = db2.iterator({ limit: -1 }).collect()
|
|
// assert.equal(items.length, entryCount)
|
|
// assert.equal(items[0].payload.value, 'hello0')
|
|
// assert.equal(items[items.length - 1].payload.value, 'hello99')
|
|
|
|
// try {
|
|
|
|
// // Set write access for both clients
|
|
// let options = {
|
|
// accessController: {
|
|
// write: [
|
|
// orbitdb1.identity.id,
|
|
// orbitdb2.identity.id
|
|
// ]
|
|
// }
|
|
// }
|
|
|
|
// // Get the previous address to make sure nothing mutates it
|
|
// const addr = db1.address.toString()
|
|
|
|
// // Open the database again (this time from the disk)
|
|
// options = Object.assign({}, options, { path: dbPath1, create: false })
|
|
// const db3 = await orbitdb1.eventlog(addr, options)
|
|
// // Set 'localOnly' flag on and it'll error if the database doesn't exist locally
|
|
// options = Object.assign({}, options, { path: dbPath2, localOnly: true })
|
|
// const db4 = await orbitdb2.eventlog(addr, options)
|
|
|
|
// await db3.load()
|
|
// await db4.load()
|
|
|
|
// // Make sure we have all the entries in the databases
|
|
// const result1 = db3.iterator({ limit: -1 }).collect()
|
|
// const result2 = db4.iterator({ limit: -1 }).collect()
|
|
// assert.equal(result1.length, entryCount)
|
|
// assert.equal(result2.length, entryCount)
|
|
|
|
// await db3.drop()
|
|
// await db4.drop()
|
|
// } catch (e) {
|
|
// reject(e)
|
|
// }
|
|
// resolve()
|
|
// }
|
|
// }, 1000)
|
|
// })
|
|
// })
|
|
// })
|
|
// })
|
|
// })
|