Mirroristas/orbitdb
2
0
Fork 0
mirror of https://github.com/orbitdb/orbitdb.git synced 2025-07-03 11:02:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove asyncawait dependency from OrbitDB completely

Browse Source
This commit is contained in:
haad 2016-04-12 19:49:04 +02:00
parent 5aa8d3e384
commit 940731a5ea
3 changed files with 561 additions and 556 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

60
src/OrbitDB.js
View File

@ -3,8 +3,6 @@
const Lazy = require('lazy.js'); const Lazy = require('lazy.js');
const EventEmitter = require('events').EventEmitter; const EventEmitter = require('events').EventEmitter;
const Promise = require('bluebird'); const Promise = require('bluebird');
const async = require('asyncawait/async');
const await = require('asyncawait/await');
const logger = require('orbit-common/lib/logger')("orbit-db.OrbitDB"); const logger = require('orbit-common/lib/logger')("orbit-db.OrbitDB");
const Log = require('ipfs-log'); const Log = require('ipfs-log');
const DBOperation = require('./db/Operation'); const DBOperation = require('./db/Operation');
@ -38,30 +36,21 @@ class OrbitDB {
} }
sync(channel, hash) { sync(channel, hash) {
console.log("--> Head:", hash) // console.log("--> Head:", hash)
if(hash && hash !== this.lastWrite && this._logs[channel]) { if(hash && hash !== this.lastWrite && this._logs[channel]) {
this.events[channel].emit('load', 'sync', channel); this.events[channel].emit('load', 'sync', channel);
const oldCount = this._logs[channel].items.length; const oldCount = this._logs[channel].items.length;
Log.fromIpfsHash(this._ipfs, hash).then((other) => { Log.fromIpfsHash(this._ipfs, hash).then((other) => {
this._logs[channel].join(other).then(() => { this._logs[channel].join(other).then(() => {
// Only emit the event if something was added // Only emit the event if something was added
const joinedCount = (this._logs[channel].items.length - oldCount); const joinedCount = this._logs[channel].items.length - oldCount;
console.log("JOIN", joinedCount);
if(joinedCount > 0) { if(joinedCount > 0) {
this.events[channel].emit('sync', channel, hash); this.events[channel].emit('sync', channel, hash);
Cache.set(channel, hash); Cache.set(channel, hash);
// Cache the payloads // Cache the payloads
const payloadHashes = other.items.map((f) => f.payload); this._cacheOperations(other)
Promise.map(payloadHashes, (f) => { .then(() => this.events[channel].emit('loaded', 'sync', channel))
return OrbitDB.fetchPayload(this._ipfs, f); .catch((e) => this.events[channel].emit('error', e.message));
}, { concurrency: 1 }).then((r) => {
r.forEach((f) => this._cached.push(f));
this.events[channel].emit('loaded', 'sync', channel);
}).catch((e) => {
this.events[channel].emit('error', e.message);
});
} else { } else {
this.events[channel].emit('loaded', 'sync', channel); this.events[channel].emit('loaded', 'sync', channel);
} }
@ -82,17 +71,7 @@ class OrbitDB {
if(!this._cached) this._cached = []; if(!this._cached) this._cached = [];
const operations = Lazy(this._logs[channel].items) const operations = Lazy(this._logs[channel].items);
// .map((f) => {
// let res = Lazy(this._cached).findWhere({ hash: f.payload });
// if(!res) {
// const payload = await(OrbitDB.fetchPayload(this._ipfs, f.payload));
// this._cached.push(payload);
// res = payload;
// }
// return res;
// })
const amount = opts.limit ? (opts.limit > -1 ? opts.limit : this._logs[channel].items.length) : 1; // Return 1 if no limit is provided const amount = opts.limit ? (opts.limit > -1 ? opts.limit : this._logs[channel].items.length) : 1; // Return 1 if no limit is provided
let result = []; let result = [];
@ -101,13 +80,16 @@ class OrbitDB {
// Key-Value, search latest key first // Key-Value, search latest key first
result = this._read(operations.reverse(), opts.key, 1, true).map((f) => f.value); result = this._read(operations.reverse(), opts.key, 1, true).map((f) => f.value);
} else if(opts.gt || opts.gte) { } else if(opts.gt || opts.gte) {
// console.log(1)
// Greater than case // Greater than case
result = this._read(operations, opts.gt ? opts.gt : opts.gte, amount, opts.gte ? opts.gte : false) result = this._read(operations, opts.gt ? opts.gt : opts.gte, amount, opts.gte ? opts.gte : false)
} else { } else {
// console.log(2)
// Lower than and lastN case, search latest first by reversing the sequence // Lower than and lastN case, search latest first by reversing the sequence
result = this._read(operations.reverse(), opts.lt ? opts.lt : opts.lte, amount, opts.lte || !opts.lt).reverse() result = this._read(operations.reverse(), opts.lt ? opts.lt : opts.lte, amount, opts.lte || !opts.lt).reverse()
} }
// console.log("++", result.toArray())
if(opts.reverse) result.reverse(); if(opts.reverse) result.reverse();
const res = result.toArray(); const res = result.toArray();
// console.log("--> Found", res.length, "items"); // console.log("--> Found", res.length, "items");
@ -145,6 +127,7 @@ class OrbitDB {
// Last-Write-Wins, ie. use only the first occurance of the key // Last-Write-Wins, ie. use only the first occurance of the key
let handled = []; let handled = [];
const _createLWWSet = (item) => { const _createLWWSet = (item) => {
// console.log("-->", item, handled)
if(Lazy(handled).indexOf(item.key) === -1) { if(Lazy(handled).indexOf(item.key) === -1) {
handled.push(item.key); handled.push(item.key);
if(DBOperation.Types.isInsert(item.op)) if(DBOperation.Types.isInsert(item.op))
@ -154,9 +137,17 @@ class OrbitDB {
}; };
// Find the items from the sequence (list of operations) // Find the items from the sequence (list of operations)
// console.log("333", this._cached)
return sequence return sequence
// .map((f) => await(OrbitDB.fetchPayload(this._ipfs, f.payload))) // IO - fetch the actual OP from ipfs. consider merging with LL. .map((f) => Lazy(this._cached).find((e) => {
// console.log("e", e, f)
return e.hash === f.payload
}))
.skipWhile((f) => key && f.key !== key) // Drop elements until we have the first one requested .skipWhile((f) => key && f.key !== key) // Drop elements until we have the first one requested
.map((f) => {
// console.log("f", f, "key", key);
return f;
})
.map(_createLWWSet) // Return items as LWW (ignore values after the first found) .map(_createLWWSet) // Return items as LWW (ignore values after the first found)
.compact() // Remove nulls .compact() // Remove nulls
.drop(inclusive ? 0 : 1) // Drop the 'gt/lt' item, include 'gte/lte' item .drop(inclusive ? 0 : 1) // Drop the 'gt/lt' item, include 'gte/lte' item
@ -185,6 +176,19 @@ class OrbitDB {
}); });
} }
// Cache DB operation entries in memory from a log
_cacheOperations(log) {
return new Promise((resolve, reject) => {
const payloadHashes = log.items.map((f) => f.payload);
Promise.map(payloadHashes, (f) => OrbitDB.fetchPayload(this._ipfs, f), { concurrency: 4 })
.then((payloads) => {
payloads.forEach((f) => this._cached.push(f));
resolve();
})
.catch(reject);
});
}
static fetchPayload(ipfs, hash) { static fetchPayload(ipfs, hash) {
return new Promise((resolve, reject) => { return new Promise((resolve, reject) => {
ipfs.object.get(hash) ipfs.object.get(hash)

893
test/client.test.js
View File

@ -1,524 +1,527 @@
// 'use strict'; 'use strict';
// const _ = require('lodash'); const _ = require('lodash');
// const assert = require('assert'); const path = require('path');
// const async = require('asyncawait/async'); const assert = require('assert');
// const await = require('asyncawait/await'); const async = require('asyncawait/async');
// const OrbitClient = require('../src/Client'); const await = require('asyncawait/await');
const OrbitClient = require('../src/Client');
// // Mute logging // Mute logging
// // require('log4js').setGlobalLogLevel('ERROR'); require('log4js').setGlobalLogLevel('ERROR');
// // Orbit // Orbit
// const username = 'testrunner'; const username = 'testrunner';
// const password = ''; const password = '';
// describe('Orbit Client', function() { describe('Orbit Client', function() {
// this.timeout(15000); this.timeout(2000);
// let client, db; let client, db;
// let channel = 'abcdefgh'; let channel = 'abcdefgh';
const cacheFile = path.join(process.cwd(), '/test', 'orbit-db-test-cache.json');
// before(async((done) => { before(async((done) => {
// client = await(OrbitClient.connect('localhost', 3333, username, password, null, { allowOffline: true })); client = await(OrbitClient.connect('localhost', 3333, username, password, null, { allowOffline: true }));
// db = client.channel(channel, '', false); db = client.channel(channel, '', false);
// db.delete(); db.delete();
// done(); done();
// })); }));
// after(() => { after(() => {
// if(db) db.delete(); if(db) db.delete();
// if(client) client.disconnect(); if(client) client.disconnect();
// }); });
// describe('Add events', function() { describe('Add events', function() {
// beforeEach(() => { beforeEach(() => {
// db.delete(); db.delete();
// }); });
// it('adds an item to an empty channel', async((done) => { it('adds an item to an empty channel', async((done) => {
// const head = await(db.add('hello')); const head = await(db.add('hello'));
// assert.notEqual(head, null); assert.notEqual(head, null);
// assert.equal(head.startsWith('Qm'), true); assert.equal(head.startsWith('Qm'), true);
// assert.equal(head.length, 46); assert.equal(head.length, 46);
// done(); done();
// })); }));
// it('adds a new item to a channel with one item', async((done) => { it('adds a new item to a channel with one item', async((done) => {
// const head = db.iterator().collect(); const head = db.iterator().collect();
// const second = await(db.add('hello')); const second = await(db.add('hello'));
// assert.notEqual(second, null); assert.notEqual(second, null);
// assert.notEqual(second, head); assert.notEqual(second, head);
// assert.equal(second.startsWith('Qm'), true); assert.equal(second.startsWith('Qm'), true);
// assert.equal(second.length, 46); assert.equal(second.length, 46);
// done(); done();
// })); }));
// it('adds five items', async((done) => { it('adds five items', async((done) => {
// for(let i = 0; i < 5; i ++) { for(let i = 0; i < 5; i ++) {
// let hash = await(db.add('hello')); let hash = await(db.add('hello'));
// assert.notEqual(hash, null); assert.notEqual(hash, null);
// assert.equal(hash.startsWith('Qm'), true); assert.equal(hash.startsWith('Qm'), true);
// assert.equal(hash.length, 46); assert.equal(hash.length, 46);
// } }
// done(); done();
// })); }));
// it('adds an item that is > 256 bytes', async((done) => { it('adds an item that is > 256 bytes', async((done) => {
// let msg = new Buffer(1024); let msg = new Buffer(1024);
// msg.fill('a') msg.fill('a')
// const hash = await(db.add(msg.toString())); const hash = await(db.add(msg.toString()));
// assert.notEqual(hash, null); assert.notEqual(hash, null);
// assert.equal(hash.startsWith('Qm'), true); assert.equal(hash.startsWith('Qm'), true);
// assert.equal(hash.length, 46); assert.equal(hash.length, 46);
// done(); done();
// })); }));
// }); });
// describe('Delete events', function() { describe('Delete events', function() {
// beforeEach(() => { beforeEach(() => {
// db.delete(); db.delete();
// const items = db.iterator().collect(); // const items = db.iterator().collect();
// assert.equal(items.length, 0); // assert.equal(items.length, 0);
// }); });
// it('deletes an item when only one item in the database', async((done) => { it('deletes an item when only one item in the database', async((done) => {
// const head = await(db.add('hello1')); const head = await(db.add('hello1'));
// let item = db.iterator().collect(); let item = db.iterator().collect();
// const delop = await(db.del(head)); const delop = await(db.del(head));
// const items = db.iterator().collect(); const items = db.iterator().collect();
// assert.equal(delop.startsWith('Qm'), true);
// assert.equal(items.length, 0);
// done();
// }));
// it('deletes an item when two items in the database', async((done) => { assert.equal(delop.startsWith('Qm'), true);
// await(db.add('hello1')); assert.equal(items.length, 0);
// const head = await(db.add('hello2')); done();
// await(db.del(head)); }));
// const items = db.iterator().collect();
// assert.equal(items.length, 1);
// assert.equal(items[0].value, 'hello1');
// done();
// }));
// it('deletes an item between adds', async((done) => { it('deletes an item when two items in the database', async((done) => {
// const head = await(db.add('hello1')); await(db.add('hello1'));
// await(db.add('hello2')); const head = await(db.add('hello2'));
// db.del(head); await(db.del(head));
// await(db.add('hello3')); const items = db.iterator().collect();
// const items = db.iterator().collect(); assert.equal(items.length, 1);
// assert.equal(items.length, 1); assert.equal(items[0].value, 'hello1');
// assert.equal(items[0].key.startsWith('Qm'), true); done();
// assert.equal(items[0].hash.startsWith('Qm'), true); }));
// assert.equal(items[0].value, 'hello3');
// done();
// }));
// });
// describe('Iterator', function() { it('deletes an item between adds', async((done) => {
// let items = []; const head = await(db.add('hello1'));
// const itemCount = 5; await(db.add('hello2'));
db.del(head);
await(db.add('hello3'));
const items = db.iterator().collect();
assert.equal(items.length, 1);
assert.equal(items[0].key.startsWith('Qm'), true);
assert.equal(items[0].hash.startsWith('Qm'), true);
assert.equal(items[0].value, 'hello3');
done();
}));
});
// beforeEach(async((done) => { describe('Iterator', function() {
// items = []; let items = [];
// db.delete(); const itemCount = 5;
// for(let i = 0; i < itemCount; i ++) {
// const hash = await(db.add('hello' + i));
// items.push(hash);
// }
// done();
// }));
// describe('Defaults', function() { beforeEach(async((done) => {
// it('returns an iterator', async((done) => { items = [];
// const iter = db.iterator(); db.delete();
// const next = iter.next().value; for(let i = 0; i < itemCount; i ++) {
// assert.notEqual(iter, null); const hash = await(db.add('hello' + i));
// assert.notEqual(next, null); items.push(hash);
// done(); }
// })); done();
}));
// it('returns an item with the correct structure', async((done) => { describe('Defaults', function() {
// const iter = db.iterator(); it('returns an iterator', async((done) => {
// const next = iter.next().value; const iter = db.iterator();
// assert.notEqual(next, null); const next = iter.next().value;
// assert.notEqual(next.key, null); assert.notEqual(iter, null);
// assert.equal(next.key.startsWith('Qm'), true); assert.notEqual(next, null);
// assert.equal(next.hash.startsWith('Qm'), true); done();
// assert.equal(next.value, 'hello4'); }));
// done();
// }));
// it('implements Iterator interface', async((done) => { it('returns an item with the correct structure', async((done) => {
// const iter = db.iterator({ limit: -1 }); const iter = db.iterator();
// let messages = []; const next = iter.next().value;
assert.notEqual(next, null);
assert.notEqual(next.key, null);
assert.equal(next.key.startsWith('Qm'), true);
assert.equal(next.hash.startsWith('Qm'), true);
assert.equal(next.value, 'hello4');
done();
}));
// for(let i of iter) it('implements Iterator interface', async((done) => {
// messages.push(i.key); const iter = db.iterator({ limit: -1 });
let messages = [];
// assert.equal(messages.length, items.length); for(let i of iter)
// done(); messages.push(i.key);
// }));
// it('returns 1 item as default', async((done) => { assert.equal(messages.length, items.length);
// const iter = db.iterator(); done();
// const first = iter.next().value; }));
// const second = iter.next().value;
// assert.equal(first.key, items[items.length - 1]);
// assert.equal(second, null);
// assert.equal(first.value, 'hello4');
// done();
// }));
// });
// describe('Collect', function() { it('returns 1 item as default', async((done) => {
// it('returns all items', async((done) => { const iter = db.iterator();
// const messages = db.iterator({ limit: -1 }).collect(); const first = iter.next().value;
// assert.equal(messages.length, items.length); const second = iter.next().value;
// assert.equal(messages[0].value, 'hello0'); assert.equal(first.key, items[items.length - 1]);
// assert.equal(messages[messages.length - 1].value, 'hello4'); assert.equal(second, null);
// done(); assert.equal(first.value, 'hello4');
// })); done();
}));
});
// it('returns 1 item', async((done) => { describe('Collect', function() {
// const messages = db.iterator().collect(); it('returns all items', async((done) => {
// assert.equal(messages.length, 1); const messages = db.iterator({ limit: -1 }).collect();
// done(); assert.equal(messages.length, items.length);
// })); assert.equal(messages[0].value, 'hello0');
assert.equal(messages[messages.length - 1].value, 'hello4');
done();
}));
// it('returns 3 items', async((done) => { it('returns 1 item', async((done) => {
// const messages = db.iterator({ limit: 3 }).collect(); const messages = db.iterator().collect();
// assert.equal(messages.length, 3); assert.equal(messages.length, 1);
// done(); done();
// })); }));
// });
// describe('Options: limit', function() { it('returns 3 items', async((done) => {
// it('returns 1 item when limit is 0', async((done) => { const messages = db.iterator({ limit: 3 }).collect();
// const iter = db.iterator({ limit: 1 }); assert.equal(messages.length, 3);
// const first = iter.next().value; done();
// const second = iter.next().value; }));
// assert.equal(first.key, _.last(items)); });
// assert.equal(second, null);
// done();
// }));
// it('returns 1 item when limit is 1', async((done) => { describe('Options: limit', function() {
// const iter = db.iterator({ limit: 1 }); it('returns 1 item when limit is 0', async((done) => {
// const first = iter.next().value; const iter = db.iterator({ limit: 1 });
// const second = iter.next().value; const first = iter.next().value;
// assert.equal(first.key, _.last(items)); const second = iter.next().value;
// assert.equal(second, null); assert.equal(first.key, _.last(items));
// done(); assert.equal(second, null);
// })); done();
}));
// it('returns 3 items', async((done) => { it('returns 1 item when limit is 1', async((done) => {
// const iter = db.iterator({ limit: 3 }); const iter = db.iterator({ limit: 1 });
// const first = iter.next().value; const first = iter.next().value;
// const second = iter.next().value; const second = iter.next().value;
// const third = iter.next().value; assert.equal(first.key, _.last(items));
// const fourth = iter.next().value; assert.equal(second, null);
// assert.equal(first.key, items[items.length - 3]); done();
// assert.equal(second.key, items[items.length - 2]); }));
// assert.equal(third.key, items[items.length - 1]);
// assert.equal(fourth, null);
// done();
// }));
// it('returns all items', async((done) => { it('returns 3 items', async((done) => {
// const messages = db.iterator({ limit: -1 }) const iter = db.iterator({ limit: 3 });
// .collect() const first = iter.next().value;
// .map((e) => e.key); const second = iter.next().value;
const third = iter.next().value;
const fourth = iter.next().value;
assert.equal(first.key, items[items.length - 3]);
assert.equal(second.key, items[items.length - 2]);
assert.equal(third.key, items[items.length - 1]);
assert.equal(fourth, null);
done();
}));
// messages.reverse(); it('returns all items', async((done) => {
// assert.equal(messages.length, items.length); const messages = db.iterator({ limit: -1 })
// assert.equal(messages[0], items[items.length - 1]); .collect()
// done(); .map((e) => e.key);
// }));
// it('returns all items when limit is bigger than -1', async((done) => { messages.reverse();
// const messages = db.iterator({ limit: -300 }) assert.equal(messages.length, items.length);
// .collect() assert.equal(messages[0], items[items.length - 1]);
// .map((e) => e.key); done();
}));
// assert.equal(messages.length, items.length); it('returns all items when limit is bigger than -1', async((done) => {
// assert.equal(messages[0], items[0]); const messages = db.iterator({ limit: -300 })
// done(); .collect()
// })); .map((e) => e.key);
// it('returns all items when limit is bigger than number of items', async((done) => { assert.equal(messages.length, items.length);
// const messages = db.iterator({ limit: 300 }) assert.equal(messages[0], items[0]);
// .collect() done();
// .map((e) => e.key); }));
// assert.equal(messages.length, items.length); it('returns all items when limit is bigger than number of items', async((done) => {
// assert.equal(messages[0], items[0]); const messages = db.iterator({ limit: 300 })
// done(); .collect()
// })); .map((e) => e.key);
// });
// describe('Options: reverse', function() { assert.equal(messages.length, items.length);
// it('returns all items reversed', async((done) => { assert.equal(messages[0], items[0]);
// const messages = db.iterator({ limit: -1, reverse: true }) done();
// .collect() }));
// .map((e) => e.key); });
// assert.equal(messages.length, items.length); describe('Options: reverse', function() {
// assert.equal(messages[0], items[0]); it('returns all items reversed', async((done) => {
// done(); const messages = db.iterator({ limit: -1, reverse: true })
// })); .collect()
// }); .map((e) => e.key);
// describe('Option: ranges', function() { assert.equal(messages.length, items.length);
// describe('gt & gte', function() { assert.equal(messages[0], items[0]);
// it('returns 1 item when gte is the head', async((done) => { done();
// const messages = db.iterator({ gte: _.last(items), limit: -1 }) }));
// .collect() });
// .map((e) => e.key);
// assert.equal(messages.length, 1); describe('Option: ranges', function() {
// assert.equal(messages[0], _.last(items)); describe('gt & gte', function() {
// done(); it('returns 1 item when gte is the head', async((done) => {
// })); const messages = db.iterator({ gte: _.last(items), limit: -1 })
.collect()
.map((e) => e.key);
// it('returns 0 items when gt is the head', async((done) => { assert.equal(messages.length, 1);
// const messages = db.iterator({ gt: _.last(items) }).collect(); assert.equal(messages[0], _.last(items));
// assert.equal(messages.length, 0); done();
// done(); }));
// }));
// it('returns 2 item when gte is defined', async((done) => { it('returns 0 items when gt is the head', async((done) => {
// const gte = items[items.length - 2]; const messages = db.iterator({ gt: _.last(items) }).collect();
// const messages = db.iterator({ gte: gte, limit: -1 }) assert.equal(messages.length, 0);
// .collect() done();
// .map((e) => e.key); }));
// assert.equal(messages.length, 2); it('returns 2 item when gte is defined', async((done) => {
// assert.equal(messages[0], items[items.length - 2]); const gte = items[items.length - 2];
// assert.equal(messages[1], items[items.length - 1]); const messages = db.iterator({ gte: gte, limit: -1 })
// done(); .collect()
// })); .map((e) => e.key);
// it('returns all items when gte is the root item', async((done) => { assert.equal(messages.length, 2);
// const messages = db.iterator({ gte: items[0], limit: -1 }) assert.equal(messages[0], items[items.length - 2]);
// .collect() assert.equal(messages[1], items[items.length - 1]);
// .map((e) => e.key); done();
}));
// assert.equal(messages.length, items.length); it('returns all items when gte is the root item', async((done) => {
// assert.equal(messages[0], items[0]); const messages = db.iterator({ gte: items[0], limit: -1 })
// assert.equal(messages[messages.length - 1], _.last(items)); .collect()
// done(); .map((e) => e.key);
// }));
// it('returns items when gt is the root item', async((done) => { assert.equal(messages.length, items.length);
// const messages = db.iterator({ gt: items[0], limit: -1 }) assert.equal(messages[0], items[0]);
// .collect() assert.equal(messages[messages.length - 1], _.last(items));
// .map((e) => e.key); done();
}));
// assert.equal(messages.length, itemCount - 1); it('returns items when gt is the root item', async((done) => {
// assert.equal(messages[0], items[1]); const messages = db.iterator({ gt: items[0], limit: -1 })
// assert.equal(messages[3], _.last(items)); .collect()
// done(); .map((e) => e.key);
// }));
// it('returns items when gt is defined', async((done) => { assert.equal(messages.length, itemCount - 1);
// const messages = db.iterator({ limit: -1}) assert.equal(messages[0], items[1]);
// .collect() assert.equal(messages[3], _.last(items));
// .map((e) => e.key); done();
}));
// const gt = messages[2]; it('returns items when gt is defined', async((done) => {
const messages = db.iterator({ limit: -1})
.collect()
.map((e) => e.key);
// const messages2 = db.iterator({ gt: gt, limit: 100 }) const gt = messages[2];
// .collect()
// .map((e) => e.key);
// assert.equal(messages2.length, 2); const messages2 = db.iterator({ gt: gt, limit: 100 })
// assert.equal(messages2[0], messages[messages.length - 2]); .collect()
// assert.equal(messages2[1], messages[messages.length - 1]); .map((e) => e.key);
// done();
// }));
// });
// describe('lt & lte', function() { assert.equal(messages2.length, 2);
// it('returns one item after head when lt is the head', async((done) => { assert.equal(messages2[0], messages[messages.length - 2]);
// const messages = db.iterator({ lt: _.last(items) }) assert.equal(messages2[1], messages[messages.length - 1]);
// .collect() done();
// .map((e) => e.key); }));
});
// assert.equal(messages.length, 1); describe('lt & lte', function() {
// assert.equal(messages[0], items[items.length - 2]); it('returns one item after head when lt is the head', async((done) => {
// done(); const messages = db.iterator({ lt: _.last(items) })
// })); .collect()
.map((e) => e.key);
// it('returns all items when lt is head and limit is -1', async((done) => { assert.equal(messages.length, 1);
// const messages = db.iterator({ lt: _.last(items), limit: -1 }) assert.equal(messages[0], items[items.length - 2]);
// .collect() done();
// .map((e) => e.key); }));
// assert.equal(messages.length, items.length - 1); it('returns all items when lt is head and limit is -1', async((done) => {
// assert.equal(messages[0], items[0]); const messages = db.iterator({ lt: _.last(items), limit: -1 })
// assert.equal(messages[messages.length - 1], items[items.length - 2]); .collect()
// done(); .map((e) => e.key);
// }));
// it('returns 3 items when lt is head and limit is 3', async((done) => { assert.equal(messages.length, items.length - 1);
// const messages = db.iterator({ lt: _.last(items), limit: 3 }) assert.equal(messages[0], items[0]);
// .collect() assert.equal(messages[messages.length - 1], items[items.length - 2]);
// .map((e) => e.key); done();
}));
// assert.equal(messages.length, 3); it('returns 3 items when lt is head and limit is 3', async((done) => {
// assert.equal(messages[0], items[items.length - 4]); const messages = db.iterator({ lt: _.last(items), limit: 3 })
// assert.equal(messages[2], items[items.length - 2]); .collect()
// done(); .map((e) => e.key);
// }));
// it('returns null when lt is the root item', async((done) => { assert.equal(messages.length, 3);
// const messages = db.iterator({ lt: items[0] }).collect(); assert.equal(messages[0], items[items.length - 4]);
// assert.equal(messages.length, 0); assert.equal(messages[2], items[items.length - 2]);
// done(); done();
// })); }));
// it('returns one item when lte is the root item', async((done) => { it('returns null when lt is the root item', async((done) => {
// const messages = db.iterator({ lte: items[0] }) const messages = db.iterator({ lt: items[0] }).collect();
// .collect() assert.equal(messages.length, 0);
// .map((e) => e.key); done();
}));
// assert.equal(messages.length, 1); it('returns one item when lte is the root item', async((done) => {
// assert.equal(messages[0], items[0]); const messages = db.iterator({ lte: items[0] })
// done(); .collect()
// })); .map((e) => e.key);
// it('returns all items when lte is the head', async((done) => { assert.equal(messages.length, 1);
// const messages = db.iterator({ lte: _.last(items), limit: -1 }) assert.equal(messages[0], items[0]);
// .collect() done();
// .map((e) => e.key); }));
// assert.equal(messages.length, itemCount); it('returns all items when lte is the head', async((done) => {
// assert.equal(messages[0], items[0]); const messages = db.iterator({ lte: _.last(items), limit: -1 })
// assert.equal(messages[4], _.last(items)); .collect()
// done(); .map((e) => e.key);
// }));
// it('returns 3 items when lte is the head', async((done) => { assert.equal(messages.length, itemCount);
// const messages = db.iterator({ lte: _.last(items), limit: 3 }) assert.equal(messages[0], items[0]);
// .collect() assert.equal(messages[4], _.last(items));
// .map((e) => e.key); done();
}));
// assert.equal(messages.length, 3); it('returns 3 items when lte is the head', async((done) => {
// assert.equal(messages[0], items[items.length - 3]); const messages = db.iterator({ lte: _.last(items), limit: 3 })
// assert.equal(messages[1], items[items.length - 2]); .collect()
// assert.equal(messages[2], _.last(items)); .map((e) => e.key);
// done();
// }));
// });
// });
// });
// describe('Delete', function() { assert.equal(messages.length, 3);
// it('deletes a channel from the local database', () => { assert.equal(messages[0], items[items.length - 3]);
// const result = db.delete(); assert.equal(messages[1], items[items.length - 2]);
// assert.equal(result, true); assert.equal(messages[2], _.last(items));
// const iter = db.iterator(); done();
// assert.equal(iter.next().value, null); }));
// }); });
// }); });
});
// describe('Key-Value Store', function() { describe('Delete', function() {
// before(() => { it('deletes a channel from the local database', () => {
// db.delete(); const result = db.delete();
// }); assert.equal(result, true);
const iter = db.iterator();
assert.equal(iter.next().value, null);
});
});
// afterEach(() => { describe('Key-Value Store', function() {
// db.delete(); before(() => {
// }); db.delete();
});
// it('put', async((done) => { afterEach(() => {
// await(db.put('key1', 'hello!')); db.delete();
// let all = db.iterator().collect(); });
// assert.equal(all.length, 1);
// assert.equal(all[0].hash.startsWith('Qm'), true);
// assert.equal(all[0].key, 'key1');
// assert.notEqual(all[0].meta, null);
// done();
// }));
// it('get', async((done) => { it('put', async((done) => {
// await(db.put('key1', 'hello!')); await(db.put('key1', 'hello!'));
// const value = db.get('key1'); let all = db.iterator().collect();
// assert.equal(value, 'hello!'); assert.equal(all.length, 1);
// done(); assert.equal(all[0].hash.startsWith('Qm'), true);
// })); assert.equal(all[0].key, 'key1');
assert.notEqual(all[0].meta, null);
done();
}));
// it('put updates a value', async((done) => { it('get', async((done) => {
// await(db.put('key1', 'hello!')); await(db.put('key1', 'hello!'));
// await(db.put('key1', 'hello again')); const value = db.get('key1');
// const value = db.get('key1'); assert.equal(value, 'hello!');
// assert.equal(value, 'hello again'); done();
// done(); }));
// }));
// it('deletes a key', async((done) => { it('put updates a value', async((done) => {
// await(db.put('key1', 'hello!')); await(db.put('key1', 'hello!'));
// await(db.del('key1')); await(db.put('key1', 'hello again'));
// const value = db.get('key1'); const value = db.get('key1');
// assert.equal(value, null); assert.equal(value, 'hello again');
// done(); done();
// })); }));
// it('deletes a key after multiple updates', async((done) => { it('deletes a key', async((done) => {
// await(db.put('key1', 'hello1')); await(db.put('key1', 'hello!'));
// await(db.put('key1', 'hello2')); await(db.del('key1'));
// await(db.put('key1', 'hello3')); const value = db.get('key1');
// await(db.del('key1')); assert.equal(value, null);
// const value = db.get('key1'); done();
// assert.equal(value, null); }));
// done();
// }));
// it('put - multiple keys', async((done) => { it('deletes a key after multiple updates', async((done) => {
// await(db.put('key1', 'hello1')); await(db.put('key1', 'hello1'));
// await(db.put('key2', 'hello2')); await(db.put('key1', 'hello2'));
// await(db.put('key3', 'hello3')); await(db.put('key1', 'hello3'));
// const all = db.iterator().collect(); await(db.del('key1'));
// assert.equal(all.length, 1); const value = db.get('key1');
// done(); assert.equal(value, null);
// })); done();
}));
// it('get - multiple keys', async((done) => { it('put - multiple keys', async((done) => {
// await(db.put('key1', 'hello1')); await(db.put('key1', 'hello1'));
// await(db.put('key2', 'hello2')); await(db.put('key2', 'hello2'));
// await(db.put('key3', 'hello3')); await(db.put('key3', 'hello3'));
// const v1 = db.get('key1'); const all = db.iterator().collect();
// const v2 = db.get('key2'); assert.equal(all.length, 1);
// const v3 = db.get('key3'); done();
// assert.equal(v1, 'hello1'); }));
// assert.equal(v2, 'hello2');
// assert.equal(v3, 'hello3');
// done();
// }));
// it('get - integer value', async((done) => { it('get - multiple keys', async((done) => {
// await(db.put('key1', 123)); await(db.put('key1', 'hello1'));
// const v1 = db.get('key1'); await(db.put('key2', 'hello2'));
// assert.equal(v1, 123); await(db.put('key3', 'hello3'));
// done(); 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');
done();
}));
// it('get - object value', async((done) => { it('get - integer value', async((done) => {
// const val = { one: 'first', two: 2 }; await(db.put('key1', 123));
// await(db.put('key1', val)); const v1 = db.get('key1');
// const v1 = db.get('key1'); assert.equal(v1, 123);
// assert.equal(_.isEqual(v1, val), true); done();
// done(); }));
// }));
// it('get - array value', async((done) => { it('get - object value', async((done) => {
// const val = [1, 2, 3, 4, 5]; const val = { one: 'first', two: 2 };
// await(db.put('key1', val)); await(db.put('key1', val));
// const v1 = db.get('key1'); const v1 = db.get('key1');
// assert.equal(_.isEqual(v1, val), true); assert.equal(_.isEqual(v1, val), true);
// done(); done();
// })); }));
// });
// }); it('get - array value', async((done) => {
const val = [1, 2, 3, 4, 5];
await(db.put('key1', val));
const v1 = db.get('key1');
assert.equal(_.isEqual(v1, val), true);
done();
}));
});
});

