pryv 3.0.0 → 3.0.2

package/test/Service.test.js

@@ -4,13 +4,13 @@
  */
 /* global describe, it, before, expect, pryv, testData */
 
-describe('Service', function () {
+describe('[SERX] Service', function () {
   before(async function () {
     this.timeout(15000);
     await testData.prepare();
   });
 
-  it('info()', async () => {
+  it('[SERA] info()', async () => {
     const pryvService = new pryv.Service(testData.serviceInfoUrl);
     const res = await pryvService.info();
     expect(res).to.exist;
@@ -22,7 +22,7 @@ describe('Service', function () {
     });
   });
 
-  it('info() 2x ', async () => {
+  it('[SERB] info() 2x ', async () => {
     const pryvService = new pryv.Service(testData.serviceInfoUrl);
     const res = await pryvService.info();
     expect(res).to.exist;
@@ -32,7 +32,7 @@ describe('Service', function () {
     expect(res2.access).to.exist;
   });
 
-  it('login()', async function () {
+  it('[SERC] login()', async function () {
     this.timeout(15000);
     const pryvService = new pryv.Service(testData.serviceInfoUrl);
     const conn = await pryvService.login(testData.username, testData.password, 'jslib-test');
@@ -41,7 +41,7 @@ describe('Service', function () {
     expect(conn.endpoint).to.exist;
   });
 
-  it('assets()', async function () {
+  it('[SERD] assets()', async function () {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
     expect(assets).to.exist;
@@ -51,13 +51,13 @@ describe('Service', function () {
     expect(assets).to.equal(assets2);
   });
 
-  describe('Errors', async function () {
-    it('Throw error with invalid content', async () => {
+  describe('[SEEX] Errors', async function () {
+    it('[SEEA] Throw error with invalid content', async () => {
       const service = new pryv.Service(null, {});
       await expect(service.info()).to.be.rejectedWith('Invalid data from service/info');
     });
 
-    it('Warn if no assets', async () => {
+    it('[SEEB] Warn if no assets', async () => {
       const serviceInfoCopy = Object.assign({}, testData.serviceInfo);
       delete serviceInfoCopy.assets;
       const pryvService = new pryv.Service(null, serviceInfoCopy);
@@ -65,13 +65,13 @@ describe('Service', function () {
       expect(assets).to.be.null;
     });
 
-    it('login() failed on wrong password', async function () {
+    it('[SEEC] login() failed on wrong password', async function () {
       this.timeout(15000);
       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.');
     });
 
-    it('login() failed on wrong username', async function () {
+    it('[SEED] login() failed on wrong username', async function () {
       this.timeout(15000);
       const pryvService = new pryv.Service(testData.serviceInfoUrl);
       // check if username is in path or domain

package/test/ServiceAssets.test.js

@@ -4,7 +4,7 @@
  */
 /* global describe, it, before, after, expect, JSDOM, pryv, testData */
 
-describe('ServiceAssets', function () {
+describe('[ASTX] ServiceAssets', function () {
   let cleanupDom = false;
 
   before(async function () {
@@ -28,19 +28,19 @@ describe('ServiceAssets', function () {
     delete global.location;
   });
 
-  it('relativeURL()', async () => {
+  it('[ASTA] relativeURL()', async () => {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
     expect(assets.relativeURL('./toto')).to.eql(testData.serviceInfo.assets.definitions.replace('index.json', 'toto'));
   });
 
-  it('setAllDefaults()', async () => {
+  it('[ASTB] setAllDefaults()', async () => {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
     await assets.setAllDefaults();
   });
 
-  it('Load all external elements', async () => {
+  it('[ASTC] Load all external elements', async () => {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
 
@@ -49,21 +49,21 @@ describe('ServiceAssets', function () {
     await assets.loginButtonGetMessages();
   });
 
-  it('.get() returns all assets', async () => {
+  it('[ASTD] .get() returns all assets', async () => {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
     const allAssets = await assets.get();
     expect(allAssets.favicon.default.url).to.eql('favicon.ico');
   });
 
-  it('.get(keyPath) ', async () => {
+  it('[ASTE] .get(keyPath) ', async () => {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
     const faviconUrl = await assets.get('favicon:default:url');
     expect(faviconUrl).to.eql('favicon.ico');
   });
 
-  it('.getUrl(keyPath) ', async () => {
+  it('[ASTF] .getUrl(keyPath) ', async () => {
     const pryvService = new pryv.Service(null, testData.serviceInfo);
     const assets = await pryvService.assets();
     const faviconUrl = await assets.getUrl('favicon:default:url');

package/test/Streams.test.js

@@ -0,0 +1,135 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, after, expect, pryv, testData */
+
+const { createId: cuid } = require('@paralleldrive/cuid2');
+
+let conn = null;
+const suffix = cuid().slice(0, 8);
+const testStreamId = 'str-' + suffix;
+const childStreamId = 'str-child-' + suffix;
+const testStreamName = 'Test Stream ' + suffix;
+const childStreamName = 'Child Stream ' + suffix;
+
+describe('[STRX] Streams', () => {
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+    conn = new pryv.Connection(testData.apiEndpointWithToken);
+  });
+
+  describe('[SCRX] streams.create', function () {
+    it('[SCRA] create a root stream', async () => {
+      const res = await conn.api([{
+        method: 'streams.create',
+        params: { id: testStreamId, name: testStreamName }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].stream).to.exist;
+      expect(res[0].stream.id).to.equal(testStreamId);
+      expect(res[0].stream.name).to.equal(testStreamName);
+    });
+
+    it('[SCRB] create a child stream', async () => {
+      const res = await conn.api([{
+        method: 'streams.create',
+        params: { id: childStreamId, name: childStreamName, parentId: testStreamId }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].stream).to.exist;
+      expect(res[0].stream.parentId).to.equal(testStreamId);
+    });
+
+    it('[SCRC] reject duplicate stream id', async () => {
+      const res = await conn.api([{
+        method: 'streams.create',
+        params: { id: testStreamId, name: 'Duplicate ' + suffix }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].error).to.exist;
+      expect(res[0].error.id).to.equal('item-already-exists');
+    });
+  });
+
+  describe('[SGTX] streams.get', function () {
+    it('[SGTA] get all streams', async () => {
+      const res = await conn.api([{
+        method: 'streams.get',
+        params: {}
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].streams).to.exist;
+      expect(Array.isArray(res[0].streams)).to.equal(true);
+      expect(res[0].streams.length).to.be.gt(0);
+    });
+
+    it('[SGTB] get stream tree includes parent and child', async () => {
+      const res = await conn.api([{
+        method: 'streams.get',
+        params: {}
+      }]);
+      const streams = res[0].streams;
+      const parent = findStream(streams, testStreamId);
+      expect(parent).to.exist;
+      expect(parent.children).to.exist;
+      const child = parent.children.find(s => s.id === childStreamId);
+      expect(child).to.exist;
+    });
+  });
+
+  describe('[SUPX] streams.update', function () {
+    it('[SUPA] rename a stream', async () => {
+      const res = await conn.api([{
+        method: 'streams.update',
+        params: { id: childStreamId, update: { name: 'Renamed ' + suffix } }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].stream).to.exist;
+      expect(res[0].stream.name).to.equal('Renamed ' + suffix);
+    });
+  });
+
+  describe('[SDLX] streams.delete', function () {
+    it('[SDLA] trash a stream (first delete)', async () => {
+      const res = await conn.api([{
+        method: 'streams.delete',
+        params: { id: childStreamId }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].stream).to.exist;
+      expect(res[0].stream.trashed).to.equal(true);
+    });
+
+    it('[SDLB] delete a trashed stream (second delete)', async () => {
+      const res = await conn.api([{
+        method: 'streams.delete',
+        params: { id: childStreamId }
+      }]);
+      expect(res[0]).to.exist;
+      // After second delete, stream is gone
+      expect(res[0].streamDeletion).to.exist;
+    });
+  });
+
+  // Cleanup parent stream
+  after(async () => {
+    if (!conn) return;
+    await conn.api([
+      { method: 'streams.delete', params: { id: testStreamId } },
+      { method: 'streams.delete', params: { id: testStreamId } }
+    ]);
+  });
+});
+
+function findStream (streams, id) {
+  for (const s of streams) {
+    if (s.id === id) return s;
+    if (s.children) {
+      const found = findStream(s.children, id);
+      if (found) return found;
+    }
+  }
+  return null;
+}

package/test/buildSearchParams.test.js

@@ -0,0 +1,61 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, expect */
+
+const buildSearchParams = require('../src/lib/buildSearchParams');
+
+describe('[BSPX] buildSearchParams', function () {
+  it('[BSPA] builds params from simple object', function () {
+    const result = buildSearchParams({ foo: 'bar', num: 123 });
+    expect(result).to.equal('foo=bar&num=123');
+  });
+
+  it('[BSPB] handles arrays as repeated keys', function () {
+    const result = buildSearchParams({ tags: ['a', 'b', 'c'] });
+    expect(result).to.equal('tags=a&tags=b&tags=c');
+  });
+
+  it('[BSPC] handles mixed arrays and values', function () {
+    const result = buildSearchParams({
+      name: 'test',
+      ids: ['id1', 'id2'],
+      limit: 10
+    });
+    expect(result).to.include('name=test');
+    expect(result).to.include('ids=id1');
+    expect(result).to.include('ids=id2');
+    expect(result).to.include('limit=10');
+  });
+
+  it('[BSPD] ignores null and undefined values', function () {
+    const result = buildSearchParams({
+      valid: 'yes',
+      nullVal: null,
+      undefVal: undefined
+    });
+    expect(result).to.equal('valid=yes');
+  });
+
+  it('[BSPE] handles empty object', function () {
+    const result = buildSearchParams({});
+    expect(result).to.equal('');
+  });
+
+  it('[BSPF] encodes special characters', function () {
+    const result = buildSearchParams({ query: 'hello world', special: 'a=b&c=d' });
+    expect(result).to.include('query=hello+world');
+    expect(result).to.include('special=a%3Db%26c%3Dd');
+  });
+
+  it('[BSPG] handles boolean values', function () {
+    const result = buildSearchParams({ active: true, disabled: false });
+    expect(result).to.equal('active=true&disabled=false');
+  });
+
+  it('[BSPH] handles empty arrays', function () {
+    const result = buildSearchParams({ tags: [], name: 'test' });
+    expect(result).to.equal('name=test');
+  });
+});

package/test/json-parser.test.js

@@ -0,0 +1,198 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, expect */
+
+const jsonParser = require('../src/lib/json-parser');
+const { EventEmitter } = require('events');
+
+// Helper to create a mock response stream
+function createMockResponse (chunks) {
+  const emitter = new EventEmitter();
+  emitter.setEncoding = function () {};
+
+  // Emit chunks asynchronously
+  setTimeout(() => {
+    chunks.forEach(chunk => emitter.emit('data', chunk));
+    emitter.emit('end');
+  }, 0);
+
+  return emitter;
+}
+
+describe('[JPSX] json-parser', function () {
+  it('[JPSA] parses single event correctly', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"events":[{"id":"evt1","type":"note/txt"}],"meta":{"serverTime":1234567890}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].id).to.equal('evt1');
+      expect(body.eventsCount).to.equal(1);
+      done();
+    });
+  });
+
+  it('[JPSB] parses multiple events', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"events":[{"id":"e1"},{"id":"e2"},{"id":"e3"}],"meta":{"serverTime":123}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(3);
+      expect(body.eventsCount).to.equal(3);
+      done();
+    });
+  });
+
+  it('[JPSC] handles chunked data', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    // Split JSON across multiple chunks
+    const chunks = [
+      '{"events":[{"id":"ev',
+      '1","type":"test"},{"i',
+      'd":"ev2"}],"meta":{"serverTime":1}}'
+    ];
+    const mockRes = createMockResponse(chunks);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(2);
+      expect(events[0].id).to.equal('ev1');
+      expect(events[1].id).to.equal('ev2');
+      done();
+    });
+  });
+
+  it('[JPSD] handles empty events array', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"events":[],"meta":{"serverTime":123}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(0);
+      expect(body.eventsCount).to.equal(0);
+      done();
+    });
+  });
+
+  it('[JPSE] handles events with nested objects', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"events":[{"id":"e1","content":{"nested":{"deep":"value"}}}],"meta":{"serverTime":1}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].content.nested.deep).to.equal('value');
+      done();
+    });
+  });
+
+  it('[JPSF] handles events with strings containing special chars', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"events":[{"id":"e1","content":"line1\\nline2\\twith\\\\backslash"}],"meta":{"serverTime":1}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].content).to.include('line1');
+      done();
+    });
+  });
+
+  it('[JPSG] includes eventDeletions when includeDeletions is true', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), true);
+
+    // Split data into chunks to simulate real HTTP streaming
+    // The parser needs multiple data events to process state transitions correctly
+    const chunks = [
+      '{"events":[{"id":"e1"}]',
+      ',"eventDeletions":[{"id":"del1"}]',
+      ',"meta":{"serverTime":1}}'
+    ];
+    const mockRes = createMockResponse(chunks);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(2);
+      expect(body.eventsCount).to.equal(1);
+      expect(body.eventDeletionsCount).to.equal(1);
+      done();
+    });
+  });
+
+  it('[JPSH] handles invalid JSON gracefully', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = 'not valid json';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.exist;
+      expect(err.rawResponse).to.exist;
+      expect(err.statusCode).to.equal(200);
+      done();
+    });
+  });
+
+  it('[JPSI] handles events with quoted strings containing brackets', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"events":[{"id":"e1","content":"text with {braces} and [brackets]"}],"meta":{"serverTime":1}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(events).to.have.lengthOf(1);
+      expect(events[0].content).to.include('{braces}');
+      done();
+    });
+  });
+
+  it('[JPSJ] preserves meta and other root properties', function (done) {
+    const events = [];
+    const parser = jsonParser((event) => events.push(event), false);
+
+    const jsonData = '{"someProperty":"value","events":[{"id":"e1"}],"meta":{"serverTime":123,"apiVersion":"1.2.3"}}';
+    const mockRes = createMockResponse([jsonData]);
+    mockRes.statusCode = 200;
+
+    parser(mockRes, (err, body) => {
+      expect(err).to.be.undefined;
+      expect(body.someProperty).to.equal('value');
+      expect(body.meta.apiVersion).to.equal('1.2.3');
+      done();
+    });
+  });
+});

package/test/utils.test.js

@@ -4,13 +4,13 @@
  */
 /* global describe, it, before, expect, pryv, testData */
 
-describe('utils', function () {
+describe('[UTLX] utils', function () {
   before(async function () {
     this.timeout(15000);
     await testData.prepare();
   });
 
-  it('extractTokenAndAPIEndpoint', function (done) {
+  it('[UTLA] extractTokenAndAPIEndpoint', function (done) {
     const tokenAndAPI = pryv.utils
       .extractTokenAndAPIEndpoint(testData.apiEndpointWithToken);
     expect(testData.token).to.equal(tokenAndAPI.token);
@@ -19,7 +19,7 @@ describe('utils', function () {
     done();
   });
 
-  it('extractTokenAndAPIEndpoint should work without token', function (done) {
+  it('[UTLB] extractTokenAndAPIEndpoint should work without token', function (done) {
     const tokenAndAPI = pryv.utils
       .extractTokenAndAPIEndpoint(testData.apiEndpoint);
 
@@ -29,7 +29,7 @@ describe('utils', function () {
     done();
   });
 
-  it('extractTokenAndAPIEndpoint should fail on invalid url', function (done) {
+  it('[UTLC] extractTokenAndAPIEndpoint should fail on invalid url', function (done) {
     let error = null;
     try {
       pryv.utils.extractTokenAndAPIEndpoint('blip');
@@ -40,7 +40,7 @@ describe('utils', function () {
     expect(error).to.exist;
   });
 
-  it('buildAPIEndpoint with token', function (done) {
+  it('[UTLD] buildAPIEndpoint with token', function (done) {
     const apiEndpoint = pryv.utils
       .buildAPIEndpoint({
         token: testData.token,
@@ -50,7 +50,7 @@ describe('utils', function () {
     done();
   });
 
-  it('buildAPIEndpoint without token', function (done) {
+  it('[UTLE] buildAPIEndpoint without token', function (done) {
     const apiEndpoint = pryv.utils
       .buildAPIEndpoint({
         token: null,