pryv 2.1.8 → 2.3.0

package/test/Connection.test.js

@@ -1,22 +1,32 @@
-const should = chai.should();
-const expect = chai.expect;
-const testData = require('./test-data.js');
-let conn = null;
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, xit, before, after, beforeEach, afterEach, expect, Browser, pryv, testData, Blob, FormData */
+/* eslint-disable no-unused-expressions */
+
 const { URL, URLSearchParams } = require('universal-url');
 const cuid = require('cuid');
-const { readFileSync } = require('fs');
 
-describe('Connection', () => {
+let conn = null;
+
+const isNode = (typeof window === 'undefined');
+
+let readFileSync;
+if (isNode) { // node
+  readFileSync = require('fs').readFileSync;
+}
 
+describe('Connection', () => {
   before(async function () {
     this.timeout(5000);
     await testData.prepare();
-    conn = new Pryv.Connection(testData.apiEndpointWithToken);
+    conn = new pryv.Connection(testData.apiEndpointWithToken);
 
     // create some events
     const toBeDeletedId = cuid();
     const toBeTrashed = cuid();
-    const resSetup = await conn.api([
+    await conn.api([
       {
         method: 'events.create',
         params: {
@@ -40,7 +50,7 @@ describe('Connection', () => {
           id: toBeDeletedId,
           streamIds: ['data'],
           type: 'note/txt',
-          content: 'To be Deleted ' + new Date(),
+          content: 'To be Deleted ' + new Date()
         }
       },
       {
@@ -65,208 +75,205 @@ describe('Connection', () => {
   });
 
   describe('.service', function () {
-    it('return a Pryv.Service object', async () => {
+    it('return a pryv.Service object', async () => {
       const service = conn.service;
-      expect(service instanceof Pryv.Service).to.equal(true);
+      expect(service instanceof pryv.Service).to.equal(true);
     });
-
   });
 
   describe('.username() ', function () {
     it('return the username of this connection', async () => {
       const username = await conn.username();
-      expect(username).to.equals(testData.username);
+      expect(username).to.equal(testData.username);
     });
-
   });
 
-
   describe('.api()', function () {
     this.timeout(5000);
     it('.api() events.get', async () => {
       const res = await conn.api(
         [
           {
-            method: "events.get",
+            method: 'events.get',
             params: {}
           }
         ]);
-      res.length.should.equal(1);
+      expect(res.length).to.equal(1);
     });
 
     it('.api() events.get split in chunks', async () => {
       conn.options.chunkSize = 2;
       const res = await conn.api(
         [
-          { method: "events.get", params: {} },
-          { method: "events.get", params: {} },
-          { method: "events.get", params: {} }
+          { method: 'events.get', params: {} },
+          { method: 'events.get', params: {} },
+          { method: 'events.get', params: {} }
         ]);
-      res.length.should.equal(3);
-
+      expect(res.length).to.equal(3);
     });
 
-
     it('.api() events.get with handleResult call', async () => {
       conn.options.chunkSize = 2;
 
-      let resultsRecievedCount = 0;
-      function oneMoreResult(res) {
-        should.exist(res.events);
-        resultsRecievedCount++;
+      let resultsReceivedCount = 0;
+      function oneMoreResult (res) {
+        expect(res.events).to.exist;
+        resultsReceivedCount++;
       }
 
       const res = await conn.api(
         [
-          { method: "events.get", params: {}, handleResult: oneMoreResult },
-          { method: "events.get", params: {}, handleResult: oneMoreResult },
-          { method: "events.get", params: {}, handleResult: oneMoreResult }
+          { method: 'events.get', params: {}, handleResult: oneMoreResult },
+          { method: 'events.get', params: {}, handleResult: oneMoreResult },
+          { method: 'events.get', params: {}, handleResult: oneMoreResult }
         ]);
-      res.length.should.equal(3);
-      res.length.should.equal(resultsRecievedCount);
+      expect(res.length).to.equal(3);
+      expect(res.length).to.equal(resultsReceivedCount);
     });
 
     it('.api() events.get with async handleResult call', async () => {
       conn.options.chunkSize = 2;
 
-      let resultsRecievedCount = 0;
-      async function oneMoreResult(res) {
-        should.exist(res.events);
+      let resultsReceivedCount = 0;
+      async function oneMoreResult (res) {
+        expect(res.events).to.exist;
 
-        let promise = new Promise((res, rej) => {
-          setTimeout(() => res("Now it's done!"), 100)
+        const promise = new Promise((resolve, reject) => {
+          setTimeout(() => resolve("Now it's done!"), 100);
         });
         // wait until the promise returns us a value
         await promise;
-        resultsRecievedCount++;
+        resultsReceivedCount++;
       }
 
       const res = await conn.api(
         [
-          { method: "events.get", params: {}, handleResult: oneMoreResult },
-          { method: "events.get", params: {}, handleResult: oneMoreResult },
-          { method: "events.get", params: {}, handleResult: oneMoreResult }
+          { method: 'events.get', params: {}, handleResult: oneMoreResult },
+          { method: 'events.get', params: {}, handleResult: oneMoreResult },
+          { method: 'events.get', params: {}, handleResult: oneMoreResult }
         ]);
-      res.length.should.equal(3);
-      res.length.should.equal(resultsRecievedCount);
+      expect(res.length).to.equal(3);
+      expect(res.length).to.equal(resultsReceivedCount);
     });
 
     it('.api() events.get split in chunks and send percentages', async () => {
       conn.options.chunkSize = 2;
-      const percentres = { 1: 67, 2: 100 }
+      const percentres = { 1: 67, 2: 100 };
       let count = 1;
       const res = await conn.api(
         [
-          { method: "events.get", params: {} },
-          { method: "events.get", params: {} },
-          { method: "events.get", params: {} }
+          { method: 'events.get', params: {} },
+          { method: 'events.get', params: {} },
+          { method: 'events.get', params: {} }
         ], function (percent) {
-          percent.should.equal(percentres[count]);
+          expect(percent).to.equal(percentres[count]);
           count++;
         });
-      res.length.should.equal(3);
-
+      expect(res.length).to.equal(3);
     });
 
     it('.api() with callbacks', (done) => {
       conn.api(
         [
-          { method: "events.get", params: {} }
+          { method: 'events.get', params: {} }
         ]).then((res) => {
-          res.length.should.equal(1);
-          done();
-        }, (err) => {
-          should.not.exist(err);
-          done();
-        });
-
+        expect(res.length).to.equal(1);
+        done();
+      }, (err) => {
+        expect(err).to.not.exist;
+        done();
+      });
     });
   });
 
-  describe('Attachements', () => {
-    it('Create event with attachment from file', async () => {
-      let res = null;
-
-      if (typeof window === 'undefined') { // node
-
-        res = await conn.createEventWithFile({
-          type: 'picture/attached',
-          streamId: 'data'
-        }, './test/Y.png');
-
-      } else { // browser
-        const formData = new FormData();
-        var blob = new Blob(['Hello'], { type: "text/txt" });
-        formData.append("webmasterfile", blob);
-
-        res = await conn.createEventWithFormData({
-          type: 'file/attached',
-          streamId: 'data'
-        }, formData);
-
-      }
-
-
-      should.exist(res);
-      should.exist(res.event);
-      should.exist(res.event.attachments);
-      res.event.attachments.length.should.equal(1);
-      res.event.attachments[0].size.should.equal(14798);
-      res.event.attachments[0].type.should.equal('image/png');
-      res.event.attachments[0].fileName.should.equal('Y.png');
+  describe('Attachments', () => {
+    it('Node Only: Create event with attachment from file', async function () {
+      if (!isNode) { this.skip(); }
+      const res = await conn.createEventWithFile({
+        type: 'picture/attached',
+        streamIds: ['data']
+      }, './test/Y.png');
+
+      expect(res).to.exist;
+      expect(res.event).to.exist;
+      expect(res.event.attachments).to.exist;
+      expect(res.event.attachments.length).to.equal(1);
+      expect(res.event.attachments[0].size).to.equal(14798);
+      expect(res.event.attachments[0].type).to.equal('image/png');
+      expect(res.event.attachments[0].fileName).to.equal('Y.png');
     });
 
-    it('Create event with attachment from Buffer', async () => {
-      const fileData = readFileSync('./test/Y.png');
-
-      let res = null;
-
-      if (typeof window === 'undefined') { // node
-
-        res = await conn.createEventWithFileFromBuffer({
-          type: 'picture/attached',
-          streamId: 'data'
-        }, fileData, 'Y.png');
-
-      } else { // browser
-        const formData = new FormData();
-        var blob = new Blob(['Hello'], { type: "text/txt" });
-        formData.append("webmasterfile", blob);
+    it('Node Only: Create event with attachment from Buffer', async function () {
+      if (!isNode) { this.skip(); }
 
-        res = await conn.createEventWithFormData({
-          type: 'file/attached',
-          streamId: 'data'
-        }, formData);
-
-      }
-
-
-      should.exist(res);
-      should.exist(res.event);
-      should.exist(res.event.attachments);
-      res.event.attachments.length.should.equal(1);
-      res.event.attachments[0].size.should.equal(14798);
-      res.event.attachments[0].type.should.equal('image/png');
-      res.event.attachments[0].fileName.should.equal('Y.png');
+      const fileData = readFileSync('./test/Y.png');
+      const res = await conn.createEventWithFileFromBuffer({
+        type: 'picture/attached',
+        streamIds: ['data']
+      }, fileData, 'Y.png');
+
+      expect(res).to.exist;
+      expect(res.event).to.exist;
+      expect(res.event.attachments).to.exist;
+      expect(res.event.attachments.length).to.equal(1);
+      expect(res.event.attachments[0].size).to.equal(14798);
+      expect(res.event.attachments[0].type).to.equal('image/png');
+      expect(res.event.attachments[0].fileName).to.equal('Y.png');
     });
 
+    it('Browser Only: Create event with attachment from Buffer', async function () {
+      if (isNode) { this.skip(); }
+
+      const blob = new Blob(['Hello'], { type: 'text/txt' });
+      const res = await conn.createEventWithFileFromBuffer({
+        type: 'picture/attached',
+        streamIds: ['data']
+      }, blob, 'Hello.txt');
+
+      expect(res).to.exist;
+      expect(res.event).to.exist;
+      expect(res.event.attachments).to.exist;
+      expect(res.event.attachments.length).to.equal(1);
+      expect(res.event.attachments[0].size).to.equal(5);
+      expect(res.event.attachments[0].type).to.equal('text/txt');
+      expect(res.event.attachments[0].fileName).to.equal('Hello.txt');
+    });
 
+    it('Browser Only: Create event with attachment formData', async function () {
+      if (isNode) { this.skip(); }
+
+      const formData = new FormData();
+      const blob = new Blob(['Hello'], { type: 'text/txt' });
+      formData.append('webmasterfile', blob);
+
+      const res = await conn.createEventWithFormData({
+        type: 'file/attached',
+        streamIds: ['data']
+      }, formData);
+
+      expect(res).to.exist;
+      expect(res.event).to.exist;
+      expect(res.event.attachments).to.exist;
+      expect(res.event.attachments.length).to.equal(1);
+      expect(res.event.attachments[0].size).to.equal(5);
+      expect(res.event.attachments[0].type).to.equal('text/txt');
+      expect(res.event.attachments[0].fileName).to.equal('blob');
+    });
   });
 
   describe('HF events', () => {
-
     it('Add data points to HF event', async () => {
-
       const res = await conn.api([{
         method: 'events.create',
         params: {
-          type: 'series:mass/kg', streamId: 'data'
+          type: 'series:mass/kg',
+          streamIds: ['data']
         }
       }]);
-      should.exist(res);
-      should.exist(res[0]);
-      should.exist(res[0].event);
-      should.exist(res[0].event.id);
+      expect(res).to.exist;
+      expect(res[0]).to.exist;
+      expect(res[0].event).to.exist;
+      expect(res[0].event.id).to.exist;
       const event = res[0].event;
 
       const res2 = await conn.addPointsToHFEvent(
@@ -274,25 +281,22 @@ describe('Connection', () => {
         ['deltaTime', 'value'],
         [[0, 1], [1, 1]]);
 
-      should.exist(res2);
-      'ok'.should.equal(res2.status);
+      expect(res2).to.exist;
+      expect('ok').to.equal(res2.status);
     });
-
   });
 
   describe('.get()', () => {
     it('/events', async () => {
       const res = await conn.get('events', { limit: 1 });
-      res.events.length.should.equal(1);
+      expect(res.events.length).to.equal(1);
     });
-
   });
 
   describe('time', () => {
     it('deltatime property', async () => {
       await conn.get('events', { limit: 1 });
-      const deltaTime = conn.deltaTime;
-      expect(Math.abs(deltaTime) < 2).to.be.true;
+      expect(conn.deltaTime).to.be.within(-2, 2);
     });
   });
 
@@ -311,18 +315,17 @@ describe('Connection', () => {
       it('streaming ', async () => {
         const queryParams = { fromTime: 0, toTime: now, limit: 10000 };
         let eventsCount = 0;
-        function forEachEvent(event) { eventsCount++; }
+        function forEachEvent (event) { eventsCount++; }
         const res = await conn.getEventsStreamed(queryParams, forEachEvent);
         expect(eventsCount).to.equal(res.eventsCount);
       });
 
-
       it('streaming includesDeletion', async () => {
         const queryParams = { fromTime: 0, toTime: now, limit: 10000, includeDeletions: true, modifiedSince: 0, state: 'all' };
         let eventsCount = 0;
         let trashedCount = 0;
         let deletedCount = 0;
-        function forEachEvent(event) {
+        function forEachEvent (event) {
           if (event.deleted) {
             deletedCount++;
           } else if (event.trashed) {
@@ -340,23 +343,21 @@ describe('Connection', () => {
       });
 
       it('no-events ', async () => {
-        const queryParams = { fromTime: 0, toTime: now, tags: ['RANDOM-123'] };
-        function forEachEvent(event) { }
+        const queryParams = { fromTime: 0, toTime: now, types: ['type/unexistent'] };
+        function forEachEvent (event) { }
         const res = await conn.getEventsStreamed(queryParams, forEachEvent);
         expect(0).to.equal(res.eventsCount);
       });
 
       it('no-events includeDeletions', async () => {
-        const queryParams = { fromTime: 0, toTime: now, tags: ['RANDOM-123'], includeDeletions: true, modifiedSince: 0 };
-        function forEachEvent(event) { }
+        const queryParams = { fromTime: 0, toTime: now, types: ['type/unexistent'], includeDeletions: true, modifiedSince: 0 };
+        function forEachEvent (event) { }
         const res = await conn.getEventsStreamed(queryParams, forEachEvent);
         expect(0).to.equal(res.eventsCount);
         expect(res.eventDeletionsCount).to.be.gte(0);
       });
     });
 
-
-
     if (typeof window === 'undefined') {
       describe('Browser mock', function () {
         beforeEach(function () {
@@ -365,7 +366,7 @@ describe('Connection', () => {
           global.document = browser.document;
           global.window = browser.window;
           global.location = browser.location;
-          function fetch(...args) {
+          function fetch (...args) {
             return browser.fetch(...args);
           }
           global.fetch = fetch;
@@ -386,15 +387,16 @@ describe('Connection', () => {
           delete global.fetch;
           const queryParams = { fromTime: 0, toTime: now, limit: 10000 };
           let eventsCount = 0;
-          function forEachEvent(event) { eventsCount++; }
+          function forEachEvent (event) { eventsCount++; }
           const res = await conn.getEventsStreamed(queryParams, forEachEvent);
           expect(eventsCount).to.equal(res.eventsCount);
         });
 
+        // HACK: skip until a solution is found to Zombie's `fetch()` not accepting URLs
         xit(' with fetch', async () => {
           const queryParams = { fromTime: 0, toTime: now, limit: 10000 };
           let eventsCount = 0;
-          function forEachEvent(event) { eventsCount++; }
+          function forEachEvent (event) { eventsCount++; }
           const res = await conn.getEventsStreamed(queryParams, forEachEvent);
           expect(eventsCount).to.equal(res.eventsCount);
         });
@@ -408,12 +410,13 @@ describe('Connection', () => {
     before(async () => {
       newUser = (await conn.api([
         {
-          method: "accesses.create", params: {
-            "name": "test",
-            "permissions": [
+          method: 'accesses.create',
+          params: {
+            name: 'test',
+            permissions: [
               {
-                "streamId": "data",
-                "level": "read"
+                streamId: 'data',
+                level: 'read'
               }
             ]
           }
@@ -425,31 +428,30 @@ describe('Connection', () => {
       const regexAPIandToken = /(.+):\/\/(.+)/gm;
       const res = regexAPIandToken.exec(testData.apiEndpoint);
       const apiEndpointWithToken = res[1] + '://' + newUser.access.token + '@' + res[2];
-      const newConn = new Pryv.Connection(apiEndpointWithToken);
+      const newConn = new pryv.Connection(apiEndpointWithToken);
       accessInfoUser = await newConn.accessInfo();
     });
 
     after(async () => {
       await conn.api([
         {
-          method: "accesses.delete", params: {
-            "id": newUser.access.id
+          method: 'accesses.delete',
+          params: {
+            id: newUser.access.id
           }
         }
       ]);
     });
 
     it('has same username', () => {
-      should.exist(accessInfoUser);
-      should.exist(accessInfoUser.name);
-      should.equal(newUser.access.name, accessInfoUser.name);
+      expect(accessInfoUser).to.exist;
+      expect(accessInfoUser.name).to.exist;
+      expect(newUser.access.name).to.equal(accessInfoUser.name);
     });
 
     it('has same token', () => {
-      should.exist(accessInfoUser.token);
-      should.equal(newUser.access.token, accessInfoUser.token);
+      expect(accessInfoUser.token).to.exist;
+      expect(newUser.access.token).to.equal(accessInfoUser.token);
     });
-
   });
-
-});
+});

package/test/Service.test.js

@@ -1,89 +1,75 @@
-
-                   
-const should = chai.should();
-const expect = chai.expect;
-const assert = chai.assert;
-
-const chaiAsPromised = require('chai-as-promised');
-chai.use(chaiAsPromised); 
-
-const testData = require('./test-data.js');
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect, pryv, testData */
+/* eslint-disable no-unused-expressions */
 
 describe('Service', function () {
-
   before(async function () {
     this.timeout(5000);
     await testData.prepare();
   });
 
   it('info()', async () => {
-    const pryvService = new Pryv.Service(testData.serviceInfoUrl);
+    const pryvService = new pryv.Service(testData.serviceInfoUrl);
     const res = await pryvService.info();
-    should.exist(res);
-    
+    expect(res).to.exist;
+
     ['access', 'api', 'register'].forEach((key) => {
-      should.exist(res[key]);
+      expect(res[key]).to.exist;
       // all API endpoints should end with a '/';
-      res[key].slice(-1).should.equal('/');
+      expect(res[key].slice(-1)).to.equal('/');
     });
   });
 
   it('info() 2x ', async () => {
-    const pryvService = new Pryv.Service(testData.serviceInfoUrl);
+    const pryvService = new pryv.Service(testData.serviceInfoUrl);
     const res = await pryvService.info();
-    should.exist(res);
-    should.exist(res.access);
+    expect(res).to.exist;
+    expect(res.access).to.exist;
     const res2 = await pryvService.info();
-    should.exist(res2);
-    should.exist(res2.access);
+    expect(res2).to.exist;
+    expect(res2.access).to.exist;
   });
 
   it('login()', async function () {
     this.timeout(5000);
-    const pryvService = new Pryv.Service(testData.serviceInfoUrl);
+    const pryvService = new pryv.Service(testData.serviceInfoUrl);
     const conn = await pryvService.login(testData.username, testData.password, 'jslib-test');
-    should.exist(conn);
-    should.exist(conn.token);
-    should.exist(conn.endpoint);
+    expect(conn).to.exist;
+    expect(conn.token).to.exist;
+    expect(conn.endpoint).to.exist;
   });
 
-
-  
-
-  it('assets()', async function() {
-    const pryvService = new Pryv.Service(null, testData.serviceInfo);
+  it('assets()', async function () {
+    const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
-    should.exist(assets);
+    expect(assets).to.exist;
 
-    //assets should be cached
+    // assets should be cached
     const assets2 = await pryvService.assets();
     expect(assets).to.equal(assets2);
   });
 
   describe('Errors', async function () {
-
     it('Throw error with invalid content', async () => {
-      const service = new Pryv.Service(null, {});
-      await assert.isRejected(service.info(), 
-      'Invalid data from service/info');
+      const service = new pryv.Service(null, {});
+      await expect(service.info()).to.be.rejectedWith('Invalid data from service/info');
     });
 
     it('Warn if no assets', async () => {
-      let serviceInfoCopy = Object.assign({}, testData.serviceInfo);
+      const serviceInfoCopy = Object.assign({}, testData.serviceInfo);
       delete serviceInfoCopy.assets;
-      const pryvService = new Pryv.Service(null, serviceInfoCopy);
+      const pryvService = new pryv.Service(null, serviceInfoCopy);
       const assets = await pryvService.assets();
       expect(assets).to.be.null;
     });
 
     it('login() failed', async function () {
       this.timeout(5000);
-      const pryvService = new Pryv.Service(testData.serviceInfoUrl);
-      await assert.isRejected(
-        pryvService.login(testData.username, 'bobby', 'jslib-test'),'The given username/password pair is invalid.');
+      const pryvService = new pryv.Service(testData.serviceInfoUrl);
+      await expect(pryvService.login(testData.username, 'bobby', 'jslib-test')).to.be.rejectedWith('The given username/password pair is invalid.');
     });
-
   });
 });
-
-