completing test suite

Author: perki

components/pryv-monitor/src/index.js

@@ -15,7 +15,7 @@ module.exports = function (pryv) {
   console.log('Pryv version', pryv.version);
   // check version here
   if (pryv.Monitor) {
-    throw new Error('Monitor already loaded');
+    return; // already loaded
   }
   // sharing cross references
   pryv.Monitor = Monitor;

components/pryv/test/Accesses.test.js

@@ -0,0 +1,126 @@
+/**
+ * @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 testStreamId = 'acc-' + cuid().slice(0, 8);
+let createdAccessId = null;
+let createdAccessToken = null;
+
+describe('[ACSX] Accesses', () => {
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+    conn = new pryv.Connection(testData.apiEndpointWithToken);
+
+    // Create a test stream for permissions
+    await conn.api([{
+      method: 'streams.create',
+      params: { id: testStreamId, name: 'Access Test Stream' }
+    }]);
+  });
+
+  describe('[ACRX] accesses.create', function () {
+    it('[ACRA] create a shared access', async () => {
+      const res = await conn.api([{
+        method: 'accesses.create',
+        params: {
+          name: 'test-shared-' + cuid().slice(0, 8),
+          type: 'shared',
+          permissions: [{ streamId: testStreamId, level: 'read' }]
+        }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].access).to.exist;
+      expect(res[0].access.token).to.exist;
+      expect(res[0].access.type).to.equal('shared');
+      createdAccessId = res[0].access.id;
+      createdAccessToken = res[0].access.token;
+    });
+
+    it('[ACRB] create an app access', async () => {
+      const res = await conn.api([{
+        method: 'accesses.create',
+        params: {
+          name: 'test-app-' + cuid().slice(0, 8),
+          type: 'app',
+          permissions: [{ streamId: testStreamId, level: 'contribute' }]
+        }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].access).to.exist;
+      expect(res[0].access.type).to.equal('app');
+    });
+
+    it('[ACRC] reject access with invalid permission level', async () => {
+      const res = await conn.api([{
+        method: 'accesses.create',
+        params: {
+          name: 'bad-access',
+          type: 'shared',
+          permissions: [{ streamId: testStreamId, level: 'bogus' }]
+        }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].error).to.exist;
+    });
+  });
+
+  describe('[AGTX] accesses.get', function () {
+    it('[AGTA] list accesses', async () => {
+      const res = await conn.api([{
+        method: 'accesses.get',
+        params: {}
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].accesses).to.exist;
+      expect(Array.isArray(res[0].accesses)).to.equal(true);
+      expect(res[0].accesses.length).to.be.gt(0);
+    });
+
+    it('[AGTB] created access is in the list', async () => {
+      const res = await conn.api([{
+        method: 'accesses.get',
+        params: {}
+      }]);
+      const found = res[0].accesses.find(a => a.id === createdAccessId);
+      expect(found).to.exist;
+      expect(found.token).to.equal(createdAccessToken);
+    });
+  });
+
+  describe('[ADLX] accesses.delete', function () {
+    it('[ADLA] delete (revoke) an access', async () => {
+      expect(createdAccessId).to.exist;
+      const res = await conn.api([{
+        method: 'accesses.delete',
+        params: { id: createdAccessId }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].accessDeletion).to.exist;
+      expect(res[0].accessDeletion.id).to.equal(createdAccessId);
+    });
+
+    it('[ADLB] deleted access is no longer in the list', async () => {
+      const res = await conn.api([{
+        method: 'accesses.get',
+        params: {}
+      }]);
+      const found = res[0].accesses.find(a => a.id === createdAccessId);
+      expect(found).to.not.exist;
+    });
+  });
+
+  // Cleanup
+  after(async () => {
+    if (!conn) return;
+    await conn.api([
+      { method: 'streams.delete', params: { id: testStreamId } },
+      { method: 'streams.delete', params: { id: testStreamId } }
+    ]);
+  });
+});

components/pryv/test/Account.test.js

@@ -0,0 +1,73 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect, pryv, testData */
+
+let conn = null;
+
+describe('[ACTX] Account', () => {
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+    conn = new pryv.Connection(testData.apiEndpointWithToken);
+  });
+
+  describe('[AINX] account.get', function () {
+    it('[AINA] get account info', async () => {
+      const res = await conn.api([{
+        method: 'account.get',
+        params: {}
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].account).to.exist;
+      expect(res[0].account.username).to.equal(testData.username);
+      expect(res[0].account.email).to.exist;
+    });
+  });
+
+  describe('[ASUX] account.get storageUsed', function () {
+    it('[ASUA] storageUsed has expected fields', async () => {
+      const res = await conn.api([{
+        method: 'account.get',
+        params: {}
+      }]);
+      const account = res[0].account;
+      expect(account.storageUsed).to.exist;
+      expect(account.storageUsed.dbDocuments).to.be.a('number');
+      expect(account.storageUsed.attachedFiles).to.be.a('number');
+    });
+  });
+
+  describe('[ACPX] account.changePassword', function () {
+    it('[ACPA] change password and change back', async () => {
+      const oldPassword = testData.password;
+      const newPassword = oldPassword + '-new';
+
+      // Change to new password
+      const res1 = await conn.api([{
+        method: 'account.changePassword',
+        params: { oldPassword, newPassword }
+      }]);
+      expect(res1[0]).to.exist;
+      expect(res1[0].error).to.not.exist;
+
+      // Change back to original
+      const res2 = await conn.api([{
+        method: 'account.changePassword',
+        params: { oldPassword: newPassword, newPassword: oldPassword }
+      }]);
+      expect(res2[0]).to.exist;
+      expect(res2[0].error).to.not.exist;
+    });
+
+    it('[ACPB] reject wrong old password', async () => {
+      const res = await conn.api([{
+        method: 'account.changePassword',
+        params: { oldPassword: 'wrong-password', newPassword: 'new-password' }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].error).to.exist;
+    });
+  });
+});

components/pryv/test/Streams.test.js

@@ -0,0 +1,132 @@
+/**
+ * @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 testStreamId = 'str-' + cuid().slice(0, 8);
+const childStreamId = 'str-child-' + cuid().slice(0, 8);
+
+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: 'Test Stream' }
+      }]);
+      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('Test Stream');
+    });
+
+    it('[SCRB] create a child stream', async () => {
+      const res = await conn.api([{
+        method: 'streams.create',
+        params: { id: childStreamId, name: 'Child Stream', 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' }
+      }]);
+      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 Child' } }
+      }]);
+      expect(res[0]).to.exist;
+      expect(res[0].stream).to.exist;
+      expect(res[0].stream.name).to.equal('Renamed Child');
+    });
+  });
+
+  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;
+}