6
test/orbit-db.test.js
View File

@ -12,7 +12,7 @@ const OrbitDB = require('../src/OrbitDB');
const Log = require('ipfs-log'); const Log = require('ipfs-log');
// Mute logging // Mute logging
// require('log4js').setGlobalLogLevel('ERROR'); require('log4js').setGlobalLogLevel('ERROR');
// Orbit // Orbit
const username = 'testrunner'; const username = 'testrunner';
@ -152,8 +152,6 @@ describe('OrbitDB', function() {
})); }));
it('doesn\'t emit \'sync\' event if items weren\'t merged', async((done) => { it('doesn\'t emit \'sync\' event if items weren\'t merged', async((done) => {
const h1 = await(Log.getIpfsHash(ipfs, log));
console.log(h1, otherLogHash)
db._logs[channel] = log; db._logs[channel] = log;
db.events[channel].on('sync', (channelName, hash) => { db.events[channel].on('sync', (channelName, hash) => {
assert.equal(false, true); assert.equal(false, true);
@ -165,7 +163,7 @@ describe('OrbitDB', function() {
}); });
describe('cache payloads', function() { describe('cache payloads', function() {
it('caches payloads', (done) => { it('fetches payloads', (done) => {
assert.equal(db._cached.length, 0); assert.equal(db._cached.length, 0);
db.events[channel].on('loaded', (src, channelName) => { db.events[channel].on('loaded', (src, channelName) => {
assert.equal(db._cached.length, 3); assert.equal(db._cached.length, 3);