mirror of
https://github.com/orbitdb/orbitdb.git
synced 2025-10-07 22:57:07 +00:00
Get the first tests running
This commit is contained in:
haad
@@ -1,413 +1,413 @@
|
||||
import assert from 'assert'
|
||||
import mapSeries from 'p-each-series'
|
||||
import rmrf from 'rimraf'
|
||||
import OrbitDB from '../src/OrbitDB.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'
|
||||
// // Include test utilities
|
||||
// import {
|
||||
// config,
|
||||
// startIpfs,
|
||||
// stopIpfs,
|
||||
// testAPIs,
|
||||
// connectPeers,
|
||||
// waitForPeers,
|
||||
// } from 'orbit-db-test-utils'
|
||||
|
||||
const orbitdbPath1 = './orbitdb/tests/replication/1'
|
||||
const orbitdbPath2 = './orbitdb/tests/replication/2'
|
||||
const dbPath1 = './orbitdb/tests/replication/1/db1'
|
||||
const dbPath2 = './orbitdb/tests/replication/2/db2'
|
||||
// const orbitdbPath1 = './orbitdb/tests/replication/1'
|
||||
// const orbitdbPath2 = './orbitdb/tests/replication/2'
|
||||
// const dbPath1 = './orbitdb/tests/replication/1/db1'
|
||||
// const dbPath2 = './orbitdb/tests/replication/2/db2'
|
||||
|
||||
Object.keys(testAPIs).forEach(API => {
|
||||
describe(`orbit-db - Replication (${API})`, function() {
|
||||
this.timeout(config.timeout * 2)
|
||||
// Object.keys(testAPIs).forEach(API => {
|
||||
// describe(`orbit-db - Replication (${API})`, function() {
|
||||
// this.timeout(config.timeout * 2)
|
||||
|
||||
let ipfsd1, ipfsd2, ipfs1, ipfs2
|
||||
let orbitdb1, orbitdb2, db1, db2
|
||||
// let ipfsd1, ipfsd2, ipfs1, ipfs2
|
||||
// let orbitdb1, orbitdb2, db1, db2
|
||||
|
||||
let timer
|
||||
let options
|
||||
// let timer
|
||||
// let options
|
||||
|
||||
before(async () => {
|
||||
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 })
|
||||
console.log("Peers connected")
|
||||
})
|
||||
// before(async () => {
|
||||
// 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 })
|
||||
// console.log("Peers connected")
|
||||
// })
|
||||
|
||||
after(async () => {
|
||||
if (ipfsd1)
|
||||
await stopIpfs(ipfsd1)
|
||||
// after(async () => {
|
||||
// if (ipfsd1)
|
||||
// await stopIpfs(ipfsd1)
|
||||
|
||||
if (ipfsd2)
|
||||
await stopIpfs(ipfsd2)
|
||||
})
|
||||
// if (ipfsd2)
|
||||
// await stopIpfs(ipfsd2)
|
||||
// })
|
||||
|
||||
beforeEach(async () => {
|
||||
clearInterval(timer)
|
||||
// beforeEach(async () => {
|
||||
// clearInterval(timer)
|
||||
|
||||
rmrf.sync(orbitdbPath1)
|
||||
rmrf.sync(orbitdbPath2)
|
||||
rmrf.sync(dbPath1)
|
||||
rmrf.sync(dbPath2)
|
||||
// rmrf.sync(orbitdbPath1)
|
||||
// rmrf.sync(orbitdbPath2)
|
||||
// rmrf.sync(dbPath1)
|
||||
// rmrf.sync(dbPath2)
|
||||
|
||||
orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: orbitdbPath1 })
|
||||
orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: orbitdbPath2 })
|
||||
// orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: orbitdbPath1 })
|
||||
// orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: orbitdbPath2 })
|
||||
|
||||
options = {
|
||||
// Set write access for both clients
|
||||
accessController: {
|
||||
write: [
|
||||
orbitdb1.identity.id,
|
||||
orbitdb2.identity.id
|
||||
]
|
||||
}
|
||||
}
|
||||
// options = {
|
||||
// // Set write access for both clients
|
||||
// accessController: {
|
||||
// write: [
|
||||
// orbitdb1.identity.id,
|
||||
// orbitdb2.identity.id
|
||||
// ]
|
||||
// }
|
||||
// }
|
||||
|
||||
options = Object.assign({}, options, { directory: dbPath1 })
|
||||
db1 = await orbitdb1.eventlog('replication-tests', options)
|
||||
})
|
||||
// options = Object.assign({}, options, { directory: dbPath1 })
|
||||
// db1 = await orbitdb1.eventlog('replication-tests', options)
|
||||
// })
|
||||
|
||||
afterEach(async () => {
|
||||
clearInterval(timer)
|
||||
options = {}
|
||||
// afterEach(async () => {
|
||||
// clearInterval(timer)
|
||||
// options = {}
|
||||
|
||||
if (db1)
|
||||
await db1.drop()
|
||||
// if (db1)
|
||||
// await db1.drop()
|
||||
|
||||
if (db2)
|
||||
await db2.drop()
|
||||
// if (db2)
|
||||
// await db2.drop()
|
||||
|
||||
if(orbitdb1)
|
||||
await orbitdb1.stop()
|
||||
// if(orbitdb1)
|
||||
// await orbitdb1.stop()
|
||||
|
||||
if(orbitdb2)
|
||||
await orbitdb2.stop()
|
||||
})
|
||||
// if(orbitdb2)
|
||||
// await orbitdb2.stop()
|
||||
// })
|
||||
|
||||
it('replicates database of 1 entry', async () => {
|
||||
console.log("Waiting for peers to connect")
|
||||
await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
// Set 'sync' flag on. It'll prevent creating a new local database and rather
|
||||
// fetch the database from the network
|
||||
options = Object.assign({}, options, { directory: dbPath2, sync: true })
|
||||
db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
// it('replicates database of 1 entry', async () => {
|
||||
// console.log("Waiting for peers to connect")
|
||||
// await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
// // Set 'sync' flag on. It'll prevent creating a new local database and rather
|
||||
// // fetch the database from the network
|
||||
// options = Object.assign({}, options, { directory: dbPath2, sync: true })
|
||||
// db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
|
||||
let finished = false
|
||||
// let finished = false
|
||||
|
||||
await db1.add('hello')
|
||||
// await db1.add('hello')
|
||||
|
||||
return new Promise(resolve => {
|
||||
let replicatedEventCount = 0
|
||||
db2.events.on('replicated', (address, length) => {
|
||||
replicatedEventCount++
|
||||
// Once db2 has finished replication, make sure it has all elements
|
||||
// and process to the asserts below
|
||||
const all = db2.iterator({ limit: -1 }).collect().length
|
||||
finished = (all === 1)
|
||||
})
|
||||
// return new Promise(resolve => {
|
||||
// let replicatedEventCount = 0
|
||||
// db2.events.on('replicated', (address, length) => {
|
||||
// replicatedEventCount++
|
||||
// // Once db2 has finished replication, make sure it has all elements
|
||||
// // and process to the asserts below
|
||||
// const all = db2.iterator({ limit: -1 }).collect().length
|
||||
// finished = (all === 1)
|
||||
// })
|
||||
|
||||
timer = setInterval(() => {
|
||||
if (finished) {
|
||||
clearInterval(timer)
|
||||
const entries = db2.iterator({ limit: -1 }).collect()
|
||||
assert.equal(entries.length, 1)
|
||||
assert.equal(entries[0].payload.value, 'hello')
|
||||
assert.equal(replicatedEventCount, 1)
|
||||
resolve()
|
||||
}
|
||||
}, 100)
|
||||
})
|
||||
})
|
||||
// timer = setInterval(() => {
|
||||
// if (finished) {
|
||||
// clearInterval(timer)
|
||||
// const entries = db2.iterator({ limit: -1 }).collect()
|
||||
// assert.equal(entries.length, 1)
|
||||
// assert.equal(entries[0].payload.value, 'hello')
|
||||
// assert.equal(replicatedEventCount, 1)
|
||||
// resolve()
|
||||
// }
|
||||
// }, 100)
|
||||
// })
|
||||
// })
|
||||
|
||||
it('replicates database of 100 entries', async () => {
|
||||
console.log("Waiting for peers to connect")
|
||||
await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
// it('replicates database of 100 entries', async () => {
|
||||
// console.log("Waiting for peers to connect")
|
||||
// await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
|
||||
options = Object.assign({}, options, { directory: dbPath2, sync: true })
|
||||
db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
// options = Object.assign({}, options, { directory: dbPath2, sync: true })
|
||||
// db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
|
||||
let finished = false
|
||||
const entryCount = 100
|
||||
const entryArr = []
|
||||
// let finished = false
|
||||
// const entryCount = 100
|
||||
// const entryArr = []
|
||||
|
||||
for (let i = 0; i < entryCount; i ++)
|
||||
entryArr.push(i)
|
||||
// for (let i = 0; i < entryCount; i ++)
|
||||
// entryArr.push(i)
|
||||
|
||||
return new Promise(async (resolve, reject) => {
|
||||
db2.events.on('replicated', () => {
|
||||
// Once db2 has finished replication, make sure it has all elements
|
||||
// and process to the asserts below
|
||||
const all = db2.iterator({ limit: -1 }).collect().length
|
||||
finished = (all === entryCount)
|
||||
})
|
||||
// return new Promise(async (resolve, reject) => {
|
||||
// db2.events.on('replicated', () => {
|
||||
// // Once db2 has finished replication, make sure it has all elements
|
||||
// // and process to the asserts below
|
||||
// const all = db2.iterator({ limit: -1 }).collect().length
|
||||
// finished = (all === entryCount)
|
||||
// })
|
||||
|
||||
try {
|
||||
const add = i => db1.add('hello' + i)
|
||||
await mapSeries(entryArr, add)
|
||||
} catch (e) {
|
||||
reject(e)
|
||||
}
|
||||
// try {
|
||||
// const add = i => db1.add('hello' + i)
|
||||
// await mapSeries(entryArr, add)
|
||||
// } catch (e) {
|
||||
// reject(e)
|
||||
// }
|
||||
|
||||
timer = setInterval(() => {
|
||||
if (finished) {
|
||||
clearInterval(timer)
|
||||
const entries = db2.iterator({ limit: -1 }).collect()
|
||||
assert.equal(entries.length, entryCount)
|
||||
assert.equal(entries[0].payload.value, 'hello0')
|
||||
assert.equal(entries[entries.length - 1].payload.value, 'hello99')
|
||||
resolve()
|
||||
}
|
||||
}, 100)
|
||||
})
|
||||
})
|
||||
// timer = setInterval(() => {
|
||||
// if (finished) {
|
||||
// clearInterval(timer)
|
||||
// const entries = db2.iterator({ limit: -1 }).collect()
|
||||
// assert.equal(entries.length, entryCount)
|
||||
// assert.equal(entries[0].payload.value, 'hello0')
|
||||
// assert.equal(entries[entries.length - 1].payload.value, 'hello99')
|
||||
// resolve()
|
||||
// }
|
||||
// }, 100)
|
||||
// })
|
||||
// })
|
||||
|
||||
it('emits correct replication info', async () => {
|
||||
console.log("Waiting for peers to connect")
|
||||
await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
// it('emits correct replication info', async () => {
|
||||
// console.log("Waiting for peers to connect")
|
||||
// await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
|
||||
options = Object.assign({}, options, { directory: dbPath2, sync: true })
|
||||
db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
// options = Object.assign({}, options, { directory: dbPath2, sync: true })
|
||||
// db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
|
||||
let finished = false
|
||||
const entryCount = 99
|
||||
// let finished = false
|
||||
// const entryCount = 99
|
||||
|
||||
return new Promise(async (resolve, reject) => {
|
||||
// Test that none of the entries gets into the replication queue twice
|
||||
const replicateSet = new Set()
|
||||
db2.events.on('replicate', (address, entry) => {
|
||||
if (!replicateSet.has(entry.hash)) {
|
||||
replicateSet.add(entry.hash)
|
||||
} else {
|
||||
reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash + '\n' + entry.payload.value))
|
||||
}
|
||||
})
|
||||
// return new Promise(async (resolve, reject) => {
|
||||
// // Test that none of the entries gets into the replication queue twice
|
||||
// const replicateSet = new Set()
|
||||
// db2.events.on('replicate', (address, entry) => {
|
||||
// if (!replicateSet.has(entry.hash)) {
|
||||
// replicateSet.add(entry.hash)
|
||||
// } else {
|
||||
// reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash + '\n' + entry.payload.value))
|
||||
// }
|
||||
// })
|
||||
|
||||
// Verify that progress count increases monotonically by saving
|
||||
// each event's current progress into an array
|
||||
const progressEvents = []
|
||||
db2.events.on('replicate.progress', () => {
|
||||
progressEvents.push(db2.replicationStatus.progress)
|
||||
})
|
||||
// // Verify that progress count increases monotonically by saving
|
||||
// // each event's current progress into an array
|
||||
// const progressEvents = []
|
||||
// db2.events.on('replicate.progress', () => {
|
||||
// progressEvents.push(db2.replicationStatus.progress)
|
||||
// })
|
||||
|
||||
db2.events.on('replicated', (address, length) => {
|
||||
// Once db2 has finished replication, make sure it has all elements
|
||||
// and process to the asserts below
|
||||
const all = db2.iterator({ limit: -1 }).collect().length
|
||||
finished = (all === entryCount)
|
||||
})
|
||||
// db2.events.on('replicated', (address, length) => {
|
||||
// // Once db2 has finished replication, make sure it has all elements
|
||||
// // and process to the asserts below
|
||||
// const all = db2.iterator({ limit: -1 }).collect().length
|
||||
// finished = (all === entryCount)
|
||||
// })
|
||||
|
||||
try {
|
||||
timer = setInterval(() => {
|
||||
if (finished) {
|
||||
clearInterval(timer)
|
||||
// All entries should be in the database
|
||||
assert.equal(db2.iterator({ limit: -1 }).collect().length, entryCount)
|
||||
// progress events should increase monotonically
|
||||
assert.equal(progressEvents.length, entryCount)
|
||||
for (const [idx, e] of progressEvents.entries()) {
|
||||
assert.equal(e, idx + 1)
|
||||
}
|
||||
// Verify replication status
|
||||
assert.equal(db2.replicationStatus.progress, entryCount)
|
||||
assert.equal(db2.replicationStatus.max, entryCount)
|
||||
// Verify replicator state
|
||||
assert.equal(db2._replicator.tasksRunning, 0)
|
||||
assert.equal(db2._replicator.tasksQueued, 0)
|
||||
assert.equal(db2._replicator.unfinished.length, 0)
|
||||
// Replicator's internal caches should be empty
|
||||
assert.equal(db2._replicator._logs.length, 0)
|
||||
assert.equal(Object.keys(db2._replicator._fetching).length, 0)
|
||||
// try {
|
||||
// timer = setInterval(() => {
|
||||
// if (finished) {
|
||||
// clearInterval(timer)
|
||||
// // All entries should be in the database
|
||||
// assert.equal(db2.iterator({ limit: -1 }).collect().length, entryCount)
|
||||
// // progress events should increase monotonically
|
||||
// assert.equal(progressEvents.length, entryCount)
|
||||
// for (const [idx, e] of progressEvents.entries()) {
|
||||
// assert.equal(e, idx + 1)
|
||||
// }
|
||||
// // Verify replication status
|
||||
// assert.equal(db2.replicationStatus.progress, entryCount)
|
||||
// assert.equal(db2.replicationStatus.max, entryCount)
|
||||
// // Verify replicator state
|
||||
// assert.equal(db2._replicator.tasksRunning, 0)
|
||||
// assert.equal(db2._replicator.tasksQueued, 0)
|
||||
// assert.equal(db2._replicator.unfinished.length, 0)
|
||||
// // Replicator's internal caches should be empty
|
||||
// assert.equal(db2._replicator._logs.length, 0)
|
||||
// assert.equal(Object.keys(db2._replicator._fetching).length, 0)
|
||||
|
||||
resolve()
|
||||
}
|
||||
}, 1000)
|
||||
} catch (e) {
|
||||
reject(e)
|
||||
}
|
||||
// resolve()
|
||||
// }
|
||||
// }, 1000)
|
||||
// } catch (e) {
|
||||
// reject(e)
|
||||
// }
|
||||
|
||||
// Trigger replication
|
||||
let adds = []
|
||||
for (let i = 0; i < entryCount; i ++) {
|
||||
adds.push(i)
|
||||
}
|
||||
// // Trigger replication
|
||||
// let adds = []
|
||||
// for (let i = 0; i < entryCount; i ++) {
|
||||
// adds.push(i)
|
||||
// }
|
||||
|
||||
await mapSeries(adds, i => db1.add('hello ' + i))
|
||||
})
|
||||
})
|
||||
// await mapSeries(adds, i => db1.add('hello ' + i))
|
||||
// })
|
||||
// })
|
||||
|
||||
it('emits correct replication info on fresh replication', async () => {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
let finished = false
|
||||
const entryCount = 512
|
||||
// it('emits correct replication info on fresh replication', async () => {
|
||||
// return new Promise(async (resolve, reject) => {
|
||||
// let finished = false
|
||||
// const entryCount = 512
|
||||
|
||||
// Trigger replication
|
||||
const adds = []
|
||||
for (let i = 0; i < entryCount; i ++) {
|
||||
adds.push(i)
|
||||
}
|
||||
// // Trigger replication
|
||||
// const adds = []
|
||||
// for (let i = 0; i < entryCount; i ++) {
|
||||
// adds.push(i)
|
||||
// }
|
||||
|
||||
const add = async (i) => {
|
||||
process.stdout.write("\rWriting " + (i + 1) + " / " + entryCount + " ")
|
||||
await db1.add('hello ' + i)
|
||||
}
|
||||
// const add = async (i) => {
|
||||
// process.stdout.write("\rWriting " + (i + 1) + " / " + entryCount + " ")
|
||||
// await db1.add('hello ' + i)
|
||||
// }
|
||||
|
||||
await mapSeries(adds, add)
|
||||
console.log()
|
||||
// await mapSeries(adds, add)
|
||||
// console.log()
|
||||
|
||||
// Open second instance again
|
||||
options = {
|
||||
directory: dbPath2,
|
||||
overwrite: true,
|
||||
sync: true,
|
||||
}
|
||||
// // Open second instance again
|
||||
// options = {
|
||||
// directory: dbPath2,
|
||||
// overwrite: true,
|
||||
// sync: true,
|
||||
// }
|
||||
|
||||
db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
// db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
|
||||
// Test that none of the entries gets into the replication queue twice
|
||||
const replicateSet = new Set()
|
||||
db2.events.on('replicate', (address, entry) => {
|
||||
if (!replicateSet.has(entry.hash)) {
|
||||
replicateSet.add(entry.hash)
|
||||
} else {
|
||||
reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash))
|
||||
}
|
||||
})
|
||||
// // Test that none of the entries gets into the replication queue twice
|
||||
// const replicateSet = new Set()
|
||||
// db2.events.on('replicate', (address, entry) => {
|
||||
// if (!replicateSet.has(entry.hash)) {
|
||||
// replicateSet.add(entry.hash)
|
||||
// } else {
|
||||
// reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash))
|
||||
// }
|
||||
// })
|
||||
|
||||
// Verify that progress count increases monotonically by saving
|
||||
// each event's current progress into an array
|
||||
const progressEvents = []
|
||||
db2.events.on('replicate.progress', (address, hash, entry) => {
|
||||
progressEvents.push(db2.replicationStatus.progress)
|
||||
})
|
||||
// // Verify that progress count increases monotonically by saving
|
||||
// // each event's current progress into an array
|
||||
// const progressEvents = []
|
||||
// db2.events.on('replicate.progress', (address, hash, entry) => {
|
||||
// progressEvents.push(db2.replicationStatus.progress)
|
||||
// })
|
||||
|
||||
let replicatedEventCount = 0
|
||||
db2.events.on('replicated', (address, length) => {
|
||||
replicatedEventCount++
|
||||
// Once db2 has finished replication, make sure it has all elements
|
||||
// and process to the asserts below
|
||||
const all = db2.iterator({ limit: -1 }).collect().length
|
||||
finished = (all === entryCount)
|
||||
})
|
||||
// let replicatedEventCount = 0
|
||||
// db2.events.on('replicated', (address, length) => {
|
||||
// replicatedEventCount++
|
||||
// // Once db2 has finished replication, make sure it has all elements
|
||||
// // and process to the asserts below
|
||||
// const all = db2.iterator({ limit: -1 }).collect().length
|
||||
// finished = (all === entryCount)
|
||||
// })
|
||||
|
||||
timer = setInterval(async () => {
|
||||
if (finished) {
|
||||
clearInterval(timer)
|
||||
// timer = setInterval(async () => {
|
||||
// if (finished) {
|
||||
// clearInterval(timer)
|
||||
|
||||
try {
|
||||
// All entries should be in the database
|
||||
assert.equal(db2.iterator({ limit: -1 }).collect().length, entryCount)
|
||||
// 'replicated' event should've been received only once
|
||||
assert.equal(replicatedEventCount, 1)
|
||||
// progress events should increase monotonically
|
||||
assert.equal(progressEvents.length, entryCount)
|
||||
for (const [idx, e] of progressEvents.entries()) {
|
||||
assert.equal(e, idx + 1)
|
||||
}
|
||||
// Verify replication status
|
||||
assert.equal(db2.replicationStatus.progress, entryCount)
|
||||
assert.equal(db2.replicationStatus.max, entryCount)
|
||||
// Verify replicator state
|
||||
assert.equal(db2._replicator.tasksRunning, 0)
|
||||
assert.equal(db2._replicator.tasksQueued, 0)
|
||||
assert.equal(db2._replicator.unfinished.length, 0)
|
||||
// Replicator's internal caches should be empty
|
||||
assert.equal(db2._replicator._logs.length, 0)
|
||||
assert.equal(Object.keys(db2._replicator._fetching).length, 0)
|
||||
// try {
|
||||
// // All entries should be in the database
|
||||
// assert.equal(db2.iterator({ limit: -1 }).collect().length, entryCount)
|
||||
// // 'replicated' event should've been received only once
|
||||
// assert.equal(replicatedEventCount, 1)
|
||||
// // progress events should increase monotonically
|
||||
// assert.equal(progressEvents.length, entryCount)
|
||||
// for (const [idx, e] of progressEvents.entries()) {
|
||||
// assert.equal(e, idx + 1)
|
||||
// }
|
||||
// // Verify replication status
|
||||
// assert.equal(db2.replicationStatus.progress, entryCount)
|
||||
// assert.equal(db2.replicationStatus.max, entryCount)
|
||||
// // Verify replicator state
|
||||
// assert.equal(db2._replicator.tasksRunning, 0)
|
||||
// assert.equal(db2._replicator.tasksQueued, 0)
|
||||
// assert.equal(db2._replicator.unfinished.length, 0)
|
||||
// // Replicator's internal caches should be empty
|
||||
// assert.equal(db2._replicator._logs.length, 0)
|
||||
// assert.equal(Object.keys(db2._replicator._fetching).length, 0)
|
||||
|
||||
resolve()
|
||||
} catch (e) {
|
||||
reject(e)
|
||||
}
|
||||
}
|
||||
}, 100)
|
||||
})
|
||||
})
|
||||
// resolve()
|
||||
// } catch (e) {
|
||||
// reject(e)
|
||||
// }
|
||||
// }
|
||||
// }, 100)
|
||||
// })
|
||||
// })
|
||||
|
||||
it('emits correct replication info in two-way replication', async () => {
|
||||
return new Promise(async (resolve, reject) => {
|
||||
console.log("Waiting for peers to connect")
|
||||
await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
// it('emits correct replication info in two-way replication', async () => {
|
||||
// return new Promise(async (resolve, reject) => {
|
||||
// console.log("Waiting for peers to connect")
|
||||
// await waitForPeers(ipfs2, [orbitdb1.id], db1.address.toString())
|
||||
|
||||
let finished = false
|
||||
const entryCount = 100
|
||||
// let finished = false
|
||||
// const entryCount = 100
|
||||
|
||||
// Trigger replication
|
||||
const adds = []
|
||||
for (let i = 0; i < entryCount; i ++) {
|
||||
adds.push(i)
|
||||
}
|
||||
// // Trigger replication
|
||||
// const adds = []
|
||||
// for (let i = 0; i < entryCount; i ++) {
|
||||
// adds.push(i)
|
||||
// }
|
||||
|
||||
const add = async (i) => {
|
||||
process.stdout.write("\rWriting " + (i + 1) + " / " + entryCount + " ")
|
||||
await Promise.all([db1.add('hello-1-' + i), db2.add('hello-2-' + i)])
|
||||
}
|
||||
// const add = async (i) => {
|
||||
// process.stdout.write("\rWriting " + (i + 1) + " / " + entryCount + " ")
|
||||
// await Promise.all([db1.add('hello-1-' + i), db2.add('hello-2-' + i)])
|
||||
// }
|
||||
|
||||
// Open second instance again
|
||||
let options = {
|
||||
directory: dbPath2 + '2',
|
||||
overwrite: true,
|
||||
sync: true,
|
||||
}
|
||||
// // Open second instance again
|
||||
// let options = {
|
||||
// directory: dbPath2 + '2',
|
||||
// overwrite: true,
|
||||
// sync: true,
|
||||
// }
|
||||
|
||||
db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
assert.equal(db1.address.toString(), db2.address.toString())
|
||||
// db2 = await orbitdb2.eventlog(db1.address.toString(), options)
|
||||
// assert.equal(db1.address.toString(), db2.address.toString())
|
||||
|
||||
// Test that none of the entries gets into the replication queue twice
|
||||
const replicateSet = new Set()
|
||||
db2.events.on('replicate', (address, entry) => {
|
||||
if (!replicateSet.has(entry.hash)) {
|
||||
replicateSet.add(entry.hash)
|
||||
} else {
|
||||
reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash))
|
||||
}
|
||||
})
|
||||
// // Test that none of the entries gets into the replication queue twice
|
||||
// const replicateSet = new Set()
|
||||
// db2.events.on('replicate', (address, entry) => {
|
||||
// if (!replicateSet.has(entry.hash)) {
|
||||
// replicateSet.add(entry.hash)
|
||||
// } else {
|
||||
// reject(new Error('Shouldn\'t have started replication twice for entry ' + entry.hash))
|
||||
// }
|
||||
// })
|
||||
|
||||
db2.events.on('replicated', (address, length) => {
|
||||
// Once db2 has finished replication, make sure it has all elements
|
||||
// and process to the asserts below
|
||||
const all = db2.iterator({ limit: -1 }).collect().length
|
||||
finished = (all === entryCount * 2)
|
||||
})
|
||||
// db2.events.on('replicated', (address, length) => {
|
||||
// // Once db2 has finished replication, make sure it has all elements
|
||||
// // and process to the asserts below
|
||||
// const all = db2.iterator({ limit: -1 }).collect().length
|
||||
// finished = (all === entryCount * 2)
|
||||
// })
|
||||
|
||||
try {
|
||||
await mapSeries(adds, add)
|
||||
console.log()
|
||||
// try {
|
||||
// await mapSeries(adds, add)
|
||||
// console.log()
|
||||
|
||||
timer = setInterval(() => {
|
||||
if (finished) {
|
||||
clearInterval(timer)
|
||||
// timer = setInterval(() => {
|
||||
// if (finished) {
|
||||
// clearInterval(timer)
|
||||
|
||||
// Database values should match
|
||||
const values1 = db1.iterator({limit: -1}).collect()
|
||||
const values2 = db2.iterator({limit: -1}).collect()
|
||||
assert.equal(values1.length, values2.length)
|
||||
assert.deepEqual(values1, values2)
|
||||
// All entries should be in the database
|
||||
assert.equal(values1.length, entryCount * 2)
|
||||
assert.equal(values2.length, entryCount * 2)
|
||||
// Verify replication status
|
||||
assert.equal(db2.replicationStatus.progress, entryCount * 2)
|
||||
assert.equal(db2.replicationStatus.max, entryCount * 2)
|
||||
// Verify replicator state
|
||||
assert.equal(db2._replicator.tasksRunning, 0)
|
||||
assert.equal(db2._replicator.tasksQueued, 0)
|
||||
assert.equal(db2._replicator.unfinished.length, 0)
|
||||
// Replicator's internal caches should be empty
|
||||
assert.equal(db2._replicator._logs.length, 0)
|
||||
assert.equal(Object.keys(db2._replicator._fetching).length, 0)
|
||||
// // Database values should match
|
||||
// const values1 = db1.iterator({limit: -1}).collect()
|
||||
// const values2 = db2.iterator({limit: -1}).collect()
|
||||
// assert.equal(values1.length, values2.length)
|
||||
// assert.deepEqual(values1, values2)
|
||||
// // All entries should be in the database
|
||||
// assert.equal(values1.length, entryCount * 2)
|
||||
// assert.equal(values2.length, entryCount * 2)
|
||||
// // Verify replication status
|
||||
// assert.equal(db2.replicationStatus.progress, entryCount * 2)
|
||||
// assert.equal(db2.replicationStatus.max, entryCount * 2)
|
||||
// // Verify replicator state
|
||||
// assert.equal(db2._replicator.tasksRunning, 0)
|
||||
// assert.equal(db2._replicator.tasksQueued, 0)
|
||||
// assert.equal(db2._replicator.unfinished.length, 0)
|
||||
// // Replicator's internal caches should be empty
|
||||
// assert.equal(db2._replicator._logs.length, 0)
|
||||
// assert.equal(Object.keys(db2._replicator._fetching).length, 0)
|
||||
|
||||
resolve()
|
||||
}
|
||||
}, 500)
|
||||
} catch (e) {
|
||||
reject(e)
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
// resolve()
|
||||
// }
|
||||
// }, 500)
|
||||
// } catch (e) {
|
||||
// reject(e)
|
||||
// }
|
||||
// })
|
||||
// })
|
||||
// })
|
||||
// })
|
||||
|
||||
Reference in New Issue
Block a user