mirror of
https://github.com/orbitdb/orbitdb.git
synced 2025-03-30 15:08:28 +00:00
580 lines
18 KiB
JavaScript
580 lines
18 KiB
JavaScript
'use strict';
|
|
|
|
var fs = require('fs');
|
|
var path = require('path');
|
|
var assert = require('assert');
|
|
var async = require('asyncawait/async');
|
|
var await = require('asyncawait/await');
|
|
var ipfsDaemon = require('orbit-common/lib/ipfs-daemon');
|
|
var logger = require('orbit-common/lib/logger');
|
|
var Server = require('orbit-server/src/server');
|
|
var OrbitClient = require('../src/OrbitClient');
|
|
|
|
var serverConfig = {
|
|
networkId: "orbitdb-test",
|
|
networkName: "OrbitDB Test Network",
|
|
salt: "hellothisisdog",
|
|
userDataPath: "/tmp/orbitdb-tests",
|
|
verifyMessages: true
|
|
}
|
|
|
|
// Orbit
|
|
const host = 'localhost';
|
|
const port = 3006;
|
|
const username = 'testrunner';
|
|
const password = '';
|
|
|
|
const startServer = async (() => {
|
|
return new Promise(async((resolve, reject) => {
|
|
logger.setLevel('ERROR');
|
|
const ipfsd = await(ipfsDaemon());
|
|
const server = Server(ipfsd.daemon, ipfsd.nodeInfo, serverConfig);
|
|
server.app.listen(port, () => {
|
|
resolve(server);
|
|
}).on('error', (err) => {
|
|
resolve(server);
|
|
});
|
|
}));
|
|
});
|
|
|
|
|
|
describe('Orbit Client', () => {
|
|
let server, orbit;
|
|
|
|
let head = '';
|
|
let items = [];
|
|
let channel = 'abcdefgh';
|
|
|
|
before(async((done) => {
|
|
var initialize = () => new Promise(async((resolve, reject) => {
|
|
orbit = OrbitClient.connect(`${host}:${port}`, username, password);
|
|
orbit.channel(channel, '').delete();
|
|
resolve();
|
|
}));
|
|
server = await(startServer());
|
|
await(initialize());
|
|
done();
|
|
}));
|
|
|
|
after(function(done) {
|
|
var deleteChannel = () => new Promise(async((resolve, reject) => {
|
|
if(orbit) orbit.channel(channel, '').delete();
|
|
resolve();
|
|
}));
|
|
server.shutdown();
|
|
server = null;
|
|
deleteChannel().then(done);
|
|
});
|
|
|
|
/* TESTS */
|
|
describe('Connect', function() {
|
|
it('connects to hash-cache-server', async((done) => {
|
|
assert.notEqual(orbit, null);
|
|
assert.notEqual(orbit.client, null);
|
|
assert.equal(orbit.user.id, 'Qmf5A5RSTQmcfvigT3j29Fqh2fAHRANk5ooBYKdWsPtr8U');
|
|
assert.equal(orbit.network.id, serverConfig.networkId);
|
|
assert.equal(orbit.network.name, serverConfig.networkName);
|
|
assert.notEqual(orbit.network.config.SupernodeRouting, null);
|
|
assert.notEqual(orbit.network.config.Bootstrap.length, 0);
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('Info', function() {
|
|
it('gets channel info on empty channel', async((done) => {
|
|
var info = orbit.channel(channel, '').info();
|
|
assert.notEqual(info, null);
|
|
assert.equal(info.head, null);
|
|
assert.notEqual(info.modes, null);
|
|
done();
|
|
}));
|
|
|
|
it('gets channel info on an existing channel', async((done) => {
|
|
var msg = orbit.channel(channel, '').add('hello');
|
|
var info = orbit.channel(channel, '').info();
|
|
assert.notEqual(info, null);
|
|
assert.notEqual(info.head, null);
|
|
assert.notEqual(info.modes, null);
|
|
assert.equal(info.modes.r, null);
|
|
done();
|
|
}));
|
|
|
|
// it('gets channel info when channel has modes set', async((done) => {
|
|
// try {
|
|
// orbit.channel(channel).delete();
|
|
// var mode = {
|
|
// mode: "+r",
|
|
// params: {
|
|
// password: 'password'
|
|
// }
|
|
// };
|
|
// var res = orbit.channel(channel, '').setMode(mode)
|
|
// var info = orbit.channel(channel, 'password').info();
|
|
// assert.notEqual(info, null);
|
|
// assert.equal(info.head, null);
|
|
// assert.equal(JSON.stringify(info.modes), JSON.stringify(res));
|
|
// orbit.channel(channel, 'password').delete();
|
|
// } catch(e) {
|
|
// orbit.channel(channel, 'password').delete();
|
|
// assert.equal(e, null);
|
|
// }
|
|
// done();
|
|
// }));
|
|
|
|
});
|
|
|
|
describe('Delete', function() {
|
|
it('deletes a channel from the database', async((done) => {
|
|
var result = orbit.channel(channel, '').delete();
|
|
assert.equal(result, true);
|
|
var iter = orbit.channel(channel, '').iterator();
|
|
assert.equal(iter.next().value, null);
|
|
done();
|
|
}));
|
|
|
|
it('deletes a channel with a password', async((done) => {
|
|
done();
|
|
}));
|
|
|
|
it('doesn\'t delete a channel when password is wrong', async((done) => {
|
|
done();
|
|
}));
|
|
|
|
it('doesn\'t delete a channel when user is not an op', async((done) => {
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('Add events', function() {
|
|
it('adds an item to an empty channel', async((done) => {
|
|
try {
|
|
orbit.channel(channel, '').delete();
|
|
const head = orbit.channel(channel, '').add('hello');
|
|
assert.notEqual(head, null);
|
|
assert.equal(head.startsWith('Qm'), true);
|
|
assert.equal(head.length, 46);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('adds a new item to a channel with one item', async((done) => {
|
|
try {
|
|
const head = orbit.channel(channel, '').iterator().collect()[0];
|
|
const second = orbit.channel(channel, '').add('hello');
|
|
assert.notEqual(second, null);
|
|
assert.notEqual(second, head);
|
|
assert.equal(second.startsWith('Qm'), true);
|
|
assert.equal(second.length, 46);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('adds five items', async((done) => {
|
|
for(var i = 0; i < 5; i ++) {
|
|
try {
|
|
var s = orbit.channel(channel, '').add('hello');
|
|
assert.notEqual(s, null);
|
|
assert.equal(s.startsWith('Qm'), true);
|
|
assert.equal(s.length, 46);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('adds an item that is > 256 bytes', async((done) => {
|
|
try {
|
|
var msg = new Buffer(512);
|
|
msg.fill('a')
|
|
var s = orbit.channel(channel, '').add(msg.toString());
|
|
assert.notEqual(s, null);
|
|
assert.equal(s.startsWith('Qm'), true);
|
|
assert.equal(s.length, 46);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
});
|
|
|
|
|
|
describe('Iterator', function() {
|
|
var items = [];
|
|
var itemCount = 5;
|
|
|
|
before(function(done) {
|
|
var addMessages = () => new Promise(async((resolve, reject) => {
|
|
var result = orbit.channel(channel, '').delete();
|
|
var iter = orbit.channel(channel, '').iterator();
|
|
for(var i = 0; i < itemCount; i ++) {
|
|
var s = orbit.channel(channel, '').add('hello' + i);
|
|
items.push(s);
|
|
}
|
|
resolve();
|
|
}));
|
|
addMessages().then(done);
|
|
});
|
|
|
|
describe('Defaults', function() {
|
|
it('returns an iterator', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator();
|
|
var next = iter.next().value;
|
|
assert.notEqual(iter, null);
|
|
assert.notEqual(next, null);
|
|
assert.notEqual(next.item, null);
|
|
assert.notEqual(next.item.op, null);
|
|
assert.equal(next.item.seq, 4);
|
|
assert.notEqual(next.item.target, null);
|
|
assert.notEqual(next.item.next, null);
|
|
assert.notEqual(next.item.Payload, null);
|
|
assert.equal(next.item.Payload, 'hello4');
|
|
done();
|
|
}));
|
|
|
|
it('implements Iterator interface', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: -1 });
|
|
var messages = [];
|
|
|
|
for(let i of iter)
|
|
messages.push(i.hash);
|
|
|
|
assert.equal(messages.length, items.length);
|
|
done();
|
|
}));
|
|
|
|
it('returns 1 item as default', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator();
|
|
var first = iter.next().value;
|
|
var second = iter.next().value;
|
|
assert.equal(first.item.key, items[items.length - 1]);
|
|
assert.equal(second, null);
|
|
assert.equal(first.item.Payload, 'hello4');
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('Collect', function() {
|
|
it('returns all items', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: -1 });
|
|
var messages = iter.collect();
|
|
assert.equal(messages.length, items.length);
|
|
assert.equal(messages[messages.length - 1].item.Payload, 'hello0');
|
|
assert.equal(messages[0].item.Payload, 'hello4');
|
|
done();
|
|
}));
|
|
|
|
it('returns 1 item', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator();
|
|
var messages = iter.collect();
|
|
assert.equal(messages.length, 1);
|
|
done();
|
|
}));
|
|
|
|
it('returns 3 items', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: 3 });
|
|
var messages = iter.collect();
|
|
assert.equal(messages.length, 3);
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('Options: limit', function() {
|
|
it('returns 1 item when limit is 0', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: 0 });
|
|
var first = iter.next().value;
|
|
var second = iter.next().value;
|
|
assert.equal(first.item.key, items[items.length - 1]);
|
|
assert.equal(second, null);
|
|
done();
|
|
}));
|
|
|
|
it('returns 1 item when limit is 1', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: 1 });
|
|
var first = iter.next().value;
|
|
var second = iter.next().value;
|
|
assert.equal(first.item.key, items[items.length - 1]);
|
|
assert.equal(second, null);
|
|
done();
|
|
}));
|
|
|
|
it('returns 3 items', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: 3 });
|
|
var first = iter.next().value;
|
|
var second = iter.next().value;
|
|
var third = iter.next().value;
|
|
var fourth = iter.next().value;
|
|
assert.equal(first.item.key, items[items.length - 1]);
|
|
assert.equal(second.item.key, items[items.length - 2]);
|
|
assert.equal(third.item.key, items[items.length - 3]);
|
|
assert.equal(fourth, null);
|
|
done();
|
|
}));
|
|
|
|
it('returns all items', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: -1 });
|
|
var messages = iter.collect().map((e) => e.item.key);
|
|
|
|
messages.reverse();
|
|
assert.equal(messages.length, items.length);
|
|
assert.equal(messages[0], items[0]);
|
|
done();
|
|
}));
|
|
|
|
it('returns all items when limit is bigger than -1', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: -300 });
|
|
var messages = iter.collect().map((e) => e.item.key);
|
|
|
|
assert.equal(messages.length, items.length);
|
|
assert.equal(messages[0], items[items.length - 1]);
|
|
done();
|
|
}));
|
|
|
|
it('returns all items when limit is bigger than number of items', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: 300 });
|
|
var messages = iter.collect().map((e) => e.item.key);
|
|
|
|
assert.equal(messages.length, items.length);
|
|
assert.equal(messages[0], items[items.length - 1]);
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('Options: reverse', function() {
|
|
it('returns all items reversed', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: -1, reverse: true });
|
|
var messages = iter.collect().map((e) => e.item.key);
|
|
|
|
assert.equal(messages.length, items.length);
|
|
assert.equal(messages[0], items[0]);
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('Options: ranges', function() {
|
|
var all = [];
|
|
var head;
|
|
|
|
before((done) => {
|
|
var fetchAll = () => new Promise(async((resolve, reject) => {
|
|
all = orbit.channel(channel, '').iterator({ limit: -1 }).collect();
|
|
head = all[0];
|
|
resolve();
|
|
}));
|
|
fetchAll().then(done);
|
|
});
|
|
|
|
describe('gt & gte', function() {
|
|
it('returns 0 items when gt is the head', async((done) => {
|
|
var messages = orbit.channel(channel, '').iterator({ gt: head.hash }).collect();
|
|
assert.equal(messages.length, 0);
|
|
done();
|
|
}));
|
|
|
|
it('returns 1 item when gte is the head', async((done) => {
|
|
var iter2 = orbit.channel(channel, '').iterator({ gte: head.hash, limit: -1 });
|
|
var messages = iter2.collect().map((e) => e.item.key);
|
|
|
|
assert.equal(messages.length, 1);
|
|
assert.equal(messages[0], items[items.length -1]);
|
|
done();
|
|
}));
|
|
|
|
it('returns 2 item when gte is defined', async((done) => {
|
|
var gte = all[1].hash;
|
|
var iter = orbit.channel(channel, '').iterator({ gte: gte, limit: -1 });
|
|
var messages = iter.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, 2);
|
|
assert.equal(messages[0], all[0].hash);
|
|
assert.equal(messages[1], all[1].hash);
|
|
done();
|
|
}));
|
|
|
|
it('returns all items when gte is the root item', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ gte: all[all.length -1], limit: -1 });
|
|
var messages = iter.collect().map((e) => e.item.key);
|
|
|
|
assert.equal(messages.length, itemCount);
|
|
assert.equal(messages[0], items[items.length - 1]);
|
|
assert.equal(messages[messages.length - 1], items[0]);
|
|
done();
|
|
}));
|
|
|
|
it('returns items when gt is the root item', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ gt: all[all.length - 1], limit: -1 });
|
|
var messages = iter.collect().map((e) => e.item.key);
|
|
|
|
assert.equal(messages.length, itemCount - 1);
|
|
assert.equal(messages[0], items[items.length - 1]);
|
|
assert.equal(messages[3], items[1]);
|
|
done();
|
|
}));
|
|
|
|
it('returns items when gt is defined', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ limit: -1});
|
|
var messages = iter.collect().map((e) => e.hash);
|
|
|
|
var gt = messages[2];
|
|
var iter2 = orbit.channel(channel, '').iterator({ gt: gt, limit: 100 });
|
|
var messages2 = iter2.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages2.length, 2);
|
|
assert.equal(messages2[0], messages[0]);
|
|
assert.equal(messages2[1], messages[1]);
|
|
done();
|
|
}));
|
|
});
|
|
|
|
describe('lt & lte', function() {
|
|
it('returns one item when lt is the head', async((done) => {
|
|
var iter2 = orbit.channel(channel, '').iterator({ lt: head.hash });
|
|
var messages = iter2.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, 1);
|
|
assert.equal(messages[0], head.hash);
|
|
done();
|
|
}));
|
|
|
|
it('returns all items when lt is head and limit is -1', async((done) => {
|
|
var iter2 = orbit.channel(channel, '').iterator({ lt: head.hash, limit: -1 });
|
|
var messages = iter2.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, itemCount);
|
|
assert.equal(messages[0], head.hash);
|
|
assert.equal(messages[4], all[all.length - 1].hash);
|
|
done();
|
|
}));
|
|
|
|
it('returns 3 items when lt is head and limit is 3', async((done) => {
|
|
var iter2 = orbit.channel(channel, '').iterator({ lt: head.hash, limit: 3 });
|
|
var messages = iter2.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, 3);
|
|
assert.equal(messages[0], head.hash);
|
|
assert.equal(messages[2], all[2].hash);
|
|
done();
|
|
}));
|
|
|
|
it('returns null when lt is the root item', async((done) => {
|
|
var messages = orbit.channel(channel, '').iterator({ lt: all[all.length - 1].hash }).collect();
|
|
assert.equal(messages.length, 0);
|
|
done();
|
|
}));
|
|
|
|
it('returns one item when lte is the root item', async((done) => {
|
|
var iter = orbit.channel(channel, '').iterator({ lte: all[all.length - 1].hash });
|
|
var messages = iter.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, 1);
|
|
assert.equal(messages[0], all[all.length - 1].hash);
|
|
done();
|
|
}));
|
|
|
|
it('returns all items when lte is the head', async((done) => {
|
|
var iter2 = orbit.channel(channel, '').iterator({ lte: head.hash, limit: -1 });
|
|
var messages = iter2.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, itemCount);
|
|
assert.equal(messages[0], all[0].hash);
|
|
assert.equal(messages[4], all[all.length - 1].hash);
|
|
done();
|
|
}));
|
|
|
|
it('returns 3 items when lte is the head', async((done) => {
|
|
var iter2 = orbit.channel(channel, '').iterator({ lte: head.hash, limit: 3 });
|
|
var messages = iter2.collect().map((e) => e.hash);
|
|
|
|
assert.equal(messages.length, 3);
|
|
assert.equal(messages[0], all[0].hash);
|
|
assert.equal(messages[1], all[1].hash);
|
|
assert.equal(messages[2], all[2].hash);
|
|
done();
|
|
}));
|
|
});
|
|
});
|
|
|
|
});
|
|
|
|
|
|
/*
|
|
describe('Modes', function() {
|
|
var password = 'hello';
|
|
|
|
it('sets read mode', async((done) => {
|
|
try {
|
|
var mode = {
|
|
mode: "+r",
|
|
params: {
|
|
password: password
|
|
}
|
|
};
|
|
var modes = orbit.channel(channel, '').setMode(mode)
|
|
assert.notEqual(modes.r, null);
|
|
assert.equal(modes.r.password, password);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('can\'t read with wrong password', async((done) => {
|
|
try {
|
|
var modes = orbit.channel(channel, 'invalidpassword').iterator();
|
|
assert.equal(true, false);
|
|
} catch(e) {
|
|
assert.equal(e, 'Unauthorized');
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('sets write mode', async((done) => {
|
|
try {
|
|
var mode = {
|
|
mode: "+w",
|
|
params: {
|
|
ops: [orbit.user.id]
|
|
}
|
|
};
|
|
var modes = orbit.channel(channel, password).setMode(mode);
|
|
assert.notEqual(modes.w, null);
|
|
assert.equal(modes.w.ops[0], orbit.user.id);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('can\'t write when user not an op', async((done) => {
|
|
// TODO
|
|
done();
|
|
}));
|
|
|
|
it('removes write mode', async((done) => {
|
|
try {
|
|
var modes = orbit.channel(channel, password).setMode({ mode: "-w" });
|
|
assert.equal(modes.w, null);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
|
|
it('removes read mode', async((done) => {
|
|
try {
|
|
var modes = orbit.channel(channel, password).setMode({ mode: "-r" });
|
|
assert.equal(modes.r, null);
|
|
} catch(e) {
|
|
assert.equal(e, null);
|
|
}
|
|
done();
|
|
}));
|
|
|
|
});
|
|
*/
|
|
});
|