run service_node in the browser instead of as a nodejs module

Gruntfile.js

@@ -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: {

libloki/service_nodes.js

@@ -1,4 +1,11 @@
-function consolidateLists(lists, threshold = 1){
+/* global window */
+
+// eslint-disable-next-line func-names
+(function () {
+  window.libloki = window.libloki || {};
+  window.libloki.serviceNodes = window.libloki.serviceNodes || {};
+
+  function consolidateLists(lists, threshold = 1){
     if (typeof threshold !== 'number') {
       throw Error('Provided threshold is not a number');
     }
@@ -22,8 +29,7 @@ function consolidateLists(lists, threshold = 1){
     return Object.entries(occurences)
       .filter(keyValue => keyValue[1] >= scaledThreshold)
       .map(keyValue => keyValue[0]);
-}
+  }
 
-module.exports = {
+  window.libloki.serviceNodes.consolidateLists = consolidateLists;
-  consolidateLists,
+})();
-}

libloki/test/index.html

@@ -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( -->

libloki/test/node/.eslintrc.js

@@ -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,
-      },
-    ],
-  },
-};

libloki/test/service_nodes_test.js

@@ -1,58 +1,57 @@
-const ServiceNode = require('../../service_nodes');
+/* global libloki, chai */
-const { expect } = require('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([]);
+      const result = libloki.serviceNodes.consolidateLists([]);
-      expect(result).to.deep.equal([]);
+      chai.expect(result).to.deep.equal([]);
     });
     it('should return the input when only 1 list is provided', () => {
-      const result = ServiceNode.consolidateLists([['a', 'b', 'c']]);
+      const result = libloki.serviceNodes.consolidateLists([['a', 'b', 'c']]);
-      expect(result).to.deep.equal(['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']);
     });
   });
 });

package.json

@@ -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",