run service_node in the browser instead of as a nodejs module

pull/122/head
sachaaaaa 6 years ago
parent 61145b6e99
commit 583a10628a

@ -100,7 +100,10 @@ module.exports = grunt => {
dest: 'js/libtextsecure.js',
},
libloki: {
src: ['libloki/libloki-protocol.js'],
src: [
'libloki/libloki-protocol.js',
'libloki/service_nodes.js',
],
dest: 'js/libloki.js',
},
lokitest: {

@ -1,29 +1,35 @@
function consolidateLists(lists, threshold = 1){
if (typeof threshold !== 'number') {
throw Error('Provided threshold is not a number');
}
/* global window */
// eslint-disable-next-line func-names
(function () {
window.libloki = window.libloki || {};
window.libloki.serviceNodes = window.libloki.serviceNodes || {};
// calculate list size manually since `Set`
// does not have a `length` attribute
let numLists = 0;
const occurences = {};
lists.forEach(list => {
numLists += 1;
list.forEach(item => {
if (!(item in occurences)) {
occurences[item] = 1;
} else {
occurences[item] += 1;
}
function consolidateLists(lists, threshold = 1){
if (typeof threshold !== 'number') {
throw Error('Provided threshold is not a number');
}
// calculate list size manually since `Set`
// does not have a `length` attribute
let numLists = 0;
const occurences = {};
lists.forEach(list => {
numLists += 1;
list.forEach(item => {
if (!(item in occurences)) {
occurences[item] = 1;
} else {
occurences[item] += 1;
}
});
});
});
const scaledThreshold = numLists * threshold;
return Object.entries(occurences)
.filter(keyValue => keyValue[1] >= scaledThreshold)
.map(keyValue => keyValue[0]);
}
const scaledThreshold = numLists * threshold;
return Object.entries(occurences)
.filter(keyValue => keyValue[1] >= scaledThreshold)
.map(keyValue => keyValue[0]);
}
module.exports = {
consolidateLists,
}
window.libloki.serviceNodes.consolidateLists = consolidateLists;
})();

@ -25,9 +25,11 @@
<script type="text/javascript" src="../../libtextsecure/stringview.js" data-cover></script>
<script type="text/javascript" src="../libloki-protocol.js" data-cover></script>
<script type="text/javascript" src="../service_nodes.js" data-cover></script>
<script type="text/javascript" src="proof-of-work_test.js"></script>
<script type="text/javascript" src="libloki-protocol_test.js"></script>
<script type="text/javascript" src="service_nodes_test.js"></script>
<!-- Comment out to turn off code coverage. Useful for getting real callstacks. -->
<!-- NOTE: blanket doesn't support modern syntax and will choke until we find a replacement. :0( -->

@ -1,22 +0,0 @@
// For reference: https://github.com/airbnb/javascript
module.exports = {
env: {
mocha: true,
browser: false,
},
parserOptions: {
sourceType: 'module',
},
rules: {
// We still get the value of this rule, it just allows for dev deps
'import/no-extraneous-dependencies': [
'error',
{
devDependencies: true,
},
],
},
};

@ -1,58 +1,57 @@
const ServiceNode = require('../../service_nodes');
const { expect } = require('chai');
/* global libloki, chai */
describe('ServiceNodes', () => {
describe('#consolidateLists', () => {
it('should throw when provided a non-iterable list', () => {
expect(() => ServiceNode.consolidateLists(null, 1)).to.throw();
chai.expect(() => libloki.serviceNodes.consolidateLists(null, 1)).to.throw();
});
it('should throw when provided a non-iterable item in the list', () => {
expect(() => ServiceNode.consolidateLists([1, 2, 3], 1)).to.throw();
chai.expect(() => libloki.serviceNodes.consolidateLists([1, 2, 3], 1)).to.throw();
});
it('should throw when provided a non-number threshold', () => {
expect(() => ServiceNode.consolidateLists([], 'a')).to.throw();
chai.expect(() => libloki.serviceNodes.consolidateLists([], 'a')).to.throw();
});
it('should return an empty array when the input is an empty array', () => {
const result = ServiceNode.consolidateLists([]);
expect(result).to.deep.equal([]);
const result = libloki.serviceNodes.consolidateLists([]);
chai.expect(result).to.deep.equal([]);
});
it('should return the input when only 1 list is provided', () => {
const result = ServiceNode.consolidateLists([['a', 'b', 'c']]);
expect(result).to.deep.equal(['a', 'b', 'c']);
const result = libloki.serviceNodes.consolidateLists([['a', 'b', 'c']]);
chai.expect(result).to.deep.equal(['a', 'b', 'c']);
});
it('should return the union of all lists when threshold is 0', () => {
const result = ServiceNode.consolidateLists([
const result = libloki.serviceNodes.consolidateLists([
['a', 'b', 'c', 'h'],
['d', 'e', 'f', 'g'],
['g', 'h'],
], 0);
expect(result.sort()).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
chai.expect(result.sort()).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h']);
});
it('should return the intersection of all lists when threshold is 1', () => {
const result = ServiceNode.consolidateLists([
const result = libloki.serviceNodes.consolidateLists([
['a', 'b', 'c', 'd'],
['a', 'e', 'f', 'g'],
['a', 'h'],
], 1);
expect(result).to.deep.equal(['a']);
chai.expect(result).to.deep.equal(['a']);
});
it('should return the elements that have an occurence >= the provided threshold', () => {
const result = ServiceNode.consolidateLists([
const result = libloki.serviceNodes.consolidateLists([
['a', 'b', 'c', 'd', 'e', 'f', 'g'],
['a', 'b', 'c', 'd', 'e', 'f', 'h'],
['a', 'b', 'c', 'd', 'e', 'f', 'g'],
['a', 'b', 'c', 'd', 'e', 'g', 'h'],
], 3/4);
expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
chai.expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
});
it('should work with sets as well', () => {
const result = ServiceNode.consolidateLists(new Set([
const result = libloki.serviceNodes.consolidateLists(new Set([
new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']),
new Set(['a', 'b', 'c', 'd', 'e', 'f', 'h']),
new Set(['a', 'b', 'c', 'd', 'e', 'f', 'g']),
new Set(['a', 'b', 'c', 'd', 'e', 'g', 'h']),
]), 3/4);
expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
chai.expect(result).to.deep.equal(['a', 'b', 'c', 'd', 'e', 'f', 'g']);
});
});
});

@ -31,7 +31,7 @@
"test-lib-view": "NODE_ENV=test-lib yarn run start",
"test-loki-view": "NODE_ENV=test-loki yarn run start",
"test-electron": "yarn grunt test",
"test-node": "mocha --recursive test/app test/modules ts/test libloki/test/node",
"test-node": "mocha --recursive test/app test/modules ts/test",
"test-node-coverage": "nyc --reporter=lcov --reporter=text mocha --recursive test/app test/modules ts/test",
"eslint": "eslint .",
"lint": "yarn format --list-different && yarn lint-windows",

Loading…
Cancel
Save