From b946741c5cf5ceda253673fe8700a9ba242185fd Mon Sep 17 00:00:00 2001 From: haad Date: Thu, 16 Feb 2023 11:07:13 +0200 Subject: [PATCH] Get the first tests running --- test/.mocharc.json | 2 +- test/counterdb.test.js | 296 +++++----- test/create-open.test.js | 760 ++++++++++++------------ test/create-type.test.js | 112 ++-- test/custom-cache.test.js | 96 ++-- test/custom-keystore.test.js | 128 ++--- test/docstore.test.js | 346 +++++------ test/drop.test.js | 100 ++-- test/eventlog.test.js | 616 ++++++++++---------- test/feed-load.test.js | 140 ++--- test/feed.test.js | 824 +++++++++++++-------------- test/keyvalue.spec.js | 2 +- test/kvstore.test.js | 242 ++++---- test/multiple-databases.test.js | 298 +++++----- test/offline-mode.js | 144 ++--- test/orbit-db-address.test.js | 182 +++--- test/persistency.js | 518 ++++++++--------- test/re-exports.test.js | 36 +- test/replicate-and-load.test.js | 268 ++++----- test/replicate-automatically.test.js | 212 +++---- test/replicate.test.js | 698 +++++++++++------------ test/replication-status.test.js | 144 ++--- test/set-identity.test.js | 174 +++--- test/v0-open-load.js | 332 +++++------ test/write-permissions.test.js | 364 ++++++------ 25 files changed, 3517 insertions(+), 3517 deletions(-) diff --git a/test/.mocharc.json b/test/.mocharc.json index f865e34..aa416fd 100644 --- a/test/.mocharc.json +++ b/test/.mocharc.json @@ -4,5 +4,5 @@ "recursive": true, "exit": true, "slow": 1000, - "exclude": ["test/browser/**/*.js"] + "exclude": ["test/browser/**/*.js", "test/access-controllers/**/*.js"] } \ No newline at end of file diff --git a/test/counterdb.test.js b/test/counterdb.test.js index cace5a4..3591dc6 100644 --- a/test/counterdb.test.js +++ b/test/counterdb.test.js @@ -1,176 +1,176 @@ -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' +// 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' +// 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) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Counters (${API})`, function () { +// this.timeout(config.timeout) - let orbitdb1, orbitdb2 - let ipfsd1, ipfsd2, ipfs1, ipfs2 +// 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 }) - }) +// 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() +// after(async () => { +// if (orbitdb1) +// await orbitdb1.stop() - if (orbitdb2) - await orbitdb2.stop() +// if (orbitdb2) +// await orbitdb2.stop() - if (ipfsd1) - await stopIpfs(ipfsd1) +// if (ipfsd1) +// await stopIpfs(ipfsd1) - if (ipfsd2) - await stopIpfs(ipfsd2) - }) +// if (ipfsd2) +// await stopIpfs(ipfsd2) +// }) - beforeEach(async () => { - orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: './orbitdb/1' }) - orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: './orbitdb/2' }) - }) +// 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() +// afterEach(async () => { +// if (orbitdb1) +// await orbitdb1.stop() - if (orbitdb2) - await orbitdb2.stop() - }) +// if (orbitdb2) +// await orbitdb2.stop() +// }) - describe('counters', function() { - let address +// 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('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('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('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('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") +// it('syncs counters', async () => { +// console.log("Sync counters") - let options = { - accessController: { - // Set write access for both clients - write: [ - orbitdb1.identity.id, - orbitdb2.identity.id - ] - } - } +// let options = { +// accessController: { +// // Set write access for both clients +// write: [ +// orbitdb1.identity.id, +// orbitdb2.identity.id +// ] +// } +// } - const dbName = new Date().getTime().toString() +// const dbName = new Date().getTime().toString() - const numbers = [[13, 10], [2, 5]] - const increaseCounter = (counterDB, i) => mapSeries(numbers[i], n => counterDB.inc(n)) +// 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) +// // 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) +// // 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()) +// // 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()) +// // 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 +// 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) - }) +// 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") +// // 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) - }) - }) - }) - }) -}) +// 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) +// }) +// }) +// }) +// }) +// }) diff --git a/test/create-open.test.js b/test/create-open.test.js index 88c85cf..09f0888 100644 --- a/test/create-open.test.js +++ b/test/create-open.test.js @@ -1,444 +1,444 @@ -import assert from 'assert' -import mapSeries from 'p-map-series' -import fs from 'fs-extra' -import path from 'path' -import rmrf from 'rimraf' -import Zip from 'adm-zip' -import OrbitDB from '../src/OrbitDB.js' -import OrbitDBAddress from '../src/orbit-db-address.js' -import Identities from 'orbit-db-identity-provider' -import * as io from 'orbit-db-io' +// import assert from 'assert' +// import mapSeries from 'p-map-series' +// import fs from 'fs-extra' +// import path from 'path' +// import rmrf from 'rimraf' +// import Zip from 'adm-zip' +// import OrbitDB from '../src/OrbitDB.js' +// import OrbitDBAddress from '../src/orbit-db-address.js' +// import Identities from 'orbit-db-identity-provider' +// import * as io from 'orbit-db-io' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath = path.join('./orbitdb', 'tests', 'create-open') -const migrationFixturePath = path.join('./test', 'fixtures', 'migration', 'cache-schema-test') -const ipfsFixturesDir = path.join('./test', 'fixtures', 'ipfs') +// const dbPath = path.join('./orbitdb', 'tests', 'create-open') +// const migrationFixturePath = path.join('./test', 'fixtures', 'migration', 'cache-schema-test') +// const ipfsFixturesDir = path.join('./test', 'fixtures', 'ipfs') -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Create & Open (${API})`, function () { - let ipfsFixtures = path.join('./test', 'fixtures', `js-ipfs.zip`) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Create & Open (${API})`, function () { +// let ipfsFixtures = path.join('./test', 'fixtures', `js-ipfs.zip`) - this.retries(1) // windows... - this.timeout(config.timeout) +// this.retries(1) // windows... +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb, address - let localDataPath +// let ipfsd, ipfs, orbitdb, address +// let localDataPath - const filterFunc = (src, dest) => { - // windows has problems copying these files... - return !(src.includes('LOG') || src.includes('LOCK')) - } +// const filterFunc = (src, dest) => { +// // windows has problems copying these files... +// return !(src.includes('LOG') || src.includes('LOCK')) +// } - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - const zip = new Zip(ipfsFixtures) - await zip.extractAllToAsync(path.join('./test', 'fixtures'), true) - await fs.copy(path.join(ipfsFixturesDir, 'blocks'), path.join(ipfsd.path, 'blocks')) - await fs.copy(path.join(ipfsFixturesDir, 'datastore'), path.join(ipfsd.path, 'datastore'), { filter: filterFunc }) - orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// const zip = new Zip(ipfsFixtures) +// await zip.extractAllToAsync(path.join('./test', 'fixtures'), true) +// await fs.copy(path.join(ipfsFixturesDir, 'blocks'), path.join(ipfsd.path, 'blocks')) +// await fs.copy(path.join(ipfsFixturesDir, 'datastore'), path.join(ipfsd.path, 'datastore'), { filter: filterFunc }) +// orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) +// }) - after(async () => { - if (orbitdb) - await orbitdb.stop() +// after(async () => { +// if (orbitdb) +// await orbitdb.stop() - if (ipfsd) - await stopIpfs(ipfsd) +// if (ipfsd) +// await stopIpfs(ipfsd) - rmrf.sync(ipfsFixturesDir) - }) +// rmrf.sync(ipfsFixturesDir) +// }) - describe('Create', function () { - describe('Errors', function () { - it('throws an error if given an invalid database type', async () => { - let err - try { - const db = await orbitdb.create('first', 'invalid-type') - } catch (e) { - err = e.toString() - } - assert.equal(err, 'Error: Invalid database type \'invalid-type\'') - }) +// describe('Create', function () { +// describe('Errors', function () { +// it('throws an error if given an invalid database type', async () => { +// let err +// try { +// const db = await orbitdb.create('first', 'invalid-type') +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, 'Error: Invalid database type \'invalid-type\'') +// }) - it('throws an error if given an address instead of name', async () => { - let err - try { - const db = await orbitdb.create('/orbitdb/Qmc9PMho3LwTXSaUXJ8WjeBZyXesAwUofdkGeadFXsqMzW/first', 'feed') - } catch (e) { - err = e.toString() - } - assert.equal(err, 'Error: Given database name is an address. Please give only the name of the database!') - }) +// it('throws an error if given an address instead of name', async () => { +// let err +// try { +// const db = await orbitdb.create('/orbitdb/Qmc9PMho3LwTXSaUXJ8WjeBZyXesAwUofdkGeadFXsqMzW/first', 'feed') +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, 'Error: Given database name is an address. Please give only the name of the database!') +// }) - it('throws an error if database already exists', async () => { - let err, db - try { - db = await orbitdb.create('first', 'feed', { replicate: false }) - const db2 = await orbitdb.create('first', 'feed', { replicate: false }) - } catch (e) { - err = e.toString() - } - assert.equal(err, `Error: Database '${db.address}' already exists!`) - await db.close() - }) +// it('throws an error if database already exists', async () => { +// let err, db +// try { +// db = await orbitdb.create('first', 'feed', { replicate: false }) +// const db2 = await orbitdb.create('first', 'feed', { replicate: false }) +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, `Error: Database '${db.address}' already exists!`) +// await db.close() +// }) - it('throws an error if database type doesn\'t match', async () => { - let err, log, kv - try { - log = await orbitdb.kvstore('keyvalue', { replicate: false }) - kv = await orbitdb.eventlog(log.address.toString()) - } catch (e) { - err = e.toString() - } - assert.equal(err, `Error: Database '${log.address}' is type 'keyvalue' but was opened as 'eventlog'`) - }) - }) +// it('throws an error if database type doesn\'t match', async () => { +// let err, log, kv +// try { +// log = await orbitdb.kvstore('keyvalue', { replicate: false }) +// kv = await orbitdb.eventlog(log.address.toString()) +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, `Error: Database '${log.address}' is type 'keyvalue' but was opened as 'eventlog'`) +// }) +// }) - describe('Success', function () { - let db +// describe('Success', function () { +// let db - before(async () => { - db = await orbitdb.create('second', 'feed', { replicate: false }) - localDataPath = path.join(dbPath, orbitdb.id, 'cache') - await db.close() - }) +// before(async () => { +// db = await orbitdb.create('second', 'feed', { replicate: false }) +// localDataPath = path.join(dbPath, orbitdb.id, 'cache') +// await db.close() +// }) - it('creates a feed database', async () => { - assert.notEqual(db, null) - }) +// it('creates a feed database', async () => { +// assert.notEqual(db, null) +// }) - it('database has the correct address', async () => { - assert.equal(db.address.toString().indexOf('/orbitdb'), 0) - assert.equal(db.address.toString().indexOf('zd'), 9) - assert.equal(db.address.toString().indexOf('second'), 59) - }) +// it('database has the correct address', async () => { +// assert.equal(db.address.toString().indexOf('/orbitdb'), 0) +// assert.equal(db.address.toString().indexOf('zd'), 9) +// assert.equal(db.address.toString().indexOf('second'), 59) +// }) - it('saves the database locally', async () => { - assert.equal(fs.existsSync(localDataPath), true) - }) +// it('saves the database locally', async () => { +// assert.equal(fs.existsSync(localDataPath), true) +// }) - it('saves database manifest reference locally', async () => { - const address = db.id - const manifestHash = address.split('/')[2] - await db._cache._store.open() - const value = await db._cache.get(path.join(address, '/_manifest')) - assert.equal(value, manifestHash) - }) +// it('saves database manifest reference locally', async () => { +// const address = db.id +// const manifestHash = address.split('/')[2] +// await db._cache._store.open() +// const value = await db._cache.get(path.join(address, '/_manifest')) +// assert.equal(value, manifestHash) +// }) - it('saves database manifest file locally', async () => { - const manifestHash = db.id.split('/')[2] - const manifest = await io.read(ipfs, manifestHash) - assert.notEqual(manifest, false) - assert.equal(manifest.name, 'second') - assert.equal(manifest.type, 'feed') - assert.notEqual(manifest.accessController, null) - assert.equal(manifest.accessController.indexOf('/ipfs'), 0) - }) +// it('saves database manifest file locally', async () => { +// const manifestHash = db.id.split('/')[2] +// const manifest = await io.read(ipfs, manifestHash) +// assert.notEqual(manifest, false) +// assert.equal(manifest.name, 'second') +// assert.equal(manifest.type, 'feed') +// assert.notEqual(manifest.accessController, null) +// assert.equal(manifest.accessController.indexOf('/ipfs'), 0) +// }) - it('can pass local database directory as an option', async () => { - const dir = './orbitdb/tests/another-feed' - const db2 = await orbitdb.create('third', 'feed', { directory: dir }) - assert.equal(fs.existsSync(dir), true) - await db2.close() - }) +// it('can pass local database directory as an option', async () => { +// const dir = './orbitdb/tests/another-feed' +// const db2 = await orbitdb.create('third', 'feed', { directory: dir }) +// assert.equal(fs.existsSync(dir), true) +// await db2.close() +// }) - it('loads cache from previous version of orbit-db', async () => { - const dbName = 'cache-schema-test' +// it('loads cache from previous version of orbit-db', async () => { +// const dbName = 'cache-schema-test' - db = await orbitdb.create(dbName, 'keyvalue', { overwrite: true }) - const manifestHash = db.address.root - const migrationDataPath = path.join(dbPath, manifestHash, dbName) +// db = await orbitdb.create(dbName, 'keyvalue', { overwrite: true }) +// const manifestHash = db.address.root +// const migrationDataPath = path.join(dbPath, manifestHash, dbName) - await db.load() - assert.equal((await db.get('key')), undefined) - await db.drop() +// await db.load() +// assert.equal((await db.get('key')), undefined) +// await db.drop() - await fs.copy(migrationFixturePath, migrationDataPath, { filter: filterFunc }) - db = await orbitdb.create(dbName, 'keyvalue', { directory: migrationDataPath, overwrite: true }) - await db.load() +// await fs.copy(migrationFixturePath, migrationDataPath, { filter: filterFunc }) +// db = await orbitdb.create(dbName, 'keyvalue', { directory: migrationDataPath, overwrite: true }) +// await db.load() - assert.equal(manifestHash, db.address.root) - assert.equal((await db.get('key')), 'value') - }) +// assert.equal(manifestHash, db.address.root) +// assert.equal((await db.get('key')), 'value') +// }) - it('loads cache from previous version of orbit-db with the directory option', async () => { - const dbName = 'cache-schema-test' - const directory = path.join(dbPath, "some-other-place") +// it('loads cache from previous version of orbit-db with the directory option', async () => { +// const dbName = 'cache-schema-test' +// const directory = path.join(dbPath, "some-other-place") - await fs.copy(migrationFixturePath, directory, { filter: filterFunc }) - db = await orbitdb.create(dbName, 'keyvalue', { directory }) - await db.load() +// await fs.copy(migrationFixturePath, directory, { filter: filterFunc }) +// db = await orbitdb.create(dbName, 'keyvalue', { directory }) +// await db.load() - assert.equal((await db.get('key')), 'value') - }) +// assert.equal((await db.get('key')), 'value') +// }) - describe('Access Controller', function () { - before(async () => { - if (db) { - await db.drop() - } - }) +// describe('Access Controller', function () { +// before(async () => { +// if (db) { +// await db.drop() +// } +// }) - afterEach(async () => { - if (db) { - await db.drop() - } - }) +// afterEach(async () => { +// if (db) { +// await db.drop() +// } +// }) - it('creates an access controller and adds ourselves as writer by default', async () => { - db = await orbitdb.create('fourth', 'feed') - assert.deepEqual(db.access.write, [orbitdb.identity.id]) - }) +// it('creates an access controller and adds ourselves as writer by default', async () => { +// db = await orbitdb.create('fourth', 'feed') +// assert.deepEqual(db.access.write, [orbitdb.identity.id]) +// }) - it('creates an access controller and adds writers', async () => { - db = await orbitdb.create('fourth', 'feed', { - accessController: { - write: ['another-key', 'yet-another-key', orbitdb.identity.id] - } - }) - assert.deepEqual(db.access.write, ['another-key', 'yet-another-key', orbitdb.identity.id]) - }) +// it('creates an access controller and adds writers', async () => { +// db = await orbitdb.create('fourth', 'feed', { +// accessController: { +// write: ['another-key', 'yet-another-key', orbitdb.identity.id] +// } +// }) +// assert.deepEqual(db.access.write, ['another-key', 'yet-another-key', orbitdb.identity.id]) +// }) - it('creates an access controller and doesn\'t add read access keys', async () => { - db = await orbitdb.create('seventh', 'feed', { read: ['one', 'two'] }) - assert.deepEqual(db.access.write, [orbitdb.identity.id]) - }) - }) - describe('Meta', function () { - before(async () => { - if (db) { - await db.close() - await db.drop() - } - }) +// it('creates an access controller and doesn\'t add read access keys', async () => { +// db = await orbitdb.create('seventh', 'feed', { read: ['one', 'two'] }) +// assert.deepEqual(db.access.write, [orbitdb.identity.id]) +// }) +// }) +// describe('Meta', function () { +// before(async () => { +// if (db) { +// await db.close() +// await db.drop() +// } +// }) - afterEach(async () => { - if (db) { - await db.close() - await db.drop() - } - }) +// afterEach(async () => { +// if (db) { +// await db.close() +// await db.drop() +// } +// }) - it('creates a manifest with no meta field', async () => { - db = await orbitdb.create('no-meta', 'feed') - const manifest = await io.read(ipfs, db.address.root) - assert.strictEqual(manifest.meta, undefined) - assert.deepStrictEqual(Object.keys(manifest).filter(k => k === 'meta'), []) - }) +// it('creates a manifest with no meta field', async () => { +// db = await orbitdb.create('no-meta', 'feed') +// const manifest = await io.read(ipfs, db.address.root) +// assert.strictEqual(manifest.meta, undefined) +// assert.deepStrictEqual(Object.keys(manifest).filter(k => k === 'meta'), []) +// }) - it('creates a manifest with a meta field', async () => { - const meta = { test: 123 } - db = await orbitdb.create('meta', 'feed', { meta }) - const manifest = await io.read(ipfs, db.address.root) - assert.deepStrictEqual(manifest.meta, meta) - assert.deepStrictEqual(Object.keys(manifest).filter(k => k === 'meta'), ['meta']) - }) - }) - }) - }) +// it('creates a manifest with a meta field', async () => { +// const meta = { test: 123 } +// db = await orbitdb.create('meta', 'feed', { meta }) +// const manifest = await io.read(ipfs, db.address.root) +// assert.deepStrictEqual(manifest.meta, meta) +// assert.deepStrictEqual(Object.keys(manifest).filter(k => k === 'meta'), ['meta']) +// }) +// }) +// }) +// }) - describe('determineAddress', function () { - describe('Errors', function () { - it('throws an error if given an invalid database type', async () => { - let err - try { - await orbitdb.determineAddress('first', 'invalid-type') - } catch (e) { - err = e.toString() - } - assert.equal(err, 'Error: Invalid database type \'invalid-type\'') - }) +// describe('determineAddress', function () { +// describe('Errors', function () { +// it('throws an error if given an invalid database type', async () => { +// let err +// try { +// await orbitdb.determineAddress('first', 'invalid-type') +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, 'Error: Invalid database type \'invalid-type\'') +// }) - it('throws an error if given an address instead of name', async () => { - let err - try { - await orbitdb.determineAddress('/orbitdb/Qmc9PMho3LwTXSaUXJ8WjeBZyXesAwUofdkGeadFXsqMzW/first', 'feed') - } catch (e) { - err = e.toString() - } - assert.equal(err, 'Error: Given database name is an address. Please give only the name of the database!') - }) - }) +// it('throws an error if given an address instead of name', async () => { +// let err +// try { +// await orbitdb.determineAddress('/orbitdb/Qmc9PMho3LwTXSaUXJ8WjeBZyXesAwUofdkGeadFXsqMzW/first', 'feed') +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, 'Error: Given database name is an address. Please give only the name of the database!') +// }) +// }) - describe('Success', function () { - before(async () => { - address = await orbitdb.determineAddress('third', 'feed', { replicate: false }) - localDataPath = path.join(dbPath, address.root, address.path) - }) +// describe('Success', function () { +// before(async () => { +// address = await orbitdb.determineAddress('third', 'feed', { replicate: false }) +// localDataPath = path.join(dbPath, address.root, address.path) +// }) - it('does not save the address locally', async () => { - assert.equal(fs.existsSync(localDataPath), false) - }) +// it('does not save the address locally', async () => { +// assert.equal(fs.existsSync(localDataPath), false) +// }) - it('returns the address that would have been created', async () => { - const db = await orbitdb.create('third', 'feed', { replicate: false }) - assert.equal(address.toString().indexOf('/orbitdb'), 0) - assert.equal(address.toString().indexOf('zd'), 9) - assert.equal(address.toString(), db.address.toString()) - await db.close() - }) - }) - }) +// it('returns the address that would have been created', async () => { +// const db = await orbitdb.create('third', 'feed', { replicate: false }) +// assert.equal(address.toString().indexOf('/orbitdb'), 0) +// assert.equal(address.toString().indexOf('zd'), 9) +// assert.equal(address.toString(), db.address.toString()) +// await db.close() +// }) +// }) +// }) - describe('Open', function () { - it('throws an error if trying to open a database with name only and \'create\' is not set to \'true\'', async () => { - let err - try { - db = await orbitdb.open('XXX', { create: false }) - } catch (e) { - err = e.toString() - } - assert.equal(err, "Error: 'options.create' set to 'false'. If you want to create a database, set 'options.create' to 'true'.") - }) +// describe('Open', function () { +// it('throws an error if trying to open a database with name only and \'create\' is not set to \'true\'', async () => { +// let err +// try { +// db = await orbitdb.open('XXX', { create: false }) +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, "Error: 'options.create' set to 'false'. If you want to create a database, set 'options.create' to 'true'.") +// }) - it('throws an error if trying to open a database with name only and \'create\' is not set to true', async () => { - let err - try { - db = await orbitdb.open('YYY', { create: true }) - } catch (e) { - err = e.toString() - } - assert.equal(err, `Error: Database type not provided! Provide a type with 'options.type' (${OrbitDB.databaseTypes.join('|')})`) - }) +// it('throws an error if trying to open a database with name only and \'create\' is not set to true', async () => { +// let err +// try { +// db = await orbitdb.open('YYY', { create: true }) +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, `Error: Database type not provided! Provide a type with 'options.type' (${OrbitDB.databaseTypes.join('|')})`) +// }) - it('opens a database - name only', async () => { - const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true }) - assert.equal(db.address.toString().indexOf('/orbitdb'), 0) - assert.equal(db.address.toString().indexOf('zd'), 9) - assert.equal(db.address.toString().indexOf('abc'), 59) - await db.drop() - }) +// it('opens a database - name only', async () => { +// const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true }) +// assert.equal(db.address.toString().indexOf('/orbitdb'), 0) +// assert.equal(db.address.toString().indexOf('zd'), 9) +// assert.equal(db.address.toString().indexOf('abc'), 59) +// await db.drop() +// }) - it('opens a database - with a different identity', async () => { - const identity = await Identities.createIdentity({ id: 'test-id', keystore: orbitdb.keystore }) - const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true, identity }) - assert.equal(db.address.toString().indexOf('/orbitdb'), 0) - assert.equal(db.address.toString().indexOf('zd'), 9) - assert.equal(db.address.toString().indexOf('abc'), 59) - assert.equal(db.identity, identity) - await db.drop() - }) +// it('opens a database - with a different identity', async () => { +// const identity = await Identities.createIdentity({ id: 'test-id', keystore: orbitdb.keystore }) +// const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true, identity }) +// assert.equal(db.address.toString().indexOf('/orbitdb'), 0) +// assert.equal(db.address.toString().indexOf('zd'), 9) +// assert.equal(db.address.toString().indexOf('abc'), 59) +// assert.equal(db.identity, identity) +// await db.drop() +// }) - it('opens the same database - from an address', async () => { - const identity = await Identities.createIdentity({ id: 'test-id', keystore: orbitdb.keystore }) - const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true, identity }) - const db2 = await orbitdb.open(db.address) - assert.equal(db2.address.toString().indexOf('/orbitdb'), 0) - assert.equal(db2.address.toString().indexOf('zd'), 9) - assert.equal(db2.address.toString().indexOf('abc'), 59) - await db.drop() - await db2.drop() - }) +// it('opens the same database - from an address', async () => { +// const identity = await Identities.createIdentity({ id: 'test-id', keystore: orbitdb.keystore }) +// const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true, identity }) +// const db2 = await orbitdb.open(db.address) +// assert.equal(db2.address.toString().indexOf('/orbitdb'), 0) +// assert.equal(db2.address.toString().indexOf('zd'), 9) +// assert.equal(db2.address.toString().indexOf('abc'), 59) +// await db.drop() +// await db2.drop() +// }) - it('opens a database and adds the creator as the only writer', async () => { - const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true }) - assert.equal(db.access.write.length, 1) - assert.equal(db.access.write[0], db.identity.id) - await db.drop() - }) +// it('opens a database and adds the creator as the only writer', async () => { +// const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true }) +// assert.equal(db.access.write.length, 1) +// assert.equal(db.access.write[0], db.identity.id) +// await db.drop() +// }) - it('doesn\'t open a database if we don\'t have it locally', async () => { - const db = await orbitdb.open('abcabc', { create: true, type: 'feed', overwrite: true }) - const address = new OrbitDBAddress(db.address.root.slice(0, -1) + 'A', 'non-existent') - await db.drop() - return new Promise((resolve, reject) => { - setTimeout(resolve, 900) - orbitdb.open(address) - .then(() => reject(new Error('Shouldn\'t open the database'))) - .catch(reject) - }) - }) +// it('doesn\'t open a database if we don\'t have it locally', async () => { +// const db = await orbitdb.open('abcabc', { create: true, type: 'feed', overwrite: true }) +// const address = new OrbitDBAddress(db.address.root.slice(0, -1) + 'A', 'non-existent') +// await db.drop() +// return new Promise((resolve, reject) => { +// setTimeout(resolve, 900) +// orbitdb.open(address) +// .then(() => reject(new Error('Shouldn\'t open the database'))) +// .catch(reject) +// }) +// }) - it('throws an error if trying to open a database locally and we don\'t have it', async () => { - const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true }) - const address = new OrbitDBAddress(db.address.root.slice(0, -1) + 'A', 'second') - await db.drop() - return orbitdb.open(address, { localOnly: true }) - .then(() => new Error('Shouldn\'t open the database')) - .catch(e => { - assert.equal(e.toString(), `Error: Database '${address}' doesn't exist!`) - }) - }) +// it('throws an error if trying to open a database locally and we don\'t have it', async () => { +// const db = await orbitdb.open('abc', { create: true, type: 'feed', overwrite: true }) +// const address = new OrbitDBAddress(db.address.root.slice(0, -1) + 'A', 'second') +// await db.drop() +// return orbitdb.open(address, { localOnly: true }) +// .then(() => new Error('Shouldn\'t open the database')) +// .catch(e => { +// assert.equal(e.toString(), `Error: Database '${address}' doesn't exist!`) +// }) +// }) - it('open the database and it has the added entries', async () => { - const db = await orbitdb.open('ZZZ', { create: true, type: 'feed' }) - await db.add('hello1') - await db.add('hello2') - await db.close() +// it('open the database and it has the added entries', async () => { +// const db = await orbitdb.open('ZZZ', { create: true, type: 'feed' }) +// await db.add('hello1') +// await db.add('hello2') +// await db.close() - const db2 = await orbitdb.open(db.address) +// const db2 = await orbitdb.open(db.address) - await db.load() - const res = db.iterator({ limit: -1 }).collect() +// await db.load() +// const res = db.iterator({ limit: -1 }).collect() - assert.equal(res.length, 2) - assert.equal(res[0].payload.value, 'hello1') - assert.equal(res[1].payload.value, 'hello2') - await db.drop() - await db2.drop() - }) - }) +// assert.equal(res.length, 2) +// assert.equal(res[0].payload.value, 'hello1') +// assert.equal(res[1].payload.value, 'hello2') +// await db.drop() +// await db2.drop() +// }) +// }) - describe("Close", function () { - before(async () => { - if (orbitdb) await orbitdb.stop() - orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) - }) - it('closes a custom store', async () => { - const directory = path.join(dbPath, "custom-store") - const db = await orbitdb.open('xyz', { create: true, type: 'feed', directory }) - await db.close() - assert.strictEqual(db._cache.status, 'closed') - }) +// describe("Close", function () { +// before(async () => { +// if (orbitdb) await orbitdb.stop() +// orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) +// }) +// it('closes a custom store', async () => { +// const directory = path.join(dbPath, "custom-store") +// const db = await orbitdb.open('xyz', { create: true, type: 'feed', directory }) +// await db.close() +// assert.strictEqual(db._cache.status, 'closed') +// }) - it("close load close sets status to 'closed'", async () => { - const directory = path.join(dbPath, "custom-store") - const db = await orbitdb.open('xyz', { create: true, type: 'feed', directory }) - await db.close() - await db.load() - await db.close() - assert.strictEqual(db._cache.status, 'closed') - }) +// it("close load close sets status to 'closed'", async () => { +// const directory = path.join(dbPath, "custom-store") +// const db = await orbitdb.open('xyz', { create: true, type: 'feed', directory }) +// await db.close() +// await db.load() +// await db.close() +// assert.strictEqual(db._cache.status, 'closed') +// }) - it('successfully manages multiple caches', async () => { - // Cleaning up cruft from other tests - const directory = path.join(dbPath, "custom-store") - const directory2 = path.join(dbPath, "custom-store2") +// it('successfully manages multiple caches', async () => { +// // Cleaning up cruft from other tests +// const directory = path.join(dbPath, "custom-store") +// const directory2 = path.join(dbPath, "custom-store2") - const db1 = await orbitdb.open('xyz1', { create: true, type: 'feed', }) - const db2 = await orbitdb.open('xyz2', { create: true, type: 'feed', directory }) - const db3 = await orbitdb.open('xyz3', { create: true, type: 'feed', directory }) - const db4 = await orbitdb.open('xyz4', { create: true, type: 'feed', directory: directory2 }) - const db5 = await orbitdb.open('xyz5', { create: true, type: 'feed', }) +// const db1 = await orbitdb.open('xyz1', { create: true, type: 'feed', }) +// const db2 = await orbitdb.open('xyz2', { create: true, type: 'feed', directory }) +// const db3 = await orbitdb.open('xyz3', { create: true, type: 'feed', directory }) +// const db4 = await orbitdb.open('xyz4', { create: true, type: 'feed', directory: directory2 }) +// const db5 = await orbitdb.open('xyz5', { create: true, type: 'feed', }) - await db1.close() - await db2.close() - await db4.close() +// await db1.close() +// await db2.close() +// await db4.close() - assert.strictEqual(orbitdb.cache._store.status, 'open') - assert.strictEqual(db2._cache.status, 'open') - assert.strictEqual(db3._cache.status, 'open') - assert.strictEqual(db4._cache.status, 'closed') +// assert.strictEqual(orbitdb.cache._store.status, 'open') +// assert.strictEqual(db2._cache.status, 'open') +// assert.strictEqual(db3._cache.status, 'open') +// assert.strictEqual(db4._cache.status, 'closed') - await db3.close() - await db5.close() +// await db3.close() +// await db5.close() - assert.strictEqual(orbitdb.cache._store.status, 'closed') - assert.strictEqual(db2._cache.status, 'closed') - assert.strictEqual(db3._cache.status, 'closed') - assert.strictEqual(db4._cache.status, 'closed') - assert.strictEqual(db5._cache.status, 'closed') - }) - }) - }) -}) +// assert.strictEqual(orbitdb.cache._store.status, 'closed') +// assert.strictEqual(db2._cache.status, 'closed') +// assert.strictEqual(db3._cache.status, 'closed') +// assert.strictEqual(db4._cache.status, 'closed') +// assert.strictEqual(db5._cache.status, 'closed') +// }) +// }) +// }) +// }) diff --git a/test/create-type.test.js b/test/create-type.test.js index b77643c..efb49ab 100644 --- a/test/create-type.test.js +++ b/test/create-type.test.js @@ -1,67 +1,67 @@ -'use strict' +// 'use strict' -import assert from 'assert' -import rmrf from 'rimraf' -import DocumentStore from 'orbit-db-docstore' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import DocumentStore from 'orbit-db-docstore' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath = './orbitdb/tests/create-open' +// const dbPath = './orbitdb/tests/create-open' -class CustomStore extends DocumentStore { - constructor (ipfs, id, dbname, options) { - super(ipfs, id, dbname, options) - this._type = CustomStore.type - } +// class CustomStore extends DocumentStore { +// constructor (ipfs, id, dbname, options) { +// super(ipfs, id, dbname, options) +// this._type = CustomStore.type +// } - static get type () { - return 'custom' - } -} +// static get type () { +// return 'custom' +// } +// } -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Create Custom Database Type (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Create Custom Database Type (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb +// let ipfsd, ipfs, orbitdb - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) +// }) - after(async () => { - if (orbitdb) await orbitdb.stop() - if (ipfsd) await stopIpfs(ipfsd) - // Remove the added custom database type from OrbitDB - // between js-ipfs and js-ipfs-api tests - delete OrbitDB.getDatabaseTypes()[CustomStore.type] - }) +// after(async () => { +// if (orbitdb) await orbitdb.stop() +// if (ipfsd) await stopIpfs(ipfsd) +// // Remove the added custom database type from OrbitDB +// // between js-ipfs and js-ipfs-api tests +// delete OrbitDB.getDatabaseTypes()[CustomStore.type] +// }) - describe('addDatabaseType', function () { - it('should have the correct custom type', async () => { - OrbitDB.addDatabaseType(CustomStore.type, CustomStore) - let store = await orbitdb.create(dbPath.replace(/^\.\//, ''), CustomStore.type) - assert.equal(store._type, CustomStore.type) - }) +// describe('addDatabaseType', function () { +// it('should have the correct custom type', async () => { +// OrbitDB.addDatabaseType(CustomStore.type, CustomStore) +// let store = await orbitdb.create(dbPath.replace(/^\.\//, ''), CustomStore.type) +// assert.equal(store._type, CustomStore.type) +// }) - it('cannot be overwritten', async () => { - try { - OrbitDB.addDatabaseType(CustomStore.type, CustomStore) - throw new Error('This should not run.') - } catch (e) { - assert(e.message.indexOf('already exists') > -1) - } - }) - }) - }) -}) +// it('cannot be overwritten', async () => { +// try { +// OrbitDB.addDatabaseType(CustomStore.type, CustomStore) +// throw new Error('This should not run.') +// } catch (e) { +// assert(e.message.indexOf('already exists') > -1) +// } +// }) +// }) +// }) +// }) diff --git a/test/custom-cache.test.js b/test/custom-cache.test.js index 6f999c7..1be7c76 100644 --- a/test/custom-cache.test.js +++ b/test/custom-cache.test.js @@ -1,59 +1,59 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' -import CustomCache from 'orbit-db-cache' -import localdown from 'localstorage-down' -import storageAdapter from 'orbit-db-storage-adapter' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' +// import CustomCache from 'orbit-db-cache' +// import localdown from 'localstorage-down' +// import storageAdapter from 'orbit-db-storage-adapter' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -import { databases } from './utils/index.js' +// import { databases } from './utils/index.js' -const storage = storageAdapter(localdown) +// const storage = storageAdapter(localdown) -const dbPath = './orbitdb/tests/customKeystore' +// const dbPath = './orbitdb/tests/customKeystore' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Use a Custom Cache (${API})`, function() { - this.timeout(20000) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Use a Custom Cache (${API})`, function() { +// this.timeout(20000) - let ipfsd, ipfs, orbitdb1, store +// let ipfsd, ipfs, orbitdb1, store - before(async () => { - store = await storage.createStore("orbitdb/test/local") - const cache = new CustomCache(store) +// before(async () => { +// store = await storage.createStore("orbitdb/test/local") +// const cache = new CustomCache(store) - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { - directory: path.join(dbPath, '1'), - cache: cache - }) - }) +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { +// directory: path.join(dbPath, '1'), +// cache: cache +// }) +// }) - after(async () => { - await orbitdb1.stop() - await stopIpfs(ipfsd) - }) +// after(async () => { +// await orbitdb1.stop() +// await stopIpfs(ipfsd) +// }) - describe('allows orbit to use a custom cache with different store types', function() { - for (let database of databases) { - it(database.type + ' allows custom cache', async () => { - const db1 = await database.create(orbitdb1, 'custom-keystore') - await database.tryInsert(db1) +// describe('allows orbit to use a custom cache with different store types', function() { +// for (let database of databases) { +// it(database.type + ' allows custom cache', async () => { +// const db1 = await database.create(orbitdb1, 'custom-keystore') +// await database.tryInsert(db1) - assert.deepEqual(database.getTestValue(db1), database.expectedValue) - await db1.close() - }) - } - }) - }) -}) +// assert.deepEqual(database.getTestValue(db1), database.expectedValue) +// await db1.close() +// }) +// } +// }) +// }) +// }) diff --git a/test/custom-keystore.test.js b/test/custom-keystore.test.js index 0ae35b8..5df81aa 100644 --- a/test/custom-keystore.test.js +++ b/test/custom-keystore.test.js @@ -1,78 +1,78 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' -import Identities from 'orbit-db-identity-provider' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' +// import Identities from 'orbit-db-identity-provider' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -import { - CustomTestKeystore, - databases, -} from './utils/index.js' +// import { +// CustomTestKeystore, +// databases, +// } from './utils/index.js' -Identities.addIdentityProvider(CustomTestKeystore().identityProvider) +// Identities.addIdentityProvider(CustomTestKeystore().identityProvider) -const dbPath = './orbitdb/tests/customKeystore' +// const dbPath = './orbitdb/tests/customKeystore' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Use a Custom Keystore (${API})`, function() { - this.timeout(20000) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Use a Custom Keystore (${API})`, function() { +// this.timeout(20000) - let ipfsd, ipfs, orbitdb1 +// let ipfsd, ipfs, orbitdb1 - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - const identity = await Identities.createIdentity({ type: 'custom', keystore: CustomTestKeystore().create() }) - orbitdb1 = await OrbitDB.createInstance(ipfs, { - directory: path.join(dbPath, '1'), - identity - }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// const identity = await Identities.createIdentity({ type: 'custom', keystore: CustomTestKeystore().create() }) +// orbitdb1 = await OrbitDB.createInstance(ipfs, { +// directory: path.join(dbPath, '1'), +// identity +// }) +// }) - after(async () => { - await orbitdb1.stop() - await stopIpfs(ipfsd) - }) +// after(async () => { +// await orbitdb1.stop() +// await stopIpfs(ipfsd) +// }) - describe('allows orbit to use a custom keystore with different store types', function() { - databases.forEach(async (database) => { - it(database.type + ' allows custom keystore', async () => { - const db1 = await database.create(orbitdb1, 'custom-keystore') - await database.tryInsert(db1) +// describe('allows orbit to use a custom keystore with different store types', function() { +// databases.forEach(async (database) => { +// it(database.type + ' allows custom keystore', async () => { +// const db1 = await database.create(orbitdb1, 'custom-keystore') +// await database.tryInsert(db1) - assert.deepEqual(database.getTestValue(db1), database.expectedValue) +// assert.deepEqual(database.getTestValue(db1), database.expectedValue) - await db1.close() - }) - }) - }) +// await db1.close() +// }) +// }) +// }) - describe('allows a custom keystore to be used with different store and write permissions', function() { - databases.forEach(async (database) => { - it(database.type + ' allows custom keystore', async () => { - const options = { - accessController: { - // Set write access for both clients - write: [orbitdb1.identity.id] - } - } +// describe('allows a custom keystore to be used with different store and write permissions', function() { +// databases.forEach(async (database) => { +// it(database.type + ' allows custom keystore', async () => { +// const options = { +// accessController: { +// // Set write access for both clients +// write: [orbitdb1.identity.id] +// } +// } - const db1 = await database.create(orbitdb1, 'custom-keystore', options) - await database.tryInsert(db1) +// const db1 = await database.create(orbitdb1, 'custom-keystore', options) +// await database.tryInsert(db1) - assert.deepEqual(database.getTestValue(db1), database.expectedValue) +// assert.deepEqual(database.getTestValue(db1), database.expectedValue) - await db1.close() - }) - }) - }) - }) -}) +// await db1.close() +// }) +// }) +// }) +// }) +// }) diff --git a/test/docstore.test.js b/test/docstore.test.js index ef41521..d565991 100644 --- a/test/docstore.test.js +++ b/test/docstore.test.js @@ -1,201 +1,201 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath = './orbitdb/tests/docstore' +// const dbPath = './orbitdb/tests/docstore' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Document Store (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Document Store (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb1, db +// let ipfsd, ipfs, orbitdb1, db - before(async () => { - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) - }) +// before(async () => { +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - it('creates and opens a database', async () => { - db = await orbitdb1.docstore('first doc database') - assert.notEqual(db, null) - assert.equal(db.type, 'docstore') - assert.equal(db.dbname, 'first doc database') - }) +// it('creates and opens a database', async () => { +// db = await orbitdb1.docstore('first doc database') +// assert.notEqual(db, null) +// assert.equal(db.type, 'docstore') +// assert.equal(db.dbname, 'first doc database') +// }) - describe('Default index \'_id\'', function() { - beforeEach(async () => { - const options = { - replicate: false, - maxHistory: 0, - path: dbPath, - } - db = await orbitdb1.docstore('orbit-db-tests', options) - }) +// describe('Default index \'_id\'', function() { +// beforeEach(async () => { +// const options = { +// replicate: false, +// maxHistory: 0, +// path: dbPath, +// } +// db = await orbitdb1.docstore('orbit-db-tests', options) +// }) - afterEach(async () => { - await db.drop() - }) +// afterEach(async () => { +// await db.drop() +// }) - it('put', async () => { - const doc = { _id: 'hello world', doc: 'all the things'} - await db.put(doc) - const value = db.get('hello world') - assert.deepEqual(value, [doc]) - }) +// it('put', async () => { +// const doc = { _id: 'hello world', doc: 'all the things'} +// await db.put(doc) +// const value = db.get('hello world') +// assert.deepEqual(value, [doc]) +// }) - it('get - partial term match', async () => { - const doc1 = { _id: 'hello world', doc: 'some things'} - const doc2 = { _id: 'hello universe', doc: 'all the things'} - const doc3 = { _id: 'sup world', doc: 'other things'} - await db.put(doc1) - await db.put(doc2) - await db.put(doc3) - const value = db.get('hello') - assert.deepEqual(value, [doc1, doc2]) - }) +// it('get - partial term match', async () => { +// const doc1 = { _id: 'hello world', doc: 'some things'} +// const doc2 = { _id: 'hello universe', doc: 'all the things'} +// const doc3 = { _id: 'sup world', doc: 'other things'} +// await db.put(doc1) +// await db.put(doc2) +// await db.put(doc3) +// const value = db.get('hello') +// assert.deepEqual(value, [doc1, doc2]) +// }) - it('get after delete', async () => { - const doc1 = { _id: 'hello world', doc: 'some things'} - const doc2 = { _id: 'hello universe', doc: 'all the things'} - const doc3 = { _id: 'sup world', doc: 'other things'} - await db.put(doc1) - await db.put(doc2) - await db.put(doc3) - await db.del('hello universe') - const value1 = db.get('hello') - const value2 = db.get('sup') - assert.deepEqual(value1, [doc1]) - assert.deepEqual(value2, [doc3]) - }) +// it('get after delete', async () => { +// const doc1 = { _id: 'hello world', doc: 'some things'} +// const doc2 = { _id: 'hello universe', doc: 'all the things'} +// const doc3 = { _id: 'sup world', doc: 'other things'} +// await db.put(doc1) +// await db.put(doc2) +// await db.put(doc3) +// await db.del('hello universe') +// const value1 = db.get('hello') +// const value2 = db.get('sup') +// assert.deepEqual(value1, [doc1]) +// assert.deepEqual(value2, [doc3]) +// }) - it('put updates a value', async () => { - const doc1 = { _id: 'hello world', doc: 'all the things'} - const doc2 = { _id: 'hello world', doc: 'some of the things'} - await db.put(doc1) - await db.put(doc2) - const value = db.get('hello') - assert.deepEqual(value, [doc2]) - }) +// it('put updates a value', async () => { +// const doc1 = { _id: 'hello world', doc: 'all the things'} +// const doc2 = { _id: 'hello world', doc: 'some of the things'} +// await db.put(doc1) +// await db.put(doc2) +// const value = db.get('hello') +// assert.deepEqual(value, [doc2]) +// }) - it('query', async () => { - const doc1 = { _id: 'hello world', doc: 'all the things', views: 17} - const doc2 = { _id: 'sup world', doc: 'some of the things', views: 10} - const doc3 = { _id: 'hello other world', doc: 'none of the things', views: 5} - const doc4 = { _id: 'hey universe', doc: ''} +// it('query', async () => { +// const doc1 = { _id: 'hello world', doc: 'all the things', views: 17} +// const doc2 = { _id: 'sup world', doc: 'some of the things', views: 10} +// const doc3 = { _id: 'hello other world', doc: 'none of the things', views: 5} +// const doc4 = { _id: 'hey universe', doc: ''} - await db.put(doc1) - await db.put(doc2) - await db.put(doc3) - await db.put(doc4) +// await db.put(doc1) +// await db.put(doc2) +// await db.put(doc3) +// await db.put(doc4) - const value1 = db.query((e) => e.views > 5) - const value2 = db.query((e) => e.views > 10) - const value3 = db.query((e) => e.views > 17) +// const value1 = db.query((e) => e.views > 5) +// const value2 = db.query((e) => e.views > 10) +// const value3 = db.query((e) => e.views > 17) - assert.deepEqual(value1, [doc1, doc2]) - assert.deepEqual(value2, [doc1]) - assert.deepEqual(value3, []) - }) +// assert.deepEqual(value1, [doc1, doc2]) +// assert.deepEqual(value2, [doc1]) +// assert.deepEqual(value3, []) +// }) - it('query after delete', async () => { - const doc1 = { _id: 'hello world', doc: 'all the things', views: 17} - const doc2 = { _id: 'sup world', doc: 'some of the things', views: 10} - const doc3 = { _id: 'hello other world', doc: 'none of the things', views: 5} - const doc4 = { _id: 'hey universe', doc: ''} +// it('query after delete', async () => { +// const doc1 = { _id: 'hello world', doc: 'all the things', views: 17} +// const doc2 = { _id: 'sup world', doc: 'some of the things', views: 10} +// const doc3 = { _id: 'hello other world', doc: 'none of the things', views: 5} +// const doc4 = { _id: 'hey universe', doc: ''} - await db.put(doc1) - await db.put(doc2) - await db.put(doc3) - await db.del('hello world') - await db.put(doc4) - const value1 = db.query((e) => e.views >= 5) - const value2 = db.query((e) => e.views >= 10) - assert.deepEqual(value1, [doc2, doc3]) - assert.deepEqual(value2, [doc2]) - }) +// await db.put(doc1) +// await db.put(doc2) +// await db.put(doc3) +// await db.del('hello world') +// await db.put(doc4) +// const value1 = db.query((e) => e.views >= 5) +// const value2 = db.query((e) => e.views >= 10) +// assert.deepEqual(value1, [doc2, doc3]) +// assert.deepEqual(value2, [doc2]) +// }) - it('query returns full op', async () => { - const doc1 = { _id: 'hello world', doc: 'all the things', views: 17} - const doc2 = { _id: 'sup world', doc: 'some of the things', views: 10} +// it('query returns full op', async () => { +// const doc1 = { _id: 'hello world', doc: 'all the things', views: 17} +// const doc2 = { _id: 'sup world', doc: 'some of the things', views: 10} - const expectedOperation = { - op: 'PUT', - key: 'sup world', - value: { - _id: 'sup world', - doc: 'some of the things', - views: 10 - }, - } +// const expectedOperation = { +// op: 'PUT', +// key: 'sup world', +// value: { +// _id: 'sup world', +// doc: 'some of the things', +// views: 10 +// }, +// } - await db.put(doc1) - await db.put(doc2) +// await db.put(doc1) +// await db.put(doc2) - const res = db.query(e => e.payload.value.views < 17, { fullOp: true })[0] - assert.notEqual(res, undefined) - assert.notEqual(res.hash, undefined) - assert.notEqual(res.id, undefined) - assert.deepEqual(res.payload, expectedOperation) - assert.notEqual(res.next, undefined) - assert.equal(res.next.length, 1) - assert.equal(res.refs.length, 0) - assert.equal(res.v, 2) - assert.notEqual(res.clock, undefined) - assert.equal(res.clock.time, 2) - assert.notEqual(res.key, undefined) - assert.notEqual(res.sig, undefined) - }) - }) +// const res = db.query(e => e.payload.value.views < 17, { fullOp: true })[0] +// assert.notEqual(res, undefined) +// assert.notEqual(res.hash, undefined) +// assert.notEqual(res.id, undefined) +// assert.deepEqual(res.payload, expectedOperation) +// assert.notEqual(res.next, undefined) +// assert.equal(res.next.length, 1) +// assert.equal(res.refs.length, 0) +// assert.equal(res.v, 2) +// assert.notEqual(res.clock, undefined) +// assert.equal(res.clock.time, 2) +// assert.notEqual(res.key, undefined) +// assert.notEqual(res.sig, undefined) +// }) +// }) - describe('Specified index', function() { - beforeEach(async () => { - const options = { - indexBy: 'doc', - replicate: false, - maxHistory: 0 - } - db = await orbitdb1.docstore('orbit-db-tests', options) - }) +// describe('Specified index', function() { +// beforeEach(async () => { +// const options = { +// indexBy: 'doc', +// replicate: false, +// maxHistory: 0 +// } +// db = await orbitdb1.docstore('orbit-db-tests', options) +// }) - afterEach(async () => { - await db.drop() - }) +// afterEach(async () => { +// await db.drop() +// }) - it('put', async () => { - const doc = { _id: 'hello world', doc: 'all the things'} - await db.put(doc) - const value = db.get('all') - assert.deepEqual(value, [doc]) - }) +// it('put', async () => { +// const doc = { _id: 'hello world', doc: 'all the things'} +// await db.put(doc) +// const value = db.get('all') +// assert.deepEqual(value, [doc]) +// }) - it('get - matches specified index', async () => { - const doc1 = { _id: 'hello world', doc: 'all the things'} - const doc2 = { _id: 'hello world', doc: 'some things'} - await db.put(doc1) - await db.put(doc2) - const value1 = db.get('all') - const value2 = db.get('some') - assert.deepEqual(value1, [doc1]) - assert.deepEqual(value2, [doc2]) - }) - }) - }) -}) +// it('get - matches specified index', async () => { +// const doc1 = { _id: 'hello world', doc: 'all the things'} +// const doc2 = { _id: 'hello world', doc: 'some things'} +// await db.put(doc1) +// await db.put(doc2) +// const value1 = db.get('all') +// const value2 = db.get('some') +// assert.deepEqual(value1, [doc1]) +// assert.deepEqual(value2, [doc2]) +// }) +// }) +// }) +// }) diff --git a/test/drop.test.js b/test/drop.test.js index 569975e..58dec96 100644 --- a/test/drop.test.js +++ b/test/drop.test.js @@ -1,60 +1,60 @@ -import assert from 'assert' -import fs from 'fs' -import path from 'path' -import rmrf from 'rimraf' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import fs from 'fs' +// import path from 'path' +// import rmrf from 'rimraf' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath = './orbitdb/tests/drop' +// const dbPath = './orbitdb/tests/drop' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Drop Database (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Drop Database (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb, db, address - let localDataPath +// let ipfsd, ipfs, orbitdb, db, address +// let localDataPath - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) +// }) - after(async () => { - if(orbitdb) - await orbitdb.stop() +// after(async () => { +// if(orbitdb) +// await orbitdb.stop() - if (ipfsd) - await stopIpfs(ipfsd) +// if (ipfsd) +// await stopIpfs(ipfsd) - rmrf.sync(dbPath) - }) +// rmrf.sync(dbPath) +// }) - describe('Drop', function() { - before(async () => { - db = await orbitdb.create('first', 'feed') - localDataPath = path.join(dbPath) - assert.equal(fs.existsSync(localDataPath), true) - }) +// describe('Drop', function() { +// before(async () => { +// db = await orbitdb.create('first', 'feed') +// localDataPath = path.join(dbPath) +// assert.equal(fs.existsSync(localDataPath), true) +// }) - it('removes local database cache', async () => { - await db.drop() - await db._cache.open() - assert.equal(await db._cache.get(db.localHeadsPath), undefined) - assert.equal(await db._cache.get(db.remoteHeadsPath), undefined) - assert.equal(await db._cache.get(db.snapshotPath), undefined) - assert.equal(await db._cache.get(db.queuePath), undefined) - assert.equal(await db._cache.get(db.manifestPath), undefined) - await db._cache.close() - }) - }) - }) -}) +// it('removes local database cache', async () => { +// await db.drop() +// await db._cache.open() +// assert.equal(await db._cache.get(db.localHeadsPath), undefined) +// assert.equal(await db._cache.get(db.remoteHeadsPath), undefined) +// assert.equal(await db._cache.get(db.snapshotPath), undefined) +// assert.equal(await db._cache.get(db.queuePath), undefined) +// assert.equal(await db._cache.get(db.manifestPath), undefined) +// await db._cache.close() +// }) +// }) +// }) +// }) diff --git a/test/eventlog.test.js b/test/eventlog.test.js index f4610c8..42705b0 100644 --- a/test/eventlog.test.js +++ b/test/eventlog.test.js @@ -1,369 +1,369 @@ -import assert from 'assert' -import mapSeries from 'p-map-series' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import mapSeries from 'p-map-series' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const last = arr => arr[arr.length - 1] +// const last = arr => arr[arr.length - 1] -const dbPath = './orbitdb/tests/eventlog' +// const dbPath = './orbitdb/tests/eventlog' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Log Database (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Log Database (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb1 +// let ipfsd, ipfs, orbitdb1 - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - describe('Eventlog', function () { - it('creates and opens a database', async () => { - const db = await orbitdb1.eventlog('log database') - assert.notEqual(db, null) - assert.equal(db.type, 'eventlog') - assert.equal(db.dbname, 'log database') - await db.drop() - }) +// describe('Eventlog', function () { +// it('creates and opens a database', async () => { +// const db = await orbitdb1.eventlog('log database') +// assert.notEqual(db, null) +// assert.equal(db.type, 'eventlog') +// assert.equal(db.dbname, 'log database') +// await db.drop() +// }) - it('returns 0 items when it\'s a fresh database', async () => { - const db = await orbitdb1.eventlog('log database') - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 0) - await db.drop() - }) +// it('returns 0 items when it\'s a fresh database', async () => { +// const db = await orbitdb1.eventlog('log database') +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 0) +// await db.drop() +// }) - it('returns the added entry\'s hash, 1 entry', async () => { - const db = await orbitdb1.eventlog('first database') - const hash = await db.add('hello1') - const items = db.iterator({ limit: -1 }).collect() - assert.notEqual(hash, null) - assert.equal(hash, last(items).hash) - assert.equal(items.length, 1) - await db.drop() - }) +// it('returns the added entry\'s hash, 1 entry', async () => { +// const db = await orbitdb1.eventlog('first database') +// const hash = await db.add('hello1') +// const items = db.iterator({ limit: -1 }).collect() +// assert.notEqual(hash, null) +// assert.equal(hash, last(items).hash) +// assert.equal(items.length, 1) +// await db.drop() +// }) - it('returns the added entry\'s hash, 2 entries', async () => { - const db = await orbitdb1.eventlog('first database') - await db.load() - await db.add('hello1') - const prevHash = db.iterator().collect()[0].hash - const hash = await db.add('hello2') - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 2) - assert.notEqual(hash, null) - assert.notEqual(hash, prevHash) - assert.equal(hash, last(items).hash) - await db.drop() - }) +// it('returns the added entry\'s hash, 2 entries', async () => { +// const db = await orbitdb1.eventlog('first database') +// await db.load() +// await db.add('hello1') +// const prevHash = db.iterator().collect()[0].hash +// const hash = await db.add('hello2') +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 2) +// assert.notEqual(hash, null) +// assert.notEqual(hash, prevHash) +// assert.equal(hash, last(items).hash) +// await db.drop() +// }) - it('adds five items', async () => { - const db = await orbitdb1.eventlog('second database') - await mapSeries([1, 2, 3, 4, 5], (i) => db.add('hello' + i)) - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 5) - assert.equal(items[0].payload.value, 'hello1') - assert.equal(last(items.map((f) => f.payload.value)), 'hello5') - await db.drop() - }) +// it('adds five items', async () => { +// const db = await orbitdb1.eventlog('second database') +// await mapSeries([1, 2, 3, 4, 5], (i) => db.add('hello' + i)) +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 5) +// assert.equal(items[0].payload.value, 'hello1') +// assert.equal(last(items.map((f) => f.payload.value)), 'hello5') +// await db.drop() +// }) - it('adds an item that is > 256 bytes', async () => { - const db = await orbitdb1.eventlog('third database') - let msg = Buffer.alloc(1024) - msg.fill('a') - const hash = await db.add(msg.toString()) - assert.notEqual(hash, null) - assert.equal(hash.startsWith('zd'), true) - assert.equal(hash.length, 49) - await db.drop() - }) - }) +// it('adds an item that is > 256 bytes', async () => { +// const db = await orbitdb1.eventlog('third database') +// let msg = Buffer.alloc(1024) +// msg.fill('a') +// const hash = await db.add(msg.toString()) +// assert.notEqual(hash, null) +// assert.equal(hash.startsWith('zd'), true) +// assert.equal(hash.length, 49) +// await db.drop() +// }) +// }) - describe('Iterator', function() { - let hashes = [] - const itemCount = 5 - let db +// describe('Iterator', function() { +// let hashes = [] +// const itemCount = 5 +// let db - before(async () => { - hashes = [] - db = await orbitdb1.eventlog('iterator tests') - hashes = await mapSeries([0, 1, 2, 3, 4], (i) => db.add('hello' + i)) - }) +// before(async () => { +// hashes = [] +// db = await orbitdb1.eventlog('iterator tests') +// hashes = await mapSeries([0, 1, 2, 3, 4], (i) => db.add('hello' + i)) +// }) - describe('Defaults', function() { - it('returns an iterator', () => { - const iter = db.iterator() - const next = iter.next().value - assert.notEqual(iter, null) - assert.notEqual(next, null) - }) +// describe('Defaults', function() { +// it('returns an iterator', () => { +// const iter = db.iterator() +// const next = iter.next().value +// assert.notEqual(iter, null) +// assert.notEqual(next, null) +// }) - it('returns an item with the correct structure', () => { - const iter = db.iterator() - const next = iter.next().value - assert.notEqual(next, null) - assert.equal(next.hash.startsWith('zd'), true) - assert.equal(next.payload.key, null) - assert.equal(next.payload.value, 'hello4') - }) +// it('returns an item with the correct structure', () => { +// const iter = db.iterator() +// const next = iter.next().value +// assert.notEqual(next, null) +// assert.equal(next.hash.startsWith('zd'), true) +// assert.equal(next.payload.key, null) +// assert.equal(next.payload.value, 'hello4') +// }) - it('implements Iterator interface', () => { - const iter = db.iterator({ limit: -1 }) - let messages = [] +// it('implements Iterator interface', () => { +// const iter = db.iterator({ limit: -1 }) +// let messages = [] - for(let i of iter) - messages.push(i.key) +// for(let i of iter) +// messages.push(i.key) - assert.equal(messages.length, hashes.length) - }) +// assert.equal(messages.length, hashes.length) +// }) - it('returns 1 item as default', () => { - const iter = db.iterator() - const first = iter.next().value - const second = iter.next().value - assert.equal(first.hash, hashes[hashes.length - 1]) - assert.equal(second, null) - assert.equal(first.payload.value, 'hello4') - }) +// it('returns 1 item as default', () => { +// const iter = db.iterator() +// const first = iter.next().value +// const second = iter.next().value +// assert.equal(first.hash, hashes[hashes.length - 1]) +// assert.equal(second, null) +// assert.equal(first.payload.value, 'hello4') +// }) - it('returns items in the correct order', () => { - const amount = 3 - const iter = db.iterator({ limit: amount }) - let i = hashes.length - amount - for(let item of iter) { - assert.equal(item.payload.value, 'hello' + i) - i ++ - } - }) - }) +// it('returns items in the correct order', () => { +// const amount = 3 +// const iter = db.iterator({ limit: amount }) +// let i = hashes.length - amount +// for(let item of iter) { +// assert.equal(item.payload.value, 'hello' + i) +// i ++ +// } +// }) +// }) - describe('Collect', function() { - it('returns all items', () => { - const messages = db.iterator({ limit: -1 }).collect() - assert.equal(messages.length, hashes.length) - assert.equal(messages[0].payload.value, 'hello0') - assert.equal(messages[messages.length - 1].payload.value, 'hello4') - }) +// describe('Collect', function() { +// it('returns all items', () => { +// const messages = db.iterator({ limit: -1 }).collect() +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0].payload.value, 'hello0') +// assert.equal(messages[messages.length - 1].payload.value, 'hello4') +// }) - it('returns 1 item', () => { - const messages = db.iterator().collect() - assert.equal(messages.length, 1) - }) +// it('returns 1 item', () => { +// const messages = db.iterator().collect() +// assert.equal(messages.length, 1) +// }) - it('returns 3 items', () => { - const messages = db.iterator({ limit: 3 }).collect() - assert.equal(messages.length, 3) - }) - }) +// it('returns 3 items', () => { +// const messages = db.iterator({ limit: 3 }).collect() +// assert.equal(messages.length, 3) +// }) +// }) - describe('Options: limit', function() { - it('returns 1 item when limit is 0', () => { - const iter = db.iterator({ limit: 0 }) - const first = iter.next().value - const second = iter.next().value - assert.equal(first.hash, last(hashes)) - assert.equal(second, null) - }) +// describe('Options: limit', function() { +// it('returns 1 item when limit is 0', () => { +// const iter = db.iterator({ limit: 0 }) +// const first = iter.next().value +// const second = iter.next().value +// assert.equal(first.hash, last(hashes)) +// assert.equal(second, null) +// }) - it('returns 1 item when limit is 1', () => { - const iter = db.iterator({ limit: 1 }) - const first = iter.next().value - const second = iter.next().value - assert.equal(first.hash, last(hashes)) - assert.equal(second, null) - }) +// it('returns 1 item when limit is 1', () => { +// const iter = db.iterator({ limit: 1 }) +// const first = iter.next().value +// const second = iter.next().value +// assert.equal(first.hash, last(hashes)) +// assert.equal(second, null) +// }) - it('returns 3 items', () => { - const iter = db.iterator({ limit: 3 }) - const first = iter.next().value - const second = iter.next().value - const third = iter.next().value - const fourth = iter.next().value - assert.equal(first.hash, hashes[hashes.length - 3]) - assert.equal(second.hash, hashes[hashes.length - 2]) - assert.equal(third.hash, hashes[hashes.length - 1]) - assert.equal(fourth, null) - }) +// it('returns 3 items', () => { +// const iter = db.iterator({ limit: 3 }) +// const first = iter.next().value +// const second = iter.next().value +// const third = iter.next().value +// const fourth = iter.next().value +// assert.equal(first.hash, hashes[hashes.length - 3]) +// assert.equal(second.hash, hashes[hashes.length - 2]) +// assert.equal(third.hash, hashes[hashes.length - 1]) +// assert.equal(fourth, null) +// }) - it('returns all items', () => { - const messages = db.iterator({ limit: -1 }) - .collect() - .map((e) => e.hash) +// it('returns all items', () => { +// const messages = db.iterator({ limit: -1 }) +// .collect() +// .map((e) => e.hash) - messages.reverse() - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[hashes.length - 1]) - }) +// messages.reverse() +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[hashes.length - 1]) +// }) - it('returns all items when limit is bigger than -1', () => { - const messages = db.iterator({ limit: -300 }) - .collect() - .map((e) => e.hash) +// it('returns all items when limit is bigger than -1', () => { +// const messages = db.iterator({ limit: -300 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[0]) - }) +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[0]) +// }) - it('returns all items when limit is bigger than number of items', () => { - const messages = db.iterator({ limit: 300 }) - .collect() - .map((e) => e.hash) +// it('returns all items when limit is bigger than number of items', () => { +// const messages = db.iterator({ limit: 300 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[0]) - }) - }) +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[0]) +// }) +// }) - describe('Option: ranges', function() { - describe('gt & gte', function() { - it('returns 1 item when gte is the head', () => { - const messages = db.iterator({ gte: last(hashes), limit: -1 }) - .collect() - .map((e) => e.hash) +// describe('Option: ranges', function() { +// describe('gt & gte', function() { +// it('returns 1 item when gte is the head', () => { +// const messages = db.iterator({ gte: last(hashes), limit: -1 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, 1) - assert.equal(messages[0], last(hashes)) - }) +// assert.equal(messages.length, 1) +// assert.equal(messages[0], last(hashes)) +// }) - it('returns 0 items when gt is the head', () => { - const messages = db.iterator({ gt: last(hashes) }).collect() - assert.equal(messages.length, 0) - }) +// it('returns 0 items when gt is the head', () => { +// const messages = db.iterator({ gt: last(hashes) }).collect() +// assert.equal(messages.length, 0) +// }) - it('returns 2 item when gte is defined', () => { - const gte = hashes[hashes.length - 2] - const messages = db.iterator({ gte: gte, limit: -1 }) - .collect() - .map((e) => e.hash) +// it('returns 2 item when gte is defined', () => { +// const gte = hashes[hashes.length - 2] +// const messages = db.iterator({ gte: gte, limit: -1 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, 2) - assert.equal(messages[0], hashes[hashes.length - 2]) - assert.equal(messages[1], hashes[hashes.length - 1]) - }) +// assert.equal(messages.length, 2) +// assert.equal(messages[0], hashes[hashes.length - 2]) +// assert.equal(messages[1], hashes[hashes.length - 1]) +// }) - it('returns all items when gte is the root item', () => { - const messages = db.iterator({ gte: hashes[0], limit: -1 }) - .collect() - .map((e) => e.hash) +// it('returns all items when gte is the root item', () => { +// const messages = db.iterator({ gte: hashes[0], limit: -1 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[0]) - assert.equal(messages[messages.length - 1], last(hashes)) - }) +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[0]) +// assert.equal(messages[messages.length - 1], last(hashes)) +// }) - it('returns items when gt is the root item', () => { - const messages = db.iterator({ gt: hashes[0], limit: -1 }) - .collect() - .map((e) => e.hash) +// it('returns items when gt is the root item', () => { +// const messages = db.iterator({ gt: hashes[0], limit: -1 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, itemCount - 1) - assert.equal(messages[0], hashes[1]) - assert.equal(messages[3], last(hashes)) - }) +// assert.equal(messages.length, itemCount - 1) +// assert.equal(messages[0], hashes[1]) +// assert.equal(messages[3], last(hashes)) +// }) - it('returns items when gt is defined', () => { - const messages = db.iterator({ limit: -1}) - .collect() - .map((e) => e.hash) +// it('returns items when gt is defined', () => { +// const messages = db.iterator({ limit: -1}) +// .collect() +// .map((e) => e.hash) - const gt = messages[2] +// const gt = messages[2] - const messages2 = db.iterator({ gt: gt, limit: 100 }) - .collect() - .map((e) => e.hash) +// const messages2 = db.iterator({ gt: gt, limit: 100 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages2.length, 2) - assert.equal(messages2[0], messages[messages.length - 2]) - assert.equal(messages2[1], messages[messages.length - 1]) - }) - }) +// assert.equal(messages2.length, 2) +// assert.equal(messages2[0], messages[messages.length - 2]) +// assert.equal(messages2[1], messages[messages.length - 1]) +// }) +// }) - describe('lt & lte', function() { - it('returns one item after head when lt is the head', () => { - const messages = db.iterator({ lt: last(hashes) }) - .collect() - .map((e) => e.hash) +// describe('lt & lte', function() { +// it('returns one item after head when lt is the head', () => { +// const messages = db.iterator({ lt: last(hashes) }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, 1) - assert.equal(messages[0], hashes[hashes.length - 2]) - }) +// assert.equal(messages.length, 1) +// assert.equal(messages[0], hashes[hashes.length - 2]) +// }) - it('returns all items when lt is head and limit is -1', () => { - const messages = db.iterator({ lt: last(hashes), limit: -1 }) - .collect() - .map((e) => e.hash) +// it('returns all items when lt is head and limit is -1', () => { +// const messages = db.iterator({ lt: last(hashes), limit: -1 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, hashes.length - 1) - assert.equal(messages[0], hashes[0]) - assert.equal(messages[messages.length - 1], hashes[hashes.length - 2]) - }) +// assert.equal(messages.length, hashes.length - 1) +// assert.equal(messages[0], hashes[0]) +// assert.equal(messages[messages.length - 1], hashes[hashes.length - 2]) +// }) - it('returns 3 items when lt is head and limit is 3', () => { - const messages = db.iterator({ lt: last(hashes), limit: 3 }) - .collect() - .map((e) => e.hash) +// it('returns 3 items when lt is head and limit is 3', () => { +// const messages = db.iterator({ lt: last(hashes), limit: 3 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, 3) - assert.equal(messages[0], hashes[hashes.length - 4]) - assert.equal(messages[2], hashes[hashes.length - 2]) - }) +// assert.equal(messages.length, 3) +// assert.equal(messages[0], hashes[hashes.length - 4]) +// assert.equal(messages[2], hashes[hashes.length - 2]) +// }) - it('returns null when lt is the root item', () => { - const messages = db.iterator({ lt: hashes[0] }).collect() - assert.equal(messages.length, 0) - }) +// it('returns null when lt is the root item', () => { +// const messages = db.iterator({ lt: hashes[0] }).collect() +// assert.equal(messages.length, 0) +// }) - it('returns one item when lte is the root item', () => { - const messages = db.iterator({ lte: hashes[0] }) - .collect() - .map((e) => e.hash) +// it('returns one item when lte is the root item', () => { +// const messages = db.iterator({ lte: hashes[0] }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, 1) - assert.equal(messages[0], hashes[0]) - }) +// assert.equal(messages.length, 1) +// assert.equal(messages[0], hashes[0]) +// }) - it('returns all items when lte is the head', () => { - const messages = db.iterator({ lte: last(hashes), limit: -1 }) - .collect() - .map((e) => e.hash) +// it('returns all items when lte is the head', () => { +// const messages = db.iterator({ lte: last(hashes), limit: -1 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, itemCount) - assert.equal(messages[0], hashes[0]) - assert.equal(messages[4], last(hashes)) - }) +// assert.equal(messages.length, itemCount) +// assert.equal(messages[0], hashes[0]) +// assert.equal(messages[4], last(hashes)) +// }) - it('returns 3 items when lte is the head', () => { - const messages = db.iterator({ lte: last(hashes), limit: 3 }) - .collect() - .map((e) => e.hash) +// it('returns 3 items when lte is the head', () => { +// const messages = db.iterator({ lte: last(hashes), limit: 3 }) +// .collect() +// .map((e) => e.hash) - assert.equal(messages.length, 3) - assert.equal(messages[0], hashes[hashes.length - 3]) - assert.equal(messages[1], hashes[hashes.length - 2]) - assert.equal(messages[2], last(hashes)) - }) - }) - }) - }) - }) -}) +// assert.equal(messages.length, 3) +// assert.equal(messages[0], hashes[hashes.length - 3]) +// assert.equal(messages[1], hashes[hashes.length - 2]) +// assert.equal(messages[2], last(hashes)) +// }) +// }) +// }) +// }) +// }) +// }) diff --git a/test/feed-load.test.js b/test/feed-load.test.js index b88c415..6c14afc 100644 --- a/test/feed-load.test.js +++ b/test/feed-load.test.js @@ -1,102 +1,102 @@ -import assert from 'assert' -import OrbitDB from '../src/OrbitDB.js' -import rmrf from 'rimraf' -import path from 'path' +// import assert from 'assert' +// import OrbitDB from '../src/OrbitDB.js' +// import rmrf from 'rimraf' +// import path from 'path' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const last = arr => arr[arr.length - 1] +// const last = arr => arr[arr.length - 1] -const dbPath = './orbitdb/tests/feed-load' +// const dbPath = './orbitdb/tests/feed-load' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Feed Load Amount (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Feed Load Amount (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb1, db, address +// let ipfsd, ipfs, orbitdb1, db, address - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - describe('Feed Load Amount', function() { +// describe('Feed Load Amount', function() { - it('add 10 items and verify they are in the index', async () => { - db = await orbitdb1.feed('feed database') +// it('add 10 items and verify they are in the index', async () => { +// db = await orbitdb1.feed('feed database') - //All tests should retrieve these 10 items. - for (var i=0; i < 10; i++) { - await db.add({content: (i + 10).toString()}) - } +// //All tests should retrieve these 10 items. +// for (var i=0; i < 10; i++) { +// await db.add({content: (i + 10).toString()}) +// } - assert.equal(Object.keys(db.index).length, 10) - }) +// assert.equal(Object.keys(db.index).length, 10) +// }) - it('reopen store and load 10 items', async () => { +// it('reopen store and load 10 items', async () => { - address = db.address.toString() - await db.close() - db = await orbitdb1.open(address) +// address = db.address.toString() +// await db.close() +// db = await orbitdb1.open(address) - //Load 10 items - await db.load(10) +// //Load 10 items +// await db.load(10) - assert.equal(Object.keys(db.index).length, 10) +// assert.equal(Object.keys(db.index).length, 10) - }) +// }) - it('reopen store and load 1 item more than exists', async () => { - await db.close() - db = await orbitdb1.open(address) +// it('reopen store and load 1 item more than exists', async () => { +// await db.close() +// db = await orbitdb1.open(address) - //Load 11 items - await db.load(11) +// //Load 11 items +// await db.load(11) - assert.equal(Object.keys(db.index).length, 10) +// assert.equal(Object.keys(db.index).length, 10) - }) +// }) - it('reopen store and load 5 item more than exists', async () => { +// it('reopen store and load 5 item more than exists', async () => { - await db.close() - db = await orbitdb1.open(address) +// await db.close() +// db = await orbitdb1.open(address) - //Load 15 items - await db.load(15) +// //Load 15 items +// await db.load(15) - assert.equal(Object.keys(db.index).length, 10) - }) +// assert.equal(Object.keys(db.index).length, 10) +// }) - it('reopen store and load 20 items more than exists', async () => { +// it('reopen store and load 20 items more than exists', async () => { - await db.close() - db = await orbitdb1.open(address) +// await db.close() +// db = await orbitdb1.open(address) - //Load 30 items - await db.load(30) +// //Load 30 items +// await db.load(30) - assert.equal(Object.keys(db.index).length, 10) - }) +// assert.equal(Object.keys(db.index).length, 10) +// }) - }) +// }) - }) -}) +// }) +// }) diff --git a/test/feed.test.js b/test/feed.test.js index a7c9e78..e353034 100644 --- a/test/feed.test.js +++ b/test/feed.test.js @@ -1,412 +1,412 @@ -import assert from 'assert' -import mapSeries from 'p-map-series' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' - -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' - -const last = arr => arr[arr.length - 1] - -const dbPath = './orbitdb/tests/feed' - -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Feed Database (${API})`, function() { - this.timeout(config.timeout) - - let ipfsd, ipfs, orbitdb1, address - - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) - }) - - after(async () => { - if(orbitdb1) - await orbitdb1.stop() - - if (ipfsd) - await stopIpfs(ipfsd) - }) - - describe('Feed', function() { - it('creates and opens a database', async () => { - const db = await orbitdb1.feed('feed database') - assert.notEqual(db, null) - assert.equal(db.type, 'feed') - assert.equal(db.dbname, 'feed database') - await db.drop() - }) - - it('returns 0 items when it\'s a fresh database', async () => { - const db = await orbitdb1.feed('feed database') - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 0) - await db.drop() - }) - - it('returns the added entry\'s hash, 1 entry', async () => { - const db = await orbitdb1.feed('first') - address = db.address.toString() - const hash = await db.add('hello1') - const items = db.iterator({ limit: -1 }).collect() - assert.notEqual(hash, null) - assert.equal(hash, last(items).hash) - assert.equal(items.length, 1) - await db.drop() - }) - - it('returns the added entry\'s hash, 2 entries', async () => { - const db = await orbitdb1.feed(address) - await db.load() - await db.add('hello1') - const prevHash = db.iterator().collect()[0].hash - const hash = await db.add('hello2') - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 2) - assert.notEqual(hash, null) - assert.notEqual(hash, prevHash) - assert.equal(hash, last(items).hash) - await db.drop() - }) - - it('adds five items', async () => { - const db = await orbitdb1.feed('second') - await mapSeries([1, 2, 3, 4, 5], (i) => db.add('hello' + i)) - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 5) - assert.equal(items[0].payload.value, 'hello1') - assert.equal(items[items.length - 1].payload.value, 'hello5') - await db.drop() - }) - - it('adds an item that is > 256 bytes', async () => { - const db = await orbitdb1.feed('third') - let msg = Buffer.alloc(1024) - msg.fill('a') - const hash = await db.add(msg.toString()) - assert.notEqual(hash, null) - assert.equal(hash.startsWith('zd'), true) - assert.equal(hash.length, 49) - await db.drop() - }) - - it('deletes an item when only one item in the database', async () => { - const db = await orbitdb1.feed('fourth') - const hash = await db.add('hello3') - const delopHash = await db.remove(hash) - const items = db.iterator().collect() - assert.equal(delopHash.startsWith('zd'), true) - assert.equal(items.length, 0) - await db.drop() - }) - - it('deletes an item when two items in the database', async () => { - const db = await orbitdb1.feed('fifth') - await db.add('hello1') - const hash = await db.add('hello2') - await db.remove(hash) - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 1) - assert.equal(items[0].payload.value, 'hello1') - await db.drop() - }) - - it('deletes an item between adds', async () => { - const db = await orbitdb1.feed('sixth') - - const hash = await db.add('hello1') - await db.add('hello2') - await db.remove(hash) - await db.add('hello3') - - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 2) - - const firstItem = items[0] - const secondItem = items[1] - assert.equal(firstItem.hash.startsWith('zd'), true) - assert.equal(firstItem.payload.key, null) - assert.equal(firstItem.payload.value, 'hello2') - assert.equal(secondItem.payload.value, 'hello3') - await db.drop() - }) - }) - - describe('Iterator', function() { - let db - - let hashes = [] - const itemCount = 5 - - before(async () => { - hashes = [] - db = await orbitdb1.feed('feed-iterator') - hashes = await mapSeries([0, 1, 2, 3, 4], (i) => db.add('hello' + i)) - }) - - describe('Defaults', function() { - it('returns an iterator', () => { - const iter = db.iterator() - const next = iter.next().value - assert.notEqual(iter, null) - assert.notEqual(next, null) - }) - - it('returns an item with the correct structure', () => { - const iter = db.iterator() - const next = iter.next().value - assert.notEqual(next, null) - assert.equal(next.hash.startsWith('zd'), true) - assert.equal(next.payload.key, null) - assert.equal(next.payload.value, 'hello4') - }) - - it('implements Iterator interface', () => { - const iter = db.iterator({ limit: -1 }) - let messages = [] - - for(let i of iter) - messages.push(i.key) - - assert.equal(messages.length, hashes.length) - }) - - it('returns 1 item as default', () => { - const iter = db.iterator() - const first = iter.next().value - const second = iter.next().value - assert.equal(first.hash, hashes[hashes.length - 1]) - assert.equal(second, null) - assert.equal(first.payload.value, 'hello4') - }) - - it('returns items in the correct order', () => { - const amount = 3 - const iter = db.iterator({ limit: amount }) - let i = hashes.length - amount - for(let item of iter) { - assert.equal(item.payload.value, 'hello' + i) - i ++ - } - }) - }) - - describe('Collect', function() { - it('returns all items', () => { - const messages = db.iterator({ limit: -1 }).collect() - assert.equal(messages.length, hashes.length) - assert.equal(messages[0].payload.value, 'hello0') - assert.equal(messages[messages.length - 1].payload.value, 'hello4') - }) - - it('returns 1 item', () => { - const messages = db.iterator().collect() - assert.equal(messages.length, 1) - }) - - it('returns 3 items', () => { - const messages = db.iterator({ limit: 3 }).collect() - assert.equal(messages.length, 3) - }) - }) - - describe('Options: limit', function() { - it('returns 1 item when limit is 0', () => { - const iter = db.iterator({ limit: 0 }) - const first = iter.next().value - const second = iter.next().value - assert.equal(first.hash, last(hashes)) - assert.equal(second, null) - }) - - it('returns 1 item when limit is 1', () => { - const iter = db.iterator({ limit: 1 }) - const first = iter.next().value - const second = iter.next().value - assert.equal(first.hash, last(hashes)) - assert.equal(second, null) - }) - - it('returns 3 items', () => { - const iter = db.iterator({ limit: 3 }) - const first = iter.next().value - const second = iter.next().value - const third = iter.next().value - const fourth = iter.next().value - assert.equal(first.hash, hashes[hashes.length - 3]) - assert.equal(second.hash, hashes[hashes.length - 2]) - assert.equal(third.hash, hashes[hashes.length - 1]) - assert.equal(fourth, null) - }) - - it('returns all items', () => { - const messages = db.iterator({ limit: -1 }) - .collect() - .map((e) => e.hash) - - messages.reverse() - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[hashes.length - 1]) - }) - - it('returns all items when limit is bigger than -1', () => { - const messages = db.iterator({ limit: -300 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[0]) - }) - - it('returns all items when limit is bigger than number of items', () => { - const messages = db.iterator({ limit: 300 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[0]) - }) - }) - - describe('Option: ranges', function() { - describe('gt & gte', function() { - it('returns 1 item when gte is the head', () => { - const messages = db.iterator({ gte: last(hashes), limit: -1 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, 1) - assert.equal(messages[0], last(hashes)) - }) - - it('returns 0 items when gt is the head', () => { - const messages = db.iterator({ gt: last(hashes) }).collect() - assert.equal(messages.length, 0) - }) - - it('returns 2 item when gte is defined', () => { - const gte = hashes[hashes.length - 2] - const messages = db.iterator({ gte: gte, limit: -1 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, 2) - assert.equal(messages[0], hashes[hashes.length - 2]) - assert.equal(messages[1], hashes[hashes.length - 1]) - }) - - it('returns all items when gte is the root item', () => { - const messages = db.iterator({ gte: hashes[0], limit: -1 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, hashes.length) - assert.equal(messages[0], hashes[0]) - assert.equal(messages[messages.length - 1], last(hashes)) - }) - - it('returns items when gt is the root item', () => { - const messages = db.iterator({ gt: hashes[0], limit: -1 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, itemCount - 1) - assert.equal(messages[0], hashes[1]) - assert.equal(messages[3], last(hashes)) - }) - - it('returns items when gt is defined', () => { - const messages = db.iterator({ limit: -1}) - .collect() - .map((e) => e.hash) - - const gt = messages[2] - - const messages2 = db.iterator({ gt: gt, limit: 100 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages2.length, 2) - assert.equal(messages2[0], messages[messages.length - 2]) - assert.equal(messages2[1], messages[messages.length - 1]) - }) - }) - - describe('lt & lte', function() { - it('returns one item after head when lt is the head', () => { - const messages = db.iterator({ lt: last(hashes) }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, 1) - assert.equal(messages[0], hashes[hashes.length - 2]) - }) - - it('returns all items when lt is head and limit is -1', () => { - const messages = db.iterator({ lt: last(hashes), limit: -1 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, hashes.length - 1) - assert.equal(messages[0], hashes[0]) - assert.equal(messages[messages.length - 1], hashes[hashes.length - 2]) - }) - - it('returns 3 items when lt is head and limit is 3', () => { - const messages = db.iterator({ lt: last(hashes), limit: 3 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, 3) - assert.equal(messages[0], hashes[hashes.length - 4]) - assert.equal(messages[2], hashes[hashes.length - 2]) - }) - - it('returns null when lt is the root item', () => { - const messages = db.iterator({ lt: hashes[0] }).collect() - assert.equal(messages.length, 0) - }) - - it('returns one item when lte is the root item', () => { - const messages = db.iterator({ lte: hashes[0] }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, 1) - assert.equal(messages[0], hashes[0]) - }) - - it('returns all items when lte is the head', () => { - const messages = db.iterator({ lte: last(hashes), limit: -1 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, itemCount) - assert.equal(messages[0], hashes[0]) - assert.equal(messages[4], last(hashes)) - }) - - it('returns 3 items when lte is the head', () => { - const messages = db.iterator({ lte: last(hashes), limit: 3 }) - .collect() - .map((e) => e.hash) - - assert.equal(messages.length, 3) - assert.equal(messages[0], hashes[hashes.length - 3]) - assert.equal(messages[1], hashes[hashes.length - 2]) - assert.equal(messages[2], last(hashes)) - }) - }) - }) - }) - }) -}) +// import assert from 'assert' +// import mapSeries from 'p-map-series' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' + +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' + +// const last = arr => arr[arr.length - 1] + +// const dbPath = './orbitdb/tests/feed' + +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Feed Database (${API})`, function() { +// this.timeout(config.timeout) + +// let ipfsd, ipfs, orbitdb1, address + +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) +// }) + +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() + +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) + +// describe('Feed', function() { +// it('creates and opens a database', async () => { +// const db = await orbitdb1.feed('feed database') +// assert.notEqual(db, null) +// assert.equal(db.type, 'feed') +// assert.equal(db.dbname, 'feed database') +// await db.drop() +// }) + +// it('returns 0 items when it\'s a fresh database', async () => { +// const db = await orbitdb1.feed('feed database') +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 0) +// await db.drop() +// }) + +// it('returns the added entry\'s hash, 1 entry', async () => { +// const db = await orbitdb1.feed('first') +// address = db.address.toString() +// const hash = await db.add('hello1') +// const items = db.iterator({ limit: -1 }).collect() +// assert.notEqual(hash, null) +// assert.equal(hash, last(items).hash) +// assert.equal(items.length, 1) +// await db.drop() +// }) + +// it('returns the added entry\'s hash, 2 entries', async () => { +// const db = await orbitdb1.feed(address) +// await db.load() +// await db.add('hello1') +// const prevHash = db.iterator().collect()[0].hash +// const hash = await db.add('hello2') +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 2) +// assert.notEqual(hash, null) +// assert.notEqual(hash, prevHash) +// assert.equal(hash, last(items).hash) +// await db.drop() +// }) + +// it('adds five items', async () => { +// const db = await orbitdb1.feed('second') +// await mapSeries([1, 2, 3, 4, 5], (i) => db.add('hello' + i)) +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 5) +// assert.equal(items[0].payload.value, 'hello1') +// assert.equal(items[items.length - 1].payload.value, 'hello5') +// await db.drop() +// }) + +// it('adds an item that is > 256 bytes', async () => { +// const db = await orbitdb1.feed('third') +// let msg = Buffer.alloc(1024) +// msg.fill('a') +// const hash = await db.add(msg.toString()) +// assert.notEqual(hash, null) +// assert.equal(hash.startsWith('zd'), true) +// assert.equal(hash.length, 49) +// await db.drop() +// }) + +// it('deletes an item when only one item in the database', async () => { +// const db = await orbitdb1.feed('fourth') +// const hash = await db.add('hello3') +// const delopHash = await db.remove(hash) +// const items = db.iterator().collect() +// assert.equal(delopHash.startsWith('zd'), true) +// assert.equal(items.length, 0) +// await db.drop() +// }) + +// it('deletes an item when two items in the database', async () => { +// const db = await orbitdb1.feed('fifth') +// await db.add('hello1') +// const hash = await db.add('hello2') +// await db.remove(hash) +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 1) +// assert.equal(items[0].payload.value, 'hello1') +// await db.drop() +// }) + +// it('deletes an item between adds', async () => { +// const db = await orbitdb1.feed('sixth') + +// const hash = await db.add('hello1') +// await db.add('hello2') +// await db.remove(hash) +// await db.add('hello3') + +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 2) + +// const firstItem = items[0] +// const secondItem = items[1] +// assert.equal(firstItem.hash.startsWith('zd'), true) +// assert.equal(firstItem.payload.key, null) +// assert.equal(firstItem.payload.value, 'hello2') +// assert.equal(secondItem.payload.value, 'hello3') +// await db.drop() +// }) +// }) + +// describe('Iterator', function() { +// let db + +// let hashes = [] +// const itemCount = 5 + +// before(async () => { +// hashes = [] +// db = await orbitdb1.feed('feed-iterator') +// hashes = await mapSeries([0, 1, 2, 3, 4], (i) => db.add('hello' + i)) +// }) + +// describe('Defaults', function() { +// it('returns an iterator', () => { +// const iter = db.iterator() +// const next = iter.next().value +// assert.notEqual(iter, null) +// assert.notEqual(next, null) +// }) + +// it('returns an item with the correct structure', () => { +// const iter = db.iterator() +// const next = iter.next().value +// assert.notEqual(next, null) +// assert.equal(next.hash.startsWith('zd'), true) +// assert.equal(next.payload.key, null) +// assert.equal(next.payload.value, 'hello4') +// }) + +// it('implements Iterator interface', () => { +// const iter = db.iterator({ limit: -1 }) +// let messages = [] + +// for(let i of iter) +// messages.push(i.key) + +// assert.equal(messages.length, hashes.length) +// }) + +// it('returns 1 item as default', () => { +// const iter = db.iterator() +// const first = iter.next().value +// const second = iter.next().value +// assert.equal(first.hash, hashes[hashes.length - 1]) +// assert.equal(second, null) +// assert.equal(first.payload.value, 'hello4') +// }) + +// it('returns items in the correct order', () => { +// const amount = 3 +// const iter = db.iterator({ limit: amount }) +// let i = hashes.length - amount +// for(let item of iter) { +// assert.equal(item.payload.value, 'hello' + i) +// i ++ +// } +// }) +// }) + +// describe('Collect', function() { +// it('returns all items', () => { +// const messages = db.iterator({ limit: -1 }).collect() +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0].payload.value, 'hello0') +// assert.equal(messages[messages.length - 1].payload.value, 'hello4') +// }) + +// it('returns 1 item', () => { +// const messages = db.iterator().collect() +// assert.equal(messages.length, 1) +// }) + +// it('returns 3 items', () => { +// const messages = db.iterator({ limit: 3 }).collect() +// assert.equal(messages.length, 3) +// }) +// }) + +// describe('Options: limit', function() { +// it('returns 1 item when limit is 0', () => { +// const iter = db.iterator({ limit: 0 }) +// const first = iter.next().value +// const second = iter.next().value +// assert.equal(first.hash, last(hashes)) +// assert.equal(second, null) +// }) + +// it('returns 1 item when limit is 1', () => { +// const iter = db.iterator({ limit: 1 }) +// const first = iter.next().value +// const second = iter.next().value +// assert.equal(first.hash, last(hashes)) +// assert.equal(second, null) +// }) + +// it('returns 3 items', () => { +// const iter = db.iterator({ limit: 3 }) +// const first = iter.next().value +// const second = iter.next().value +// const third = iter.next().value +// const fourth = iter.next().value +// assert.equal(first.hash, hashes[hashes.length - 3]) +// assert.equal(second.hash, hashes[hashes.length - 2]) +// assert.equal(third.hash, hashes[hashes.length - 1]) +// assert.equal(fourth, null) +// }) + +// it('returns all items', () => { +// const messages = db.iterator({ limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// messages.reverse() +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[hashes.length - 1]) +// }) + +// it('returns all items when limit is bigger than -1', () => { +// const messages = db.iterator({ limit: -300 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[0]) +// }) + +// it('returns all items when limit is bigger than number of items', () => { +// const messages = db.iterator({ limit: 300 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[0]) +// }) +// }) + +// describe('Option: ranges', function() { +// describe('gt & gte', function() { +// it('returns 1 item when gte is the head', () => { +// const messages = db.iterator({ gte: last(hashes), limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, 1) +// assert.equal(messages[0], last(hashes)) +// }) + +// it('returns 0 items when gt is the head', () => { +// const messages = db.iterator({ gt: last(hashes) }).collect() +// assert.equal(messages.length, 0) +// }) + +// it('returns 2 item when gte is defined', () => { +// const gte = hashes[hashes.length - 2] +// const messages = db.iterator({ gte: gte, limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, 2) +// assert.equal(messages[0], hashes[hashes.length - 2]) +// assert.equal(messages[1], hashes[hashes.length - 1]) +// }) + +// it('returns all items when gte is the root item', () => { +// const messages = db.iterator({ gte: hashes[0], limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, hashes.length) +// assert.equal(messages[0], hashes[0]) +// assert.equal(messages[messages.length - 1], last(hashes)) +// }) + +// it('returns items when gt is the root item', () => { +// const messages = db.iterator({ gt: hashes[0], limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, itemCount - 1) +// assert.equal(messages[0], hashes[1]) +// assert.equal(messages[3], last(hashes)) +// }) + +// it('returns items when gt is defined', () => { +// const messages = db.iterator({ limit: -1}) +// .collect() +// .map((e) => e.hash) + +// const gt = messages[2] + +// const messages2 = db.iterator({ gt: gt, limit: 100 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages2.length, 2) +// assert.equal(messages2[0], messages[messages.length - 2]) +// assert.equal(messages2[1], messages[messages.length - 1]) +// }) +// }) + +// describe('lt & lte', function() { +// it('returns one item after head when lt is the head', () => { +// const messages = db.iterator({ lt: last(hashes) }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, 1) +// assert.equal(messages[0], hashes[hashes.length - 2]) +// }) + +// it('returns all items when lt is head and limit is -1', () => { +// const messages = db.iterator({ lt: last(hashes), limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, hashes.length - 1) +// assert.equal(messages[0], hashes[0]) +// assert.equal(messages[messages.length - 1], hashes[hashes.length - 2]) +// }) + +// it('returns 3 items when lt is head and limit is 3', () => { +// const messages = db.iterator({ lt: last(hashes), limit: 3 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, 3) +// assert.equal(messages[0], hashes[hashes.length - 4]) +// assert.equal(messages[2], hashes[hashes.length - 2]) +// }) + +// it('returns null when lt is the root item', () => { +// const messages = db.iterator({ lt: hashes[0] }).collect() +// assert.equal(messages.length, 0) +// }) + +// it('returns one item when lte is the root item', () => { +// const messages = db.iterator({ lte: hashes[0] }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, 1) +// assert.equal(messages[0], hashes[0]) +// }) + +// it('returns all items when lte is the head', () => { +// const messages = db.iterator({ lte: last(hashes), limit: -1 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, itemCount) +// assert.equal(messages[0], hashes[0]) +// assert.equal(messages[4], last(hashes)) +// }) + +// it('returns 3 items when lte is the head', () => { +// const messages = db.iterator({ lte: last(hashes), limit: 3 }) +// .collect() +// .map((e) => e.hash) + +// assert.equal(messages.length, 3) +// assert.equal(messages[0], hashes[hashes.length - 3]) +// assert.equal(messages[1], hashes[hashes.length - 2]) +// assert.equal(messages[2], last(hashes)) +// }) +// }) +// }) +// }) +// }) +// }) diff --git a/test/keyvalue.spec.js b/test/keyvalue.spec.js index fed2ad2..52ac611 100644 --- a/test/keyvalue.spec.js +++ b/test/keyvalue.spec.js @@ -23,7 +23,7 @@ const { createIdentity } = IdentityProvider const OpLog = { Log, Entry, IPFSBlockStorage, LevelStorage } Object.keys(testAPIs).forEach((IPFS) => { - describe('KeyValue Database (' + IPFS + ')', function () { + describe.only('KeyValue Database (' + IPFS + ')', function () { this.timeout(config.timeout) let ipfsd1, ipfsd2 diff --git a/test/kvstore.test.js b/test/kvstore.test.js index 0ae79d1..3b5ea00 100644 --- a/test/kvstore.test.js +++ b/test/kvstore.test.js @@ -1,138 +1,138 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath = './orbitdb/tests/kvstore' +// const dbPath = './orbitdb/tests/kvstore' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Key-Value Database (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Key-Value Database (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb1 +// let ipfsd, ipfs, orbitdb1 - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) +// }) - after(() => { - setTimeout(async () => { - await orbitdb1.stop() - await stopIpfs(ipfsd) - }, 0) - }) +// after(() => { +// setTimeout(async () => { +// await orbitdb1.stop() +// await stopIpfs(ipfsd) +// }, 0) +// }) - it('creates and opens a database', async () => { - const db = await orbitdb1.keyvalue('first kv database') - assert.notEqual(db, null) - assert.equal(db.type, 'keyvalue') - assert.equal(db.dbname, 'first kv database') - await db.drop() - }) +// it('creates and opens a database', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// assert.notEqual(db, null) +// assert.equal(db.type, 'keyvalue') +// assert.equal(db.dbname, 'first kv database') +// await db.drop() +// }) - it('put', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.put('key1', 'hello1') - const value = db.get('key1') - assert.equal(value, 'hello1') - await db.drop() - }) +// it('put', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.put('key1', 'hello1') +// const value = db.get('key1') +// assert.equal(value, 'hello1') +// await db.drop() +// }) - it('get', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.put('key1', 'hello2') - const value = db.get('key1') - assert.equal(value, 'hello2') - await db.drop() - }) +// it('get', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.put('key1', 'hello2') +// const value = db.get('key1') +// assert.equal(value, 'hello2') +// await db.drop() +// }) - it('put updates a value', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.put('key1', 'hello3') - await db.put('key1', 'hello4') - const value = db.get('key1') - assert.equal(value, 'hello4') - await db.drop() - }) +// it('put updates a value', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.put('key1', 'hello3') +// await db.put('key1', 'hello4') +// const value = db.get('key1') +// assert.equal(value, 'hello4') +// await db.drop() +// }) - it('set is an alias for put', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.set('key1', 'hello5') - const value = db.get('key1') - assert.equal(value, 'hello5') - await db.drop() - }) +// it('set is an alias for put', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.set('key1', 'hello5') +// const value = db.get('key1') +// assert.equal(value, 'hello5') +// await db.drop() +// }) - it('put/get - multiple keys', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.put('key1', 'hello1') - await db.put('key2', 'hello2') - await db.put('key3', 'hello3') - const v1 = db.get('key1') - const v2 = db.get('key2') - const v3 = db.get('key3') - assert.equal(v1, 'hello1') - assert.equal(v2, 'hello2') - assert.equal(v3, 'hello3') - await db.drop() - }) +// it('put/get - multiple keys', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.put('key1', 'hello1') +// await db.put('key2', 'hello2') +// await db.put('key3', 'hello3') +// const v1 = db.get('key1') +// const v2 = db.get('key2') +// const v3 = db.get('key3') +// assert.equal(v1, 'hello1') +// assert.equal(v2, 'hello2') +// assert.equal(v3, 'hello3') +// await db.drop() +// }) - it('deletes a key', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.put('key1', 'hello!') - await db.del('key1') - const value = db.get('key1') - assert.equal(value, null) - await db.drop() - }) +// it('deletes a key', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.put('key1', 'hello!') +// await db.del('key1') +// const value = db.get('key1') +// assert.equal(value, null) +// await db.drop() +// }) - it('deletes a key after multiple updates', async () => { - const db = await orbitdb1.keyvalue('first kv database') - await db.put('key1', 'hello1') - await db.put('key1', 'hello2') - await db.put('key1', 'hello3') - await db.del('key1') - const value = db.get('key1') - assert.equal(value, null) - await db.drop() - }) +// it('deletes a key after multiple updates', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// await db.put('key1', 'hello1') +// await db.put('key1', 'hello2') +// await db.put('key1', 'hello3') +// await db.del('key1') +// const value = db.get('key1') +// assert.equal(value, null) +// await db.drop() +// }) - it('get - integer value', async () => { - const db = await orbitdb1.keyvalue('first kv database') - const val = 123 - await db.put('key1', val) - const v1 = db.get('key1') - assert.equal(v1, val) - await db.drop() - }) +// it('get - integer value', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// const val = 123 +// await db.put('key1', val) +// const v1 = db.get('key1') +// assert.equal(v1, val) +// await db.drop() +// }) - it('get - object value', async () => { - const db = await orbitdb1.keyvalue('first kv database') - const val = { one: 'first', two: 2 } - await db.put('key1', val) - const v1 = db.get('key1') - assert.deepEqual(v1, val) - await db.drop() - }) +// it('get - object value', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// const val = { one: 'first', two: 2 } +// await db.put('key1', val) +// const v1 = db.get('key1') +// assert.deepEqual(v1, val) +// await db.drop() +// }) - it('get - array value', async () => { - const db = await orbitdb1.keyvalue('first kv database') - const val = [1, 2, 3, 4, 5] - await db.put('key1', val) - const v1 = db.get('key1') - assert.deepEqual(v1, val) - await db.drop() - }) - }) -}) +// it('get - array value', async () => { +// const db = await orbitdb1.keyvalue('first kv database') +// const val = [1, 2, 3, 4, 5] +// await db.put('key1', val) +// const v1 = db.get('key1') +// assert.deepEqual(v1, val) +// await db.drop() +// }) +// }) +// }) diff --git a/test/multiple-databases.test.js b/test/multiple-databases.test.js index d190e29..96d9368 100644 --- a/test/multiple-databases.test.js +++ b/test/multiple-databases.test.js @@ -1,176 +1,176 @@ -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, - connectPeers, - waitForPeers, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// connectPeers, +// waitForPeers, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath1 = './orbitdb/tests/multiple-databases/1' -const dbPath2 = './orbitdb/tests/multiple-databases/2' +// const dbPath1 = './orbitdb/tests/multiple-databases/1' +// const dbPath2 = './orbitdb/tests/multiple-databases/2' -const databaseInterfaces = [ - { - name: 'logdb', - open: async (orbitdb, address, options) => await orbitdb.log(address, options), - write: async (db, index) => await db.add('hello' + index), - query: (db) => db.iterator({ limit: -1 }).collect().length, - }, - { - name: 'feed', - open: async (orbitdb, address, options) => await orbitdb.feed(address, options), - write: async (db, index) => await db.add('hello' + index), - query: (db) => db.iterator({ limit: -1 }).collect().length, - }, - { - name: 'key-value', - open: async (orbitdb, address, options) => await orbitdb.keyvalue(address, options), - write: async (db, index) => await db.put('hello', index), - query: (db) => db.get('hello'), - }, - { - name: 'counterdb', - open: async (orbitdb, address, options) => await orbitdb.counter(address, options), - write: async (db, index) => await db.inc(1), - query: (db) => db.value, - }, - { - name: 'documents', - open: async (orbitdb, address, options) => await orbitdb.docs(address, options), - write: async (db, index) => await db.put({ _id: 'hello', testing: index }), - query: (db) => { - const docs = db.get('hello') - return docs ? docs[0].testing : 0 - }, - }, -] +// const databaseInterfaces = [ +// { +// name: 'logdb', +// open: async (orbitdb, address, options) => await orbitdb.log(address, options), +// write: async (db, index) => await db.add('hello' + index), +// query: (db) => db.iterator({ limit: -1 }).collect().length, +// }, +// { +// name: 'feed', +// open: async (orbitdb, address, options) => await orbitdb.feed(address, options), +// write: async (db, index) => await db.add('hello' + index), +// query: (db) => db.iterator({ limit: -1 }).collect().length, +// }, +// { +// name: 'key-value', +// open: async (orbitdb, address, options) => await orbitdb.keyvalue(address, options), +// write: async (db, index) => await db.put('hello', index), +// query: (db) => db.get('hello'), +// }, +// { +// name: 'counterdb', +// open: async (orbitdb, address, options) => await orbitdb.counter(address, options), +// write: async (db, index) => await db.inc(1), +// query: (db) => db.value, +// }, +// { +// name: 'documents', +// open: async (orbitdb, address, options) => await orbitdb.docs(address, options), +// write: async (db, index) => await db.put({ _id: 'hello', testing: index }), +// query: (db) => { +// const docs = db.get('hello') +// return docs ? docs[0].testing : 0 +// }, +// }, +// ] -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Multiple Databases (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Multiple Databases (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd1, ipfsd2, ipfs1, ipfs2 - let orbitdb1, orbitdb2, db1, db2, db3, db4 +// let ipfsd1, ipfsd2, ipfs1, ipfs2 +// let orbitdb1, orbitdb2, db1, db2, db3, db4 - let localDatabases = [] - let remoteDatabases = [] +// let localDatabases = [] +// let remoteDatabases = [] - // Create two IPFS instances and two OrbitDB instances (2 nodes/peers) - before(async () => { - rmrf.sync(dbPath1) - rmrf.sync(dbPath2) +// // Create two IPFS instances and two OrbitDB instances (2 nodes/peers) +// before(async () => { +// rmrf.sync(dbPath1) +// rmrf.sync(dbPath2) - 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") - orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: dbPath1 }) - orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: dbPath2 }) - }) +// 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") +// orbitdb1 = await OrbitDB.createInstance(ipfs1, { directory: dbPath1 }) +// orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: dbPath2 }) +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if(orbitdb2) - await orbitdb2.stop() +// if(orbitdb2) +// await orbitdb2.stop() - if (ipfsd1) - await stopIpfs(ipfsd1) +// if (ipfsd1) +// await stopIpfs(ipfsd1) - if (ipfsd2) - await stopIpfs(ipfsd2) - }) +// if (ipfsd2) +// await stopIpfs(ipfsd2) +// }) - beforeEach(async () => { - let options = {} - // Set write access for both clients - options.write = [ - orbitdb1.identity.publicKey, - orbitdb2.identity.publicKey - ], +// beforeEach(async () => { +// let options = {} +// // Set write access for both clients +// options.write = [ +// orbitdb1.identity.publicKey, +// orbitdb2.identity.publicKey +// ], - console.log("Creating databases and waiting for peers to connect") +// console.log("Creating databases and waiting for peers to connect") - // Open the databases on the first node - options = Object.assign({}, options, { create: true }) +// // Open the databases on the first node +// options = Object.assign({}, options, { create: true }) - // Open the databases on the first node - for (let dbInterface of databaseInterfaces) { - const db = await dbInterface.open(orbitdb1, dbInterface.name, options) - localDatabases.push(db) - } +// // Open the databases on the first node +// for (let dbInterface of databaseInterfaces) { +// const db = await dbInterface.open(orbitdb1, dbInterface.name, options) +// localDatabases.push(db) +// } - for (let [index, dbInterface] of databaseInterfaces.entries()) { - const address = localDatabases[index].address.toString() - const db = await dbInterface.open(orbitdb2, address, options) - remoteDatabases.push(db) - } +// for (let [index, dbInterface] of databaseInterfaces.entries()) { +// const address = localDatabases[index].address.toString() +// const db = await dbInterface.open(orbitdb2, address, options) +// remoteDatabases.push(db) +// } - // Wait for the peers to connect - await waitForPeers(ipfs1, [orbitdb2.id], localDatabases[0].address.toString()) - await waitForPeers(ipfs2, [orbitdb1.id], localDatabases[0].address.toString()) +// // Wait for the peers to connect +// await waitForPeers(ipfs1, [orbitdb2.id], localDatabases[0].address.toString()) +// await waitForPeers(ipfs2, [orbitdb1.id], localDatabases[0].address.toString()) - console.log("Peers connected") - }) +// console.log("Peers connected") +// }) - afterEach(async () => { - for (let db of remoteDatabases) - await db.drop() +// afterEach(async () => { +// for (let db of remoteDatabases) +// await db.drop() - for (let db of localDatabases) - await db.drop() - }) +// for (let db of localDatabases) +// await db.drop() +// }) - it('replicates multiple open databases', async () => { - const entryCount = 32 - const entryArr = [] +// it('replicates multiple open databases', async () => { +// const entryCount = 32 +// const entryArr = [] - // Create an array that we use to create the db entries - for (let i = 1; i < entryCount + 1; i ++) - entryArr.push(i) +// // Create an array that we use to create the db entries +// for (let i = 1; i < entryCount + 1; i ++) +// entryArr.push(i) - // Write entries to each database - console.log("Writing to databases") - for (let index = 0; index < databaseInterfaces.length; index++) { - const dbInterface = databaseInterfaces[index] - const db = localDatabases[index] - await mapSeries(entryArr, val => dbInterface.write(db, val)) - } +// // Write entries to each database +// console.log("Writing to databases") +// for (let index = 0; index < databaseInterfaces.length; index++) { +// const dbInterface = databaseInterfaces[index] +// const db = localDatabases[index] +// await mapSeries(entryArr, val => dbInterface.write(db, val)) +// } - // Function to check if all databases have been replicated - const allReplicated = () => { - return remoteDatabases.every(db => db._oplog.length === entryCount) - } +// // Function to check if all databases have been replicated +// const allReplicated = () => { +// return remoteDatabases.every(db => db._oplog.length === entryCount) +// } - console.log("Waiting for replication to finish") +// console.log("Waiting for replication to finish") - return new Promise((resolve, reject) => { - const interval = setInterval(() => { - if (allReplicated()) { - clearInterval(interval) - // Verify that the databases contain all the right entries - databaseInterfaces.forEach((dbInterface, index) => { - const db = remoteDatabases[index] - const result = dbInterface.query(db) - assert.equal(result, entryCount) - assert.equal(db._oplog.length, entryCount) - }) - resolve() - } - }, 200) - }) - }) - }) -}) +// return new Promise((resolve, reject) => { +// const interval = setInterval(() => { +// if (allReplicated()) { +// clearInterval(interval) +// // Verify that the databases contain all the right entries +// databaseInterfaces.forEach((dbInterface, index) => { +// const db = remoteDatabases[index] +// const result = dbInterface.query(db) +// assert.equal(result, entryCount) +// assert.equal(db._oplog.length, entryCount) +// }) +// resolve() +// } +// }, 200) +// }) +// }) +// }) +// }) diff --git a/test/offline-mode.js b/test/offline-mode.js index fcd5770..69a20a9 100644 --- a/test/offline-mode.js +++ b/test/offline-mode.js @@ -1,85 +1,85 @@ -import fs from 'fs' -import path from 'path' -import assert from 'assert' -import mapSeries from 'p-map-series' -import rmrf from 'rimraf' -import OrbitDB from '../src/OrbitDB.js' -import Identities from 'orbit-db-identity-provider' -import Keystore from 'orbit-db-keystore' -import storageAdapter from 'orbit-db-storage-adapter' +// import fs from 'fs' +// import path from 'path' +// import assert from 'assert' +// import mapSeries from 'p-map-series' +// import rmrf from 'rimraf' +// import OrbitDB from '../src/OrbitDB.js' +// import Identities from 'orbit-db-identity-provider' +// import Keystore from 'orbit-db-keystore' +// import storageAdapter from 'orbit-db-storage-adapter' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const storage = storageAdapter() +// const storage = storageAdapter() -const dbPath1 = './orbitdb/tests/offline/db1' -const dbPath2 = './orbitdb/tests/offline/db2' +// const dbPath1 = './orbitdb/tests/offline/db1' +// const dbPath2 = './orbitdb/tests/offline/db2' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Offline mode (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Offline mode (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd1, ipfsd2, ipfs1, ipfs2, orbitdb, db, keystore - let identity1, identity2 - let localDataPath +// let ipfsd1, ipfsd2, ipfs1, ipfs2, orbitdb, db, keystore +// let identity1, identity2 +// let localDataPath - before(async () => { - rmrf.sync(dbPath1) - rmrf.sync(dbPath2) - ipfsd1 = await startIpfs(API, config.daemon1) - ipfsd2 = await startIpfs(API, config.daemon2) - ipfs1 = ipfsd1.api - ipfs2 = ipfsd2.api - }) +// before(async () => { +// rmrf.sync(dbPath1) +// rmrf.sync(dbPath2) +// ipfsd1 = await startIpfs(API, config.daemon1) +// ipfsd2 = await startIpfs(API, config.daemon2) +// ipfs1 = ipfsd1.api +// ipfs2 = ipfsd2.api +// }) - after(async () => { - if(orbitdb) - await orbitdb.stop() +// after(async () => { +// if(orbitdb) +// await orbitdb.stop() - if (ipfsd1) - await stopIpfs(ipfsd1) - if (ipfsd2) - await stopIpfs(ipfsd2) - }) +// if (ipfsd1) +// await stopIpfs(ipfsd1) +// if (ipfsd2) +// await stopIpfs(ipfsd2) +// }) - beforeEach(() => { - rmrf.sync(dbPath1) - rmrf.sync(dbPath2) - }) +// beforeEach(() => { +// rmrf.sync(dbPath1) +// rmrf.sync(dbPath2) +// }) - it('starts in offline mode', async () => { - orbitdb = await OrbitDB.createInstance(ipfs1, { id: 'A', offline: true, directory: dbPath1 }) - assert.equal(orbitdb._pubsub, null) - await orbitdb.stop() - }) +// it('starts in offline mode', async () => { +// orbitdb = await OrbitDB.createInstance(ipfs1, { id: 'A', offline: true, directory: dbPath1 }) +// assert.equal(orbitdb._pubsub, null) +// await orbitdb.stop() +// }) - it('does not start in offline mode', async () => { - orbitdb = await OrbitDB.createInstance(ipfs1, { offline: false, directory: dbPath1 }) - assert.notEqual(orbitdb._pubsub, null) - await orbitdb.stop() - }) +// it('does not start in offline mode', async () => { +// orbitdb = await OrbitDB.createInstance(ipfs1, { offline: false, directory: dbPath1 }) +// assert.notEqual(orbitdb._pubsub, null) +// await orbitdb.stop() +// }) - it('does not start in offline mode - default', async () => { - orbitdb = await OrbitDB.createInstance(ipfs1, { directory: dbPath1 }) - assert.notEqual(orbitdb._pubsub, null) - await orbitdb.stop() - }) +// it('does not start in offline mode - default', async () => { +// orbitdb = await OrbitDB.createInstance(ipfs1, { directory: dbPath1 }) +// assert.notEqual(orbitdb._pubsub, null) +// await orbitdb.stop() +// }) - it('throws error if no `id` passed in offline mode', async () => { - let err - try { - orbitdb = await OrbitDB.createInstance(ipfs1, { offline: true, directory: dbPath1 }) - } catch (e) { - err = e.message - } - assert.equal(err, 'Offline mode requires passing an `id` in the options') - await orbitdb.stop() - }) - }) -}) +// it('throws error if no `id` passed in offline mode', async () => { +// let err +// try { +// orbitdb = await OrbitDB.createInstance(ipfs1, { offline: true, directory: dbPath1 }) +// } catch (e) { +// err = e.message +// } +// assert.equal(err, 'Offline mode requires passing an `id` in the options') +// await orbitdb.stop() +// }) +// }) +// }) diff --git a/test/orbit-db-address.test.js b/test/orbit-db-address.test.js index 438405e..d2bf951 100644 --- a/test/orbit-db-address.test.js +++ b/test/orbit-db-address.test.js @@ -1,118 +1,118 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import OrbitDB from '../src/OrbitDB.js' -import OrbitDBAddress from '../src/orbit-db-address.js' -import { - config, - startIpfs, - stopIpfs, - testAPIs -} from 'orbit-db-test-utils' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import OrbitDB from '../src/OrbitDB.js' +// import OrbitDBAddress from '../src/orbit-db-address.js' +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs +// } from 'orbit-db-test-utils' -const dbPath = './orbitdb/tests/orbit-db-address' +// const dbPath = './orbitdb/tests/orbit-db-address' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - OrbitDB Address (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - OrbitDB Address (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb +// let ipfsd, ipfs, orbitdb - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) +// }) - after(async () => { - if(orbitdb) - await orbitdb.stop() +// after(async () => { +// if(orbitdb) +// await orbitdb.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - describe('Parse Address', () => { - it('throws an error if address is empty', () => { - let err - try { - const result = OrbitDB.parseAddress('') - } catch (e) { - err = e.toString() - } - assert.equal(err, 'Error: Not a valid OrbitDB address: ') - }) +// describe('Parse Address', () => { +// it('throws an error if address is empty', () => { +// let err +// try { +// const result = OrbitDB.parseAddress('') +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, 'Error: Not a valid OrbitDB address: ') +// }) - it('parse address successfully', () => { - const address = '/orbitdb/zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13/first-database' - const result = OrbitDB.parseAddress(address) +// it('parse address successfully', () => { +// const address = '/orbitdb/zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13/first-database' +// const result = OrbitDB.parseAddress(address) - const isInstanceOf = result instanceof OrbitDBAddress - assert.equal(isInstanceOf, true) +// const isInstanceOf = result instanceof OrbitDBAddress +// assert.equal(isInstanceOf, true) - assert.equal(result.root, 'zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13') - assert.equal(result.path, 'first-database') +// assert.equal(result.root, 'zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13') +// assert.equal(result.path, 'first-database') - assert.equal(result.toString().indexOf('/orbitdb'), 0) - assert.equal(result.toString().indexOf('zd'), 9) - }) +// assert.equal(result.toString().indexOf('/orbitdb'), 0) +// assert.equal(result.toString().indexOf('zd'), 9) +// }) - it('parse address with backslashes (win32) successfully', () => { - const address = '\\orbitdb\\Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzcJC\\first-database' - const result = OrbitDB.parseAddress(address) +// it('parse address with backslashes (win32) successfully', () => { +// const address = '\\orbitdb\\Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzcJC\\first-database' +// const result = OrbitDB.parseAddress(address) - const isInstanceOf = result instanceof OrbitDBAddress - assert.equal(isInstanceOf, true) +// const isInstanceOf = result instanceof OrbitDBAddress +// assert.equal(isInstanceOf, true) - assert.equal(result.root, 'Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzcJC') - assert.equal(result.path, 'first-database') +// assert.equal(result.root, 'Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzcJC') +// assert.equal(result.path, 'first-database') - assert.equal(result.toString().indexOf('/orbitdb'), 0) - assert.equal(result.toString().indexOf('Qm'), 9) - }) - }) +// assert.equal(result.toString().indexOf('/orbitdb'), 0) +// assert.equal(result.toString().indexOf('Qm'), 9) +// }) +// }) - describe('isValid Address', () => { - it('returns false for empty string', () => { - const result = OrbitDB.isValidAddress('') - assert.equal(result, false) - }) +// describe('isValid Address', () => { +// it('returns false for empty string', () => { +// const result = OrbitDB.isValidAddress('') +// assert.equal(result, false) +// }) - it('validate address successfully', () => { - const address = '/orbitdb/zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13/first-database' - const result = OrbitDB.isValidAddress(address) +// it('validate address successfully', () => { +// const address = '/orbitdb/zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13/first-database' +// const result = OrbitDB.isValidAddress(address) - assert.equal(result, true) - }) +// assert.equal(result, true) +// }) - it('handle missing orbitdb prefix', () => { - const address = 'zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13/first-database' - const result = OrbitDB.isValidAddress(address) +// it('handle missing orbitdb prefix', () => { +// const address = 'zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13/first-database' +// const result = OrbitDB.isValidAddress(address) - assert.equal(result, true) - }) +// assert.equal(result, true) +// }) - it('handle missing db address name', () => { - const address = '/orbitdb/zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13' - const result = OrbitDB.isValidAddress(address) +// it('handle missing db address name', () => { +// const address = '/orbitdb/zdpuAuK3BHpS7NvMBivynypqciYCuy2UW77XYBPUYRnLjnw13' +// const result = OrbitDB.isValidAddress(address) - assert.equal(result, true) - }) +// assert.equal(result, true) +// }) - it('handle invalid multihash', () => { - const address = '/orbitdb/Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzc/first-database' - const result = OrbitDB.isValidAddress(address) +// it('handle invalid multihash', () => { +// const address = '/orbitdb/Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzc/first-database' +// const result = OrbitDB.isValidAddress(address) - assert.equal(result, false) - }) +// assert.equal(result, false) +// }) - it('validate address with backslashes (win32) successfully', () => { - const address = '\\orbitdb\\Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzcJC\\first-database' - const result = OrbitDB.isValidAddress(address) +// it('validate address with backslashes (win32) successfully', () => { +// const address = '\\orbitdb\\Qmdgwt7w4uBsw8LXduzCd18zfGXeTmBsiR8edQ1hSfzcJC\\first-database' +// const result = OrbitDB.isValidAddress(address) - assert.equal(result, true) - }) - }) +// assert.equal(result, true) +// }) +// }) - }) -}) +// }) +// }) diff --git a/test/persistency.js b/test/persistency.js index 7b1a2a8..d6462d7 100644 --- a/test/persistency.js +++ b/test/persistency.js @@ -1,297 +1,297 @@ -import assert from 'assert' -import mapSeries from 'p-map-series' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' -import Cache from 'orbit-db-cache' -import Storage from 'orbit-db-storage-adapter' +// import assert from 'assert' +// import mapSeries from 'p-map-series' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' +// import Cache from 'orbit-db-cache' +// import Storage from 'orbit-db-storage-adapter' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs +// } from 'orbit-db-test-utils' -const dbPath = './orbitdb/tests/persistency' +// const dbPath = './orbitdb/tests/persistency' -const tests = [ - { - title: 'Persistency', - orbitDBConfig: { directory: path.join(dbPath, '1') } - }, -] +// const tests = [ +// { +// title: 'Persistency', +// orbitDBConfig: { directory: path.join(dbPath, '1') } +// }, +// ] -Object.keys(testAPIs).forEach(API => { - tests.forEach(test => { - describe(`orbit-db - ${test.title} (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// tests.forEach(test => { +// describe(`orbit-db - ${test.title} (${API})`, function() { +// this.timeout(config.timeout) - const entryCount = 65 +// const entryCount = 65 - let ipfsd, ipfs, orbitdb1, db, address +// let ipfsd, ipfs, orbitdb1, db, address - before(async () => { - const options = Object.assign({}, test.orbitDBConfig) +// before(async () => { +// const options = Object.assign({}, test.orbitDBConfig) - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, options) - }) +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, options) +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - describe('load', function() { - beforeEach(async () => { - const dbName = new Date().getTime().toString() - const entryArr = [] +// describe('load', function() { +// beforeEach(async () => { +// const dbName = new Date().getTime().toString() +// const entryArr = [] - for (let i = 0; i < entryCount; i ++) - entryArr.push(i) +// for (let i = 0; i < entryCount; i ++) +// entryArr.push(i) - db = await orbitdb1.eventlog(dbName) - address = db.address.toString() - await mapSeries(entryArr, (i) => db.add('hello' + i)) - await db.close() - db = null - }) +// db = await orbitdb1.eventlog(dbName) +// address = db.address.toString() +// await mapSeries(entryArr, (i) => db.add('hello' + i)) +// await db.close() +// db = null +// }) - afterEach(async () => { - await db.drop() - }) +// afterEach(async () => { +// await db.drop() +// }) - it('loads database from local cache', async () => { - db = await orbitdb1.eventlog(address) - await db.load() - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount) - assert.equal(items[0].payload.value, 'hello0') - assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) - }) +// it('loads database from local cache', async () => { +// db = await orbitdb1.eventlog(address) +// await db.load() +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount) +// assert.equal(items[0].payload.value, 'hello0') +// assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) +// }) - it('loads database partially', async () => { - const amount = 33 - db = await orbitdb1.eventlog(address) - await db.load(amount) - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, amount) - assert.equal(items[0].payload.value, 'hello' + (entryCount - amount)) - assert.equal(items[1].payload.value, 'hello' + (entryCount - amount + 1)) - assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) - }) +// it('loads database partially', async () => { +// const amount = 33 +// db = await orbitdb1.eventlog(address) +// await db.load(amount) +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, amount) +// assert.equal(items[0].payload.value, 'hello' + (entryCount - amount)) +// assert.equal(items[1].payload.value, 'hello' + (entryCount - amount + 1)) +// assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) +// }) - it('load and close several times', async () => { - const amount = 8 - for (let i = 0; i < amount; i ++) { - db = await orbitdb1.eventlog(address) - await db.load() - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount) - assert.equal(items[0].payload.value, 'hello0') - assert.equal(items[1].payload.value, 'hello1') - assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) - await db.close() - } - }) +// it('load and close several times', async () => { +// const amount = 8 +// for (let i = 0; i < amount; i ++) { +// db = await orbitdb1.eventlog(address) +// await db.load() +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount) +// assert.equal(items[0].payload.value, 'hello0') +// assert.equal(items[1].payload.value, 'hello1') +// assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) +// await db.close() +// } +// }) - it('closes database while loading', async () => { - db = await orbitdb1.eventlog(address, { replicationConcurrency: 1 }) - return new Promise(async (resolve, reject) => { - // don't wait for load to finish - db.load() - .then(() => reject("Should not finish loading?")) - .catch(e => { - if (e.code !== 'LEVEL_DATABASE_NOT_OPEN') { - reject(e) - } else { - assert.equal(db._cache.store, null) - resolve() - } - }) - await db.close() - }) - }) +// it('closes database while loading', async () => { +// db = await orbitdb1.eventlog(address, { replicationConcurrency: 1 }) +// return new Promise(async (resolve, reject) => { +// // don't wait for load to finish +// db.load() +// .then(() => reject("Should not finish loading?")) +// .catch(e => { +// if (e.code !== 'LEVEL_DATABASE_NOT_OPEN') { +// reject(e) +// } else { +// assert.equal(db._cache.store, null) +// resolve() +// } +// }) +// await db.close() +// }) +// }) - it('load, add one, close - several times', async () => { - const amount = 8 - for (let i = 0; i < amount; i ++) { - db = await orbitdb1.eventlog(address) - await db.load() - await db.add('hello' + (entryCount + i)) - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount + i + 1) - assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount + i)) - await db.close() - } - }) +// it('load, add one, close - several times', async () => { +// const amount = 8 +// for (let i = 0; i < amount; i ++) { +// db = await orbitdb1.eventlog(address) +// await db.load() +// await db.add('hello' + (entryCount + i)) +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount + i + 1) +// assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount + i)) +// await db.close() +// } +// }) - it('loading a database emits \'ready\' event', async () => { - db = await orbitdb1.eventlog(address) - return new Promise(async (resolve) => { - db.events.on('ready', () => { - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount) - assert.equal(items[0].payload.value, 'hello0') - assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) - resolve() - }) - await db.load() - }) - }) +// it('loading a database emits \'ready\' event', async () => { +// db = await orbitdb1.eventlog(address) +// return new Promise(async (resolve) => { +// db.events.on('ready', () => { +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount) +// assert.equal(items[0].payload.value, 'hello0') +// assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount - 1)) +// resolve() +// }) +// await db.load() +// }) +// }) - it('loading a database emits \'load.progress\' event', async () => { - db = await orbitdb1.eventlog(address) - return new Promise(async (resolve, reject) => { - let count = 0 - db.events.on('load.progress', (address, hash, entry) => { - count ++ - try { - assert.equal(address, db.address.toString()) +// it('loading a database emits \'load.progress\' event', async () => { +// db = await orbitdb1.eventlog(address) +// return new Promise(async (resolve, reject) => { +// let count = 0 +// db.events.on('load.progress', (address, hash, entry) => { +// count ++ +// try { +// assert.equal(address, db.address.toString()) - const { progress, max } = db.replicationStatus - assert.equal(max, entryCount) - assert.equal(progress, count) +// const { progress, max } = db.replicationStatus +// assert.equal(max, entryCount) +// assert.equal(progress, count) - assert.notEqual(hash, null) - assert.notEqual(entry, null) +// assert.notEqual(hash, null) +// assert.notEqual(entry, null) - if (progress === entryCount && count === entryCount) { - setTimeout(() => { - resolve() - }, 200) - } - } catch (e) { - reject(e) - } - }) - // Start loading the database - await db.load() - }) - }) - }) +// if (progress === entryCount && count === entryCount) { +// setTimeout(() => { +// resolve() +// }, 200) +// } +// } catch (e) { +// reject(e) +// } +// }) +// // Start loading the database +// await db.load() +// }) +// }) +// }) - describe('load from empty snapshot', function() { - it('loads database from an empty snapshot', async () => { - db = await orbitdb1.eventlog('empty-snapshot') - address = db.address.toString() - await db.saveSnapshot() - await db.close() +// describe('load from empty snapshot', function() { +// it('loads database from an empty snapshot', async () => { +// db = await orbitdb1.eventlog('empty-snapshot') +// address = db.address.toString() +// await db.saveSnapshot() +// await db.close() - db = await orbitdb1.open(address) - await db.loadFromSnapshot() - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, 0) - }) - }) +// db = await orbitdb1.open(address) +// await db.loadFromSnapshot() +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, 0) +// }) +// }) - describe('load from snapshot', function() { - beforeEach(async () => { - const dbName = new Date().getTime().toString() - const entryArr = [] +// describe('load from snapshot', function() { +// beforeEach(async () => { +// const dbName = new Date().getTime().toString() +// const entryArr = [] - for (let i = 0; i < entryCount; i ++) - entryArr.push(i) +// for (let i = 0; i < entryCount; i ++) +// entryArr.push(i) - db = await orbitdb1.eventlog(dbName) - address = db.address.toString() - await mapSeries(entryArr, (i) => db.add('hello' + i)) - await db.saveSnapshot() - await db.close() - db = null - }) +// db = await orbitdb1.eventlog(dbName) +// address = db.address.toString() +// await mapSeries(entryArr, (i) => db.add('hello' + i)) +// await db.saveSnapshot() +// await db.close() +// db = null +// }) - afterEach(async () => { - await db.drop() - }) +// afterEach(async () => { +// await db.drop() +// }) - it('loads database from snapshot', async () => { - db = await orbitdb1.eventlog(address) - await db.loadFromSnapshot() - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount) - assert.equal(items[0].payload.value, 'hello0') - assert.equal(items[entryCount - 1].payload.value, 'hello' + (entryCount - 1)) - }) +// it('loads database from snapshot', async () => { +// db = await orbitdb1.eventlog(address) +// await db.loadFromSnapshot() +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount) +// assert.equal(items[0].payload.value, 'hello0') +// assert.equal(items[entryCount - 1].payload.value, 'hello' + (entryCount - 1)) +// }) - it('load, add one and save snapshot several times', async () => { - const amount = 4 - for (let i = 0; i < amount; i ++) { - db = await orbitdb1.eventlog(address) - await db.loadFromSnapshot() - await db.add('hello' + (entryCount + i)) - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount + i + 1) - assert.equal(items[0].payload.value, 'hello0') - assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount + i)) - await db.saveSnapshot() - await db.close() - } - }) +// it('load, add one and save snapshot several times', async () => { +// const amount = 4 +// for (let i = 0; i < amount; i ++) { +// db = await orbitdb1.eventlog(address) +// await db.loadFromSnapshot() +// await db.add('hello' + (entryCount + i)) +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount + i + 1) +// assert.equal(items[0].payload.value, 'hello0') +// assert.equal(items[items.length - 1].payload.value, 'hello' + (entryCount + i)) +// await db.saveSnapshot() +// await db.close() +// } +// }) - it('throws an error when trying to load a missing snapshot', async () => { - db = await orbitdb1.eventlog(address) - await db.drop() - db = null - db = await orbitdb1.eventlog(address) +// it('throws an error when trying to load a missing snapshot', async () => { +// db = await orbitdb1.eventlog(address) +// await db.drop() +// db = null +// db = await orbitdb1.eventlog(address) - let err - try { - await db.loadFromSnapshot() - } catch (e) { - err = e.toString() - } - assert.equal(err, `Error: Snapshot for ${address} not found!`) - }) +// let err +// try { +// await db.loadFromSnapshot() +// } catch (e) { +// err = e.toString() +// } +// assert.equal(err, `Error: Snapshot for ${address} not found!`) +// }) - it('loading a database emits \'ready\' event', async () => { - db = await orbitdb1.eventlog(address) - return new Promise(async (resolve) => { - db.events.on('ready', () => { - const items = db.iterator({ limit: -1 }).collect() - assert.equal(items.length, entryCount) - assert.equal(items[0].payload.value, 'hello0') - assert.equal(items[entryCount - 1].payload.value, 'hello' + (entryCount - 1)) - resolve() - }) - await db.loadFromSnapshot() - }) - }) +// it('loading a database emits \'ready\' event', async () => { +// db = await orbitdb1.eventlog(address) +// return new Promise(async (resolve) => { +// db.events.on('ready', () => { +// const items = db.iterator({ limit: -1 }).collect() +// assert.equal(items.length, entryCount) +// assert.equal(items[0].payload.value, 'hello0') +// assert.equal(items[entryCount - 1].payload.value, 'hello' + (entryCount - 1)) +// resolve() +// }) +// await db.loadFromSnapshot() +// }) +// }) - it('loading a database emits \'load.progress\' event', async () => { - db = await orbitdb1.eventlog(address) - return new Promise(async (resolve, reject) => { - let count = 0 - db.events.on('load.progress', (address, hash, entry) => { - count ++ - try { - assert.equal(address, db.address.toString()) +// it('loading a database emits \'load.progress\' event', async () => { +// db = await orbitdb1.eventlog(address) +// return new Promise(async (resolve, reject) => { +// let count = 0 +// db.events.on('load.progress', (address, hash, entry) => { +// count ++ +// try { +// assert.equal(address, db.address.toString()) - const { progress, max } = db.replicationStatus - assert.equal(max, entryCount) - assert.equal(progress, count) +// const { progress, max } = db.replicationStatus +// assert.equal(max, entryCount) +// assert.equal(progress, count) - assert.notEqual(hash, null) - assert.notEqual(entry, null) - if (progress === entryCount && count === entryCount) { - resolve() - } - } catch (e) { - reject(e) - } - }) - // Start loading the database - await db.loadFromSnapshot() - }) - }) - }) - }) - }) -}) +// assert.notEqual(hash, null) +// assert.notEqual(entry, null) +// if (progress === entryCount && count === entryCount) { +// resolve() +// } +// } catch (e) { +// reject(e) +// } +// }) +// // Start loading the database +// await db.loadFromSnapshot() +// }) +// }) +// }) +// }) +// }) +// }) diff --git a/test/re-exports.test.js b/test/re-exports.test.js index 56bfad9..2297b47 100644 --- a/test/re-exports.test.js +++ b/test/re-exports.test.js @@ -1,22 +1,22 @@ -import assert from 'assert' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import OrbitDB from '../src/OrbitDB.js' -const AccessControllers = OrbitDB.AccessControllers -const Identities = OrbitDB.Identities -const Keystore = OrbitDB.Keystore +// const AccessControllers = OrbitDB.AccessControllers +// const Identities = OrbitDB.Identities +// const Keystore = OrbitDB.Keystore -describe('Re-exports', function () { - it('Successfully re-exports AccessControllers', () => { - assert.strictEqual(typeof AccessControllers, 'function') - assert.strictEqual(typeof AccessControllers.addAccessController, 'function') - }) +// describe('Re-exports', function () { +// it('Successfully re-exports AccessControllers', () => { +// assert.strictEqual(typeof AccessControllers, 'function') +// assert.strictEqual(typeof AccessControllers.addAccessController, 'function') +// }) - it('Successfully re-exports Identities', () => { - assert.strictEqual(typeof Identities, 'function') - assert.strictEqual(typeof Identities.createIdentity, 'function') - }) +// it('Successfully re-exports Identities', () => { +// assert.strictEqual(typeof Identities, 'function') +// assert.strictEqual(typeof Identities.createIdentity, 'function') +// }) - it('Successfully re-exports Keystore', () => { - assert.strictEqual(typeof Keystore, 'function') - }) -}) +// it('Successfully re-exports Keystore', () => { +// assert.strictEqual(typeof Keystore, 'function') +// }) +// }) diff --git a/test/replicate-and-load.test.js b/test/replicate-and-load.test.js index 931c9ae..707d666 100644 --- a/test/replicate-and-load.test.js +++ b/test/replicate-and-load.test.js @@ -1,164 +1,164 @@ -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/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' +// 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) +// 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 +// 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") - }) +// 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() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if(orbitdb2) - await orbitdb2.stop() +// if(orbitdb2) +// await orbitdb2.stop() - if (ipfsd1) - await stopIpfs(ipfsd1) +// if (ipfsd1) +// await stopIpfs(ipfsd1) - if (ipfsd2) - await stopIpfs(ipfsd2) +// if (ipfsd2) +// await stopIpfs(ipfsd2) - rmrf.sync(dbPath1) - rmrf.sync(dbPath2) - }) +// rmrf.sync(dbPath1) +// rmrf.sync(dbPath2) +// }) - describe('two peers', function() { - let db1, db2 +// 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 - ] +// 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) - } +// 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() +// before(async () => { +// await openDatabases() - assert.equal(db1.address.toString(), db2.address.toString()) +// 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()) - }) +// 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() - } +// after(async () => { +// if (db1) { +// await db1.drop() +// } - if (db2) { - await db2.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 +// 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) +// 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") +// 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) +// 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') +// 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 { +// try { - // Set write access for both clients - let options = { - accessController: { - write: [ - orbitdb1.identity.id, - orbitdb2.identity.id - ] - } - } +// // 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() +// // 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) +// // 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() +// 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) +// // 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) - }) - }) - }) - }) -}) +// await db3.drop() +// await db4.drop() +// } catch (e) { +// reject(e) +// } +// resolve() +// } +// }, 1000) +// }) +// }) +// }) +// }) +// }) diff --git a/test/replicate-automatically.test.js b/test/replicate-automatically.test.js index b053054..21486d4 100644 --- a/test/replicate-automatically.test.js +++ b/test/replicate-automatically.test.js @@ -1,128 +1,128 @@ -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, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// connectPeers, +// } from 'orbit-db-test-utils' -const dbPath1 = './orbitdb/tests/replicate-automatically/1' -const dbPath2 = './orbitdb/tests/replicate-automatically/2' +// const dbPath1 = './orbitdb/tests/replicate-automatically/1' +// const dbPath2 = './orbitdb/tests/replicate-automatically/2' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Automatic Replication (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Automatic Replication (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd1, ipfsd2, ipfs1, ipfs2 - let orbitdb1, orbitdb2, db1, db2, db3, db4 +// let ipfsd1, ipfsd2, ipfs1, ipfs2 +// let orbitdb1, orbitdb2, db1, db2, db3, db4 - before(async () => { - rmrf.sync('./orbitdb') - 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: dbPath1 }) - orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: dbPath2 }) +// before(async () => { +// rmrf.sync('./orbitdb') +// 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: dbPath1 }) +// orbitdb2 = await OrbitDB.createInstance(ipfs2, { directory: dbPath2 }) - let options = {} - // Set write access for both clients - options.write = [ - orbitdb1.identity.publicKey, - orbitdb2.identity.publicKey - ] +// let options = {} +// // Set write access for both clients +// options.write = [ +// orbitdb1.identity.publicKey, +// orbitdb2.identity.publicKey +// ] - options = Object.assign({}, options) - db1 = await orbitdb1.eventlog('replicate-automatically-tests', options) - db3 = await orbitdb1.keyvalue('replicate-automatically-tests-kv', options) - }) +// options = Object.assign({}, options) +// db1 = await orbitdb1.eventlog('replicate-automatically-tests', options) +// db3 = await orbitdb1.keyvalue('replicate-automatically-tests-kv', options) +// }) - after(async () => { - if (orbitdb1) { - await orbitdb1.stop() - } +// after(async () => { +// if (orbitdb1) { +// await orbitdb1.stop() +// } - if (orbitdb2) { - await orbitdb2.stop() - } +// if (orbitdb2) { +// await orbitdb2.stop() +// } - if (ipfsd1) { - await stopIpfs(ipfsd1) - } +// if (ipfsd1) { +// await stopIpfs(ipfsd1) +// } - if (ipfs2) { - await stopIpfs(ipfsd2) - } +// if (ipfs2) { +// await stopIpfs(ipfsd2) +// } - rmrf.sync(dbPath1) - rmrf.sync(dbPath2) - }) +// rmrf.sync(dbPath1) +// rmrf.sync(dbPath2) +// }) - it('starts replicating the database when peers connect', async () => { - const isLocalhostAddress = (addr) => addr.toString().includes('127.0.0.1') - await connectPeers(ipfs1, ipfs2, { filter: isLocalhostAddress }) - console.log('Peers connected') +// it('starts replicating the database when peers connect', async () => { +// const isLocalhostAddress = (addr) => addr.toString().includes('127.0.0.1') +// await connectPeers(ipfs1, ipfs2, { filter: isLocalhostAddress }) +// console.log('Peers connected') - const entryCount = 33 - const entryArr = [] +// const entryCount = 33 +// const entryArr = [] - // Create the entries in the first database - for (let i = 0; i < entryCount; i++) { - entryArr.push(i) - } +// // Create the entries in the first database +// for (let i = 0; i < entryCount; i++) { +// entryArr.push(i) +// } - await mapSeries(entryArr, (i) => db1.add('hello' + i)) +// await mapSeries(entryArr, (i) => db1.add('hello' + i)) - // Open the second database - db2 = await orbitdb2.eventlog(db1.address.toString()) - db4 = await orbitdb2.keyvalue(db3.address.toString()) +// // Open the second database +// db2 = await orbitdb2.eventlog(db1.address.toString()) +// db4 = await orbitdb2.keyvalue(db3.address.toString()) - // Listen for the 'replicated' events and check that all the entries - // were replicated to the second database - return new Promise((resolve, reject) => { - // Check if db2 was already replicated - let all = db2.iterator({ limit: -1 }).collect().length - // Run the test asserts below if replication was done - let finished = (all === entryCount) +// // Listen for the 'replicated' events and check that all the entries +// // were replicated to the second database +// return new Promise((resolve, reject) => { +// // Check if db2 was already replicated +// let all = db2.iterator({ limit: -1 }).collect().length +// // Run the test asserts below if replication was done +// let finished = (all === entryCount) - db3.events.on('replicated', (address, hash, entry) => { - reject(new Error("db3 should not receive the 'replicated' event!")) - }) +// db3.events.on('replicated', (address, hash, entry) => { +// reject(new Error("db3 should not receive the 'replicated' event!")) +// }) - db4.events.on('replicated', (address, hash, entry) => { - reject(new Error("db4 should not receive the 'replicated' event!")) - }) +// db4.events.on('replicated', (address, hash, entry) => { +// reject(new Error("db4 should not receive the 'replicated' event!")) +// }) - db2.events.on('replicated', (address, length) => { - // Once db2 has finished replication, make sure it has all elements - // and process to the asserts below - 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 +// all = db2.iterator({ limit: -1 }).collect().length +// finished = (all === entryCount) +// }) - try { - const timer = setInterval(() => { - if (finished) { - clearInterval(timer) - const result1 = db1.iterator({ limit: -1 }).collect() - const result2 = db2.iterator({ limit: -1 }).collect() - assert.equal(result1.length, result2.length) - assert.deepEqual(result1, result2) - resolve() - } - }, 1000) - } catch (e) { - reject(e) - } - }) - }) - }) -}) +// try { +// const timer = setInterval(() => { +// if (finished) { +// clearInterval(timer) +// const result1 = db1.iterator({ limit: -1 }).collect() +// const result2 = db2.iterator({ limit: -1 }).collect() +// assert.equal(result1.length, result2.length) +// assert.deepEqual(result1, result2) +// resolve() +// } +// }, 1000) +// } catch (e) { +// reject(e) +// } +// }) +// }) +// }) +// }) diff --git a/test/replicate.test.js b/test/replicate.test.js index 2e40895..dc8f311 100644 --- a/test/replicate.test.js +++ b/test/replicate.test.js @@ -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) +// } +// }) +// }) +// }) +// }) diff --git a/test/replication-status.test.js b/test/replication-status.test.js index 653b9a0..b1a4496 100644 --- a/test/replication-status.test.js +++ b/test/replication-status.test.js @@ -1,87 +1,87 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const dbPath1 = './orbitdb/tests/create-open/1' -const dbPath2 = './orbitdb/tests/create-open/2' +// const dbPath1 = './orbitdb/tests/create-open/1' +// const dbPath2 = './orbitdb/tests/create-open/2' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Replication Status (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Replication Status (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb1, orbitdb2, db, address +// let ipfsd, ipfs, orbitdb1, orbitdb2, db, address - before(async () => { - rmrf.sync(dbPath1) - rmrf.sync(dbPath2) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: dbPath1 }) - orbitdb2 = await OrbitDB.createInstance(ipfs, { directory: dbPath2 }) - db = await orbitdb1.log('replication status tests') - }) +// before(async () => { +// rmrf.sync(dbPath1) +// rmrf.sync(dbPath2) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: dbPath1 }) +// orbitdb2 = await OrbitDB.createInstance(ipfs, { directory: dbPath2 }) +// db = await orbitdb1.log('replication status tests') +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if(orbitdb2) - await orbitdb2.stop() +// if(orbitdb2) +// await orbitdb2.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - it('has correct initial state', async () => { - assert.deepEqual(db.replicationStatus, { progress: 0, max: 0 }) - }) +// it('has correct initial state', async () => { +// assert.deepEqual(db.replicationStatus, { progress: 0, max: 0 }) +// }) - it('has correct replication info after load', async () => { - await db.add('hello') - await db.close() - await db.load() - assert.deepEqual(db.replicationStatus, { progress: 1, max: 1 }) - await db.close() - }) +// it('has correct replication info after load', async () => { +// await db.add('hello') +// await db.close() +// await db.load() +// assert.deepEqual(db.replicationStatus, { progress: 1, max: 1 }) +// await db.close() +// }) - it('has correct replication info after close', async () => { - await db.close() - assert.deepEqual(db.replicationStatus, { progress: 0, max: 0 }) - }) +// it('has correct replication info after close', async () => { +// await db.close() +// assert.deepEqual(db.replicationStatus, { progress: 0, max: 0 }) +// }) - it('has correct replication info after sync', async () => { - await db.load() - await db.add('hello2') +// it('has correct replication info after sync', async () => { +// await db.load() +// await db.add('hello2') - const db2 = await orbitdb2.log(db.address.toString(), { create: false }) - await db2.sync(db._oplog.heads) +// const db2 = await orbitdb2.log(db.address.toString(), { create: false }) +// await db2.sync(db._oplog.heads) - return new Promise((resolve, reject) => { - setTimeout(() => { - try { - assert.deepEqual(db2.replicationStatus, { progress: 2, max: 2 }) - resolve() - } catch (e) { - reject(e) - } - }, 100) - }) - }) +// return new Promise((resolve, reject) => { +// setTimeout(() => { +// try { +// assert.deepEqual(db2.replicationStatus, { progress: 2, max: 2 }) +// resolve() +// } catch (e) { +// reject(e) +// } +// }, 100) +// }) +// }) - it('has correct replication info after loading from snapshot', async () => { - await db._cache._store.open() - await db.saveSnapshot() - await db.close() - await db.loadFromSnapshot() - assert.deepEqual(db.replicationStatus, { progress: 2, max: 2 }) - }) - }) -}) +// it('has correct replication info after loading from snapshot', async () => { +// await db._cache._store.open() +// await db.saveSnapshot() +// await db.close() +// await db.loadFromSnapshot() +// assert.deepEqual(db.replicationStatus, { progress: 2, max: 2 }) +// }) +// }) +// }) diff --git a/test/set-identity.test.js b/test/set-identity.test.js index 4dcb782..a09c16f 100644 --- a/test/set-identity.test.js +++ b/test/set-identity.test.js @@ -1,101 +1,101 @@ -import fs from 'fs' -import assert from 'assert' -import rmrf from 'rimraf' -import OrbitDB from '../src/OrbitDB.js' -import Identities from 'orbit-db-identity-provider' -import Keystore from 'orbit-db-keystore' -import storageAdapter from 'orbit-db-storage-adapter' +// import fs from 'fs' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import OrbitDB from '../src/OrbitDB.js' +// import Identities from 'orbit-db-identity-provider' +// import Keystore from 'orbit-db-keystore' +// import storageAdapter from 'orbit-db-storage-adapter' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const storage = storageAdapter() +// const storage = storageAdapter() -const keysPath = './orbitdb/identity/identitykeys' -const dbPath = './orbitdb/tests/change-identity' +// const keysPath = './orbitdb/identity/identitykeys' +// const dbPath = './orbitdb/tests/change-identity' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Set identities (${API})`, function() { - this.timeout(config.timeout) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Set identities (${API})`, function() { +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb, keystore, options - let identity1, identity2 +// let ipfsd, ipfs, orbitdb, keystore, options +// let identity1, identity2 - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api - if(fs && fs.mkdirSync) fs.mkdirSync(keysPath, { recursive: true }) - const identityStore = await storage.createStore(keysPath) +// if(fs && fs.mkdirSync) fs.mkdirSync(keysPath, { recursive: true }) +// const identityStore = await storage.createStore(keysPath) - keystore = new Keystore(identityStore) - identity1 = await Identities.createIdentity({ id: 'test-id1', keystore }) - identity2 = await Identities.createIdentity({ id: 'test-id2', keystore }) - orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) - }) +// keystore = new Keystore(identityStore) +// identity1 = await Identities.createIdentity({ id: 'test-id1', keystore }) +// identity2 = await Identities.createIdentity({ id: 'test-id2', keystore }) +// orbitdb = await OrbitDB.createInstance(ipfs, { directory: dbPath }) +// }) - after(async () => { - await keystore.close() - if(orbitdb) - await orbitdb.stop() +// after(async () => { +// await keystore.close() +// if(orbitdb) +// await orbitdb.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - beforeEach(async () => { - options = {} - options.accessController = { - write : [ - orbitdb.identity.id, - identity1.id - ] - } - options = Object.assign({}, options, { create: true, type: 'eventlog', overwrite: true }) - }) +// beforeEach(async () => { +// options = {} +// options.accessController = { +// write : [ +// orbitdb.identity.id, +// identity1.id +// ] +// } +// options = Object.assign({}, options, { create: true, type: 'eventlog', overwrite: true }) +// }) - it('sets identity', async () => { - const db = await orbitdb.open('abc', options) - assert.equal(db.identity, orbitdb.identity) - db.setIdentity(identity1) - assert.equal(db.identity, identity1) - await db.close() - }) +// it('sets identity', async () => { +// const db = await orbitdb.open('abc', options) +// assert.equal(db.identity, orbitdb.identity) +// db.setIdentity(identity1) +// assert.equal(db.identity, identity1) +// await db.close() +// }) - it('writes with new identity with access', async () => { - const db = await orbitdb.open('abc', options) - assert.equal(db.identity, orbitdb.identity) - db.setIdentity(identity1) - assert.equal(db.identity, identity1) - let err - try { - await db.add({ hello: '1'}) - } catch (e) { - err = e.message - } - assert.equal(err, null) - await db.drop() - }) +// it('writes with new identity with access', async () => { +// const db = await orbitdb.open('abc', options) +// assert.equal(db.identity, orbitdb.identity) +// db.setIdentity(identity1) +// assert.equal(db.identity, identity1) +// let err +// try { +// await db.add({ hello: '1'}) +// } catch (e) { +// err = e.message +// } +// assert.equal(err, null) +// await db.drop() +// }) - it('cannot write with new identity without access', async () => { - const db = await orbitdb.open('abc', options) - assert.equal(db.identity, orbitdb.identity) - db.setIdentity(identity2) - assert.equal(db.identity, identity2) - let err - try { - await db.add({ hello: '1'}) - } catch (e) { - err = e.message - } - assert.equal(err, `Could not append entry, key "${identity2.id}" is not allowed to write to the log`) - await db.drop() - }) - }) -}) +// it('cannot write with new identity without access', async () => { +// const db = await orbitdb.open('abc', options) +// assert.equal(db.identity, orbitdb.identity) +// db.setIdentity(identity2) +// assert.equal(db.identity, identity2) +// let err +// try { +// await db.add({ hello: '1'}) +// } catch (e) { +// err = e.message +// } +// assert.equal(err, `Could not append entry, key "${identity2.id}" is not allowed to write to the log`) +// await db.drop() +// }) +// }) +// }) diff --git a/test/v0-open-load.js b/test/v0-open-load.js index 5dcdc48..22a9db1 100644 --- a/test/v0-open-load.js +++ b/test/v0-open-load.js @@ -1,205 +1,205 @@ -import assert from 'assert' -import fs from 'fs-extra' -import path from 'path' -import rmrf from 'rimraf' -import leveldown from 'leveldown' -import Zip from 'adm-zip' -import OrbitDB from '../src/OrbitDB.js' -import Identities from 'orbit-db-identity-provider' -import migrate from 'localstorage-level-migration' -import Keystore from 'orbit-db-keystore' -import storageAdapter from 'orbit-db-storage-adapter' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs, -} from 'orbit-db-test-utils' +// import assert from 'assert' +// import fs from 'fs-extra' +// import path from 'path' +// import rmrf from 'rimraf' +// import leveldown from 'leveldown' +// import Zip from 'adm-zip' +// import OrbitDB from '../src/OrbitDB.js' +// import Identities from 'orbit-db-identity-provider' +// import migrate from 'localstorage-level-migration' +// import Keystore from 'orbit-db-keystore' +// import storageAdapter from 'orbit-db-storage-adapter' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs, +// } from 'orbit-db-test-utils' -const storage = storageAdapter(leveldown) +// const storage = storageAdapter(leveldown) -storage.preCreate = async (directory, options) => { - fs.mkdirSync(directory, { recursive: true }) -} +// storage.preCreate = async (directory, options) => { +// fs.mkdirSync(directory, { recursive: true }) +// } -const dbPath = path.join('./orbitdb', 'tests', 'v0') -const dbFixturesDir = path.join('./test', 'fixtures', 'v0', 'QmWDUfC4zcWJGgc9UHn1X3qQ5KZqBv4KCiCtjnpMmBT8JC', 'v0-db') -const keyFixtures = path.join('./test', 'fixtures', 'keys','QmRfPsKJs9YqTot5krRibra4gPwoK4kghhU8iKWxBjGDDX') +// const dbPath = path.join('./orbitdb', 'tests', 'v0') +// const dbFixturesDir = path.join('./test', 'fixtures', 'v0', 'QmWDUfC4zcWJGgc9UHn1X3qQ5KZqBv4KCiCtjnpMmBT8JC', 'v0-db') +// const keyFixtures = path.join('./test', 'fixtures', 'keys','QmRfPsKJs9YqTot5krRibra4gPwoK4kghhU8iKWxBjGDDX') -const ipfsFixturesDir = path.join('./test', 'fixtures', 'ipfs') +// const ipfsFixturesDir = path.join('./test', 'fixtures', 'ipfs') -Object.keys(testAPIs).forEach(API => { - const ipfsFixtures = path.join('./test', 'fixtures', `js-ipfs.zip`) +// Object.keys(testAPIs).forEach(API => { +// const ipfsFixtures = path.join('./test', 'fixtures', `js-ipfs.zip`) - describe(`orbit-db - Backward-Compatibility - Open & Load (${API})`, function () { - this.retries(1) // windows... - this.timeout(config.timeout) +// describe(`orbit-db - Backward-Compatibility - Open & Load (${API})`, function () { +// this.retries(1) // windows... +// this.timeout(config.timeout) - let ipfsd, ipfs, orbitdb, db, keystore +// let ipfsd, ipfs, orbitdb, db, keystore - before(async () => { - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - rmrf.sync(dbPath) +// before(async () => { +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// rmrf.sync(dbPath) - const zip = new Zip(ipfsFixtures) - await zip.extractAllToAsync(path.join('./test', 'fixtures'), true) +// const zip = new Zip(ipfsFixtures) +// await zip.extractAllToAsync(path.join('./test', 'fixtures'), true) - const filterFunc = (src, dest) => { - // windows has problems copying these files... - return !(src.includes('LOG') || src.includes('LOCK')) - } +// const filterFunc = (src, dest) => { +// // windows has problems copying these files... +// return !(src.includes('LOG') || src.includes('LOCK')) +// } - // copy data files to ipfs and orbitdb repos - await fs.copy(path.join(ipfsFixturesDir, 'blocks'), path.join(ipfsd.path, 'blocks')) - await fs.copy(path.join(ipfsFixturesDir, 'datastore'), path.join(ipfsd.path, 'datastore'), { filter: filterFunc }) +// // copy data files to ipfs and orbitdb repos +// await fs.copy(path.join(ipfsFixturesDir, 'blocks'), path.join(ipfsd.path, 'blocks')) +// await fs.copy(path.join(ipfsFixturesDir, 'datastore'), path.join(ipfsd.path, 'datastore'), { filter: filterFunc }) - const peerId = String((await ipfs.id()).id) - const store = await storage.createStore(path.join(dbPath, peerId, 'keys')) - keystore = new Keystore(store) +// const peerId = String((await ipfs.id()).id) +// const store = await storage.createStore(path.join(dbPath, peerId, 'keys')) +// keystore = new Keystore(store) - const identity = await Identities.createIdentity({ id: peerId, migrate: migrate(keyFixtures), keystore }) - orbitdb = await OrbitDB.createInstance(ipfs, { identity, keystore }) +// const identity = await Identities.createIdentity({ id: peerId, migrate: migrate(keyFixtures), keystore }) +// orbitdb = await OrbitDB.createInstance(ipfs, { identity, keystore }) - }) +// }) - after(async () => { - await keystore.close() - if (orbitdb) - await orbitdb.stop() +// after(async () => { +// await keystore.close() +// if (orbitdb) +// await orbitdb.stop() - if (ipfsd) - await stopIpfs(ipfsd) +// if (ipfsd) +// await stopIpfs(ipfsd) - rmrf.sync(ipfsFixturesDir) - rmrf.sync('./orbitdb') - }) +// rmrf.sync(ipfsFixturesDir) +// rmrf.sync('./orbitdb') +// }) - describe('Open & Load - V0 entries', function () { +// describe('Open & Load - V0 entries', function () { - before(async () => { - await fs.copy(dbFixturesDir, dbPath) - db = await orbitdb.open('/orbitdb/QmWDUfC4zcWJGgc9UHn1X3qQ5KZqBv4KCiCtjnpMmBT8JC/v0-db', { directory: dbPath, accessController: { type: 'legacy-ipfs', skipManifest: true } }) - const localFixtures = await db._cache.get('_localHeads') - const remoteFixtures = await db._cache.get('_remoteHeads') - await db._cache.set(db.localHeadsPath, localFixtures) - await db._cache.set(db.remoteHeadsPath, remoteFixtures) - await db.load() - }) +// before(async () => { +// await fs.copy(dbFixturesDir, dbPath) +// db = await orbitdb.open('/orbitdb/QmWDUfC4zcWJGgc9UHn1X3qQ5KZqBv4KCiCtjnpMmBT8JC/v0-db', { directory: dbPath, accessController: { type: 'legacy-ipfs', skipManifest: true } }) +// const localFixtures = await db._cache.get('_localHeads') +// const remoteFixtures = await db._cache.get('_remoteHeads') +// await db._cache.set(db.localHeadsPath, localFixtures) +// await db._cache.set(db.remoteHeadsPath, remoteFixtures) +// await db.load() +// }) - beforeEach(async () => { - if (process.platform === 'win32') { - // for some reason Windows does not load the database correctly at the first time. - // this is not a good solution but... it works. - await db.load() - } - }) +// beforeEach(async () => { +// if (process.platform === 'win32') { +// // for some reason Windows does not load the database correctly at the first time. +// // this is not a good solution but... it works. +// await db.load() +// } +// }) - after(async () => { - rmrf.sync(dbPath) - if (db) - await db.close() - }) +// after(async () => { +// rmrf.sync(dbPath) +// if (db) +// await db.close() +// }) - it('open v0 orbitdb address', async () => { - assert.notEqual(db, null) - }) +// it('open v0 orbitdb address', async () => { +// assert.notEqual(db, null) +// }) - it('database has the correct v0 address', async () => { - assert.equal(db.address.toString().indexOf('/orbitdb'), 0) - assert.equal(db.address.toString().indexOf('Qm'), 9) - assert.equal(db.address.toString().indexOf('v0-db'), 56) - }) +// it('database has the correct v0 address', async () => { +// assert.equal(db.address.toString().indexOf('/orbitdb'), 0) +// assert.equal(db.address.toString().indexOf('Qm'), 9) +// assert.equal(db.address.toString().indexOf('v0-db'), 56) +// }) - it('has the correct type', async () => { - assert.equal(db.type, 'feed') - }) +// it('has the correct type', async () => { +// assert.equal(db.type, 'feed') +// }) - it('database has the correct access-controller', async () => { - assert.equal(db.options.accessControllerAddress, '/ipfs/Qmc3S7aMSmH8oGmx7Zdp8UxVWcDyCq5o2H9qYFgT3GW6nM') - assert.equal(db.access.type, 'legacy-ipfs') - assert.strictEqual(db.access.write[0], '04b54f6ef529cd2dd2f9c6897a382c492222d42e57826269a38101ffe752aa07260ecd092a970d7eef08c4ddae2b7006ee25f07e4ab62fa5262ae3b51fdea29f78') - }) +// it('database has the correct access-controller', async () => { +// assert.equal(db.options.accessControllerAddress, '/ipfs/Qmc3S7aMSmH8oGmx7Zdp8UxVWcDyCq5o2H9qYFgT3GW6nM') +// assert.equal(db.access.type, 'legacy-ipfs') +// assert.strictEqual(db.access.write[0], '04b54f6ef529cd2dd2f9c6897a382c492222d42e57826269a38101ffe752aa07260ecd092a970d7eef08c4ddae2b7006ee25f07e4ab62fa5262ae3b51fdea29f78') +// }) - it('load v0 orbitdb address', async () => { - assert.equal(db.all.length, 3) - }) +// it('load v0 orbitdb address', async () => { +// assert.equal(db.all.length, 3) +// }) - it('allows migrated key to write', async () => { - const hash = await db.add({ thing: 'new addition' }) - const newEntries = db.all.filter(e => e.v > 0) - assert.equal(newEntries.length, 1) - assert.strictEqual(newEntries[0].hash, hash) - }) - }) +// it('allows migrated key to write', async () => { +// const hash = await db.add({ thing: 'new addition' }) +// const newEntries = db.all.filter(e => e.v > 0) +// assert.equal(newEntries.length, 1) +// assert.strictEqual(newEntries[0].hash, hash) +// }) +// }) - describe('Open & Load - V1 entries', function () { - const dbPath2 = './orbitdb/tests/v1' - const dbv1Fix = './test/fixtures/v1/QmZrWipUpBNx5VjBTESCeJBQuj4rWahZMz8CV8hBjdJAec/cache' - const v1Address = '/orbitdb/zdpuAqpKBwd7ojM77o3rRVKA1PAEQBnWoRASY3ugJ7zqnM6z7/v1-entries' - before(async () => { - await fs.copy(dbv1Fix, dbPath2) - db = await orbitdb.open(v1Address, { directory: dbPath2 }) - await db.load() - }) +// describe('Open & Load - V1 entries', function () { +// const dbPath2 = './orbitdb/tests/v1' +// const dbv1Fix = './test/fixtures/v1/QmZrWipUpBNx5VjBTESCeJBQuj4rWahZMz8CV8hBjdJAec/cache' +// const v1Address = '/orbitdb/zdpuAqpKBwd7ojM77o3rRVKA1PAEQBnWoRASY3ugJ7zqnM6z7/v1-entries' +// before(async () => { +// await fs.copy(dbv1Fix, dbPath2) +// db = await orbitdb.open(v1Address, { directory: dbPath2 }) +// await db.load() +// }) - beforeEach(async () => { - if (process.platform === 'win32') { - // for some reason Windows does not load the database correctly at the first time. - // this is not a good solution but... it works. - await db.load() - } - }) +// beforeEach(async () => { +// if (process.platform === 'win32') { +// // for some reason Windows does not load the database correctly at the first time. +// // this is not a good solution but... it works. +// await db.load() +// } +// }) - after(async () => { - rmrf.sync(dbPath2) - if (db) - await db.close() - }) +// after(async () => { +// rmrf.sync(dbPath2) +// if (db) +// await db.close() +// }) - it('open v1 orbitdb address', async () => { - assert.notEqual(db, null) - }) +// it('open v1 orbitdb address', async () => { +// assert.notEqual(db, null) +// }) - it('database has the correct v1 address', async () => { - assert.equal(db.address.toString().indexOf('/orbitdb'), 0) - assert.equal(db.address.toString().indexOf('zd'), 9) - assert.equal(db.address.toString().indexOf('v1-entries'), 59) - }) +// it('database has the correct v1 address', async () => { +// assert.equal(db.address.toString().indexOf('/orbitdb'), 0) +// assert.equal(db.address.toString().indexOf('zd'), 9) +// assert.equal(db.address.toString().indexOf('v1-entries'), 59) +// }) - it('has the correct type', async () => { - assert.equal(db.type, 'feed') - }) +// it('has the correct type', async () => { +// assert.equal(db.type, 'feed') +// }) - it('database has the correct access-controller', async () => { - assert.equal(db.access.type, 'ipfs') - assert.equal(db.options.accessControllerAddress, '/ipfs/zdpuAsYRtJLLLDibnmxWPzyRGJEqtjmJP27ppKWcLreNGGTFN') - assert.strictEqual(db.access.write[0], '*') - }) +// it('database has the correct access-controller', async () => { +// assert.equal(db.access.type, 'ipfs') +// assert.equal(db.options.accessControllerAddress, '/ipfs/zdpuAsYRtJLLLDibnmxWPzyRGJEqtjmJP27ppKWcLreNGGTFN') +// assert.strictEqual(db.access.write[0], '*') +// }) - it('load v1 orbitdb address', async () => { - assert.equal(db.all.length, 100) - }) +// it('load v1 orbitdb address', async () => { +// assert.equal(db.all.length, 100) +// }) - it('allows adding new entry', async () => { - const hash = await db.add('new entry') - const newEntries = db.all.filter(e => e.v > 1) - assert.equal(newEntries.length, 1) - assert.strictEqual(newEntries[0].hash, hash) - }) +// it('allows adding new entry', async () => { +// const hash = await db.add('new entry') +// const newEntries = db.all.filter(e => e.v > 1) +// assert.equal(newEntries.length, 1) +// assert.strictEqual(newEntries[0].hash, hash) +// }) - it('reopens db after adding new entry', async () => { - await db.close() - db = await orbitdb.open(v1Address, { directory: dbPath2 }) - assert.notEqual(db, null) - await db.load() - assert.equal(db.all.length, 101) - const newEntries = db.all.filter(e => e.v > 1) - assert.equal(newEntries.length, 1) - }) - }) - }) -}) +// it('reopens db after adding new entry', async () => { +// await db.close() +// db = await orbitdb.open(v1Address, { directory: dbPath2 }) +// assert.notEqual(db, null) +// await db.load() +// assert.equal(db.all.length, 101) +// const newEntries = db.all.filter(e => e.v > 1) +// assert.equal(newEntries.length, 1) +// }) +// }) +// }) +// }) diff --git a/test/write-permissions.test.js b/test/write-permissions.test.js index 352cd55..61fc5e2 100644 --- a/test/write-permissions.test.js +++ b/test/write-permissions.test.js @@ -1,214 +1,214 @@ -import assert from 'assert' -import rmrf from 'rimraf' -import path from 'path' -import OrbitDB from '../src/OrbitDB.js' +// import assert from 'assert' +// import rmrf from 'rimraf' +// import path from 'path' +// import OrbitDB from '../src/OrbitDB.js' -// Include test utilities -import { - config, - startIpfs, - stopIpfs, - testAPIs -} from 'orbit-db-test-utils' +// // Include test utilities +// import { +// config, +// startIpfs, +// stopIpfs, +// testAPIs +// } from 'orbit-db-test-utils' -import databases from './utils/databases.js' +// import databases from './utils/databases.js' -const dbPath = './orbitdb/tests/write-permissions' +// const dbPath = './orbitdb/tests/write-permissions' -Object.keys(testAPIs).forEach(API => { - describe(`orbit-db - Write Permissions (${API})`, function() { - this.timeout(20000) +// Object.keys(testAPIs).forEach(API => { +// describe(`orbit-db - Write Permissions (${API})`, function() { +// this.timeout(20000) - let ipfsd, ipfs, orbitdb1, orbitdb2 +// let ipfsd, ipfs, orbitdb1, orbitdb2 - before(async () => { - rmrf.sync(dbPath) - ipfsd = await startIpfs(API, config.daemon1) - ipfs = ipfsd.api - orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) - orbitdb2 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '2') }) - }) +// before(async () => { +// rmrf.sync(dbPath) +// ipfsd = await startIpfs(API, config.daemon1) +// ipfs = ipfsd.api +// orbitdb1 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '1') }) +// orbitdb2 = await OrbitDB.createInstance(ipfs, { directory: path.join(dbPath, '2') }) +// }) - after(async () => { - if(orbitdb1) - await orbitdb1.stop() +// after(async () => { +// if(orbitdb1) +// await orbitdb1.stop() - if(orbitdb2) - await orbitdb2.stop() +// if(orbitdb2) +// await orbitdb2.stop() - if (ipfsd) - await stopIpfs(ipfsd) - }) +// if (ipfsd) +// await stopIpfs(ipfsd) +// }) - describe('allows multiple peers to write to the databases', function() { - databases.forEach(async (database) => { - it(database.type + ' allows multiple writers', async () => { - let options = { - // Set write access for both clients - accessController: { - write: [ - orbitdb1.identity.id, - orbitdb2.identity.id - ] - } - } +// describe('allows multiple peers to write to the databases', function() { +// databases.forEach(async (database) => { +// it(database.type + ' allows multiple writers', async () => { +// let options = { +// // Set write access for both clients +// accessController: { +// write: [ +// orbitdb1.identity.id, +// orbitdb2.identity.id +// ] +// } +// } - const db1 = await database.create(orbitdb1, 'sync-test', options) - options = Object.assign({}, options, { sync: true }) - const db2 = await database.create(orbitdb2, db1.address.toString(), options) +// const db1 = await database.create(orbitdb1, 'sync-test', options) +// options = Object.assign({}, options, { sync: true }) +// const db2 = await database.create(orbitdb2, db1.address.toString(), options) - await database.tryInsert(db1) - await database.tryInsert(db2) +// await database.tryInsert(db1) +// await database.tryInsert(db2) - assert.deepEqual(database.getTestValue(db1), database.expectedValue) - assert.deepEqual(database.getTestValue(db2), database.expectedValue) +// assert.deepEqual(database.getTestValue(db1), database.expectedValue) +// assert.deepEqual(database.getTestValue(db2), database.expectedValue) - await db1.close() - await db2.close() - }) - }) - }) +// await db1.close() +// await db2.close() +// }) +// }) +// }) - describe('syncs databases', function() { - databases.forEach(async (database) => { - it(database.type + ' syncs', async () => { - let options = { - // Set write access for both clients - accessController: { - write: [ - orbitdb1.identity.id, - orbitdb2.identity.id - ] - } - } +// describe('syncs databases', function() { +// databases.forEach(async (database) => { +// it(database.type + ' syncs', async () => { +// let options = { +// // Set write access for both clients +// accessController: { +// write: [ +// orbitdb1.identity.id, +// orbitdb2.identity.id +// ] +// } +// } - const db1 = await database.create(orbitdb1, 'sync-test', options) - options = Object.assign({}, options, { sync: true }) - const db2 = await database.create(orbitdb2, db1.address.toString(), options) +// const db1 = await database.create(orbitdb1, 'sync-test', options) +// options = Object.assign({}, options, { sync: true }) +// const db2 = await database.create(orbitdb2, db1.address.toString(), options) - await database.tryInsert(db2) +// await database.tryInsert(db2) - assert.strictEqual(database.query(db1).length, 0) - db1.sync(db2._oplog.heads) +// assert.strictEqual(database.query(db1).length, 0) +// db1.sync(db2._oplog.heads) - return new Promise(resolve => { - setTimeout(async () => { - const value = database.getTestValue(db1) - assert.deepEqual(value, database.expectedValue) - await db1.close() - await db2.close() - resolve() - }, 300) - }) - }) - }) - }) +// return new Promise(resolve => { +// setTimeout(async () => { +// const value = database.getTestValue(db1) +// assert.deepEqual(value, database.expectedValue) +// await db1.close() +// await db2.close() +// resolve() +// }, 300) +// }) +// }) +// }) +// }) - describe('syncs databases that anyone can write to', function() { - databases.forEach(async (database) => { - it(database.type + ' syncs', async () => { - let options = { - // Set write permission for everyone - accessController: { - write: ['*'] - } - } +// describe('syncs databases that anyone can write to', function() { +// databases.forEach(async (database) => { +// it(database.type + ' syncs', async () => { +// let options = { +// // Set write permission for everyone +// accessController: { +// write: ['*'] +// } +// } - const db1 = await database.create(orbitdb1, 'sync-test-public-dbs', options) - options = Object.assign({}, options, { sync: true }) - const db2 = await database.create(orbitdb2, db1.address.toString(), options) +// const db1 = await database.create(orbitdb1, 'sync-test-public-dbs', options) +// options = Object.assign({}, options, { sync: true }) +// const db2 = await database.create(orbitdb2, db1.address.toString(), options) - await database.tryInsert(db2) +// await database.tryInsert(db2) - assert.strictEqual(database.query(db1).length, 0) - db1.sync(db2._oplog.heads) +// assert.strictEqual(database.query(db1).length, 0) +// db1.sync(db2._oplog.heads) - return new Promise(resolve => { - setTimeout(async () => { - const value = database.getTestValue(db1) - assert.deepEqual(value, database.expectedValue) - await db1.close() - await db2.close() - resolve() - }, 300) - }) - }) - }) - }) +// return new Promise(resolve => { +// setTimeout(async () => { +// const value = database.getTestValue(db1) +// assert.deepEqual(value, database.expectedValue) +// await db1.close() +// await db2.close() +// resolve() +// }, 300) +// }) +// }) +// }) +// }) - describe('doesn\'t sync if peer is not allowed to write to the database', function() { - databases.forEach(async (database) => { - it(database.type + ' doesn\'t sync', async () => { +// describe('doesn\'t sync if peer is not allowed to write to the database', function() { +// databases.forEach(async (database) => { +// it(database.type + ' doesn\'t sync', async () => { - let options = { - // Only peer 1 can write - accessController: { - write: [orbitdb1.identity.id] - } - } - let err - options = Object.assign({}, options, { path: path.join(dbPath, '/sync-test/1') }) - const db1 = await database.create(orbitdb1, 'write error test 1', options) - options = Object.assign({}, options, { path: path.join(dbPath, '/sync-test/2'), sync: true }) - const db2 = await database.create(orbitdb2, 'write error test 1', options) +// let options = { +// // Only peer 1 can write +// accessController: { +// write: [orbitdb1.identity.id] +// } +// } +// let err +// options = Object.assign({}, options, { path: path.join(dbPath, '/sync-test/1') }) +// const db1 = await database.create(orbitdb1, 'write error test 1', options) +// options = Object.assign({}, options, { path: path.join(dbPath, '/sync-test/2'), sync: true }) +// const db2 = await database.create(orbitdb2, 'write error test 1', options) - try { - // Catch replication event if the update from peer 2 got synced and into the database - db1.events.on('replicated', () => err = new Error('Shouldn\'t replicate!')) - // Try to update from peer 2, this shouldn't be allowed - await database.tryInsert(db2) - } catch (e) { - // Make sure peer 2's instance throws an error - err = e.toString() - } - assert.strictEqual(err, `Error: Could not append entry, key "${orbitdb2.identity.id}" is not allowed to write to the log`) +// try { +// // Catch replication event if the update from peer 2 got synced and into the database +// db1.events.on('replicated', () => err = new Error('Shouldn\'t replicate!')) +// // Try to update from peer 2, this shouldn't be allowed +// await database.tryInsert(db2) +// } catch (e) { +// // Make sure peer 2's instance throws an error +// err = e.toString() +// } +// assert.strictEqual(err, `Error: Could not append entry, key "${orbitdb2.identity.id}" is not allowed to write to the log`) - // Make sure nothing was added to the database - assert.strictEqual(database.query(db1).length, 0) +// // Make sure nothing was added to the database +// assert.strictEqual(database.query(db1).length, 0) - // Try to sync peer 1 with peer 2, this shouldn't produce anything - // at peer 1 (nothing was supposed to be added to the database by peer 2) - db1.sync(db2._oplog.heads) +// // Try to sync peer 1 with peer 2, this shouldn't produce anything +// // at peer 1 (nothing was supposed to be added to the database by peer 2) +// db1.sync(db2._oplog.heads) - return new Promise((resolve, reject) => { - setTimeout(async () => { - // Make sure nothing was added - assert.strictEqual(database.query(db1).length, 0) - await db1.close() - await db2.close() - if (!err) { - reject(new Error('tryInsert should throw an err')) - } else { - resolve() - } - }, 300) - }) - }) - }) - }) +// return new Promise((resolve, reject) => { +// setTimeout(async () => { +// // Make sure nothing was added +// assert.strictEqual(database.query(db1).length, 0) +// await db1.close() +// await db2.close() +// if (!err) { +// reject(new Error('tryInsert should throw an err')) +// } else { +// resolve() +// } +// }, 300) +// }) +// }) +// }) +// }) - describe('throws an error if peer is not allowed to write to the database', function() { - databases.forEach(async (database) => { - it(database.type + ' throws an error', async () => { - let options = { - // No write access (only creator of the database can write) - accessController: { - write: [] - } - } +// describe('throws an error if peer is not allowed to write to the database', function() { +// databases.forEach(async (database) => { +// it(database.type + ' throws an error', async () => { +// let options = { +// // No write access (only creator of the database can write) +// accessController: { +// write: [] +// } +// } - let err - try { - const db1 = await database.create(orbitdb1, 'write error test 2', options) - options = Object.assign({}, options, { sync: true }) - const db2 = await database.create(orbitdb2, db1.address.toString(), options) - await database.tryInsert(db2) - } catch (e) { - err = e.toString() - } - assert.strictEqual(err, `Error: Could not append entry, key "${orbitdb2.identity.id}" is not allowed to write to the log`) - }) - }) - }) - }) -}) +// let err +// try { +// const db1 = await database.create(orbitdb1, 'write error test 2', options) +// options = Object.assign({}, options, { sync: true }) +// const db2 = await database.create(orbitdb2, db1.address.toString(), options) +// await database.tryInsert(db2) +// } catch (e) { +// err = e.toString() +// } +// assert.strictEqual(err, `Error: Could not append entry, key "${orbitdb2.identity.id}" is not allowed to write to the log`) +// }) +// }) +// }) +// }) +// })