pryv 3.0.3 → 3.1.0

package/test/Service.passwordReset.test.js

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect, pryv, testData */
+
+const { createId: cuid } = require('@paralleldrive/cuid2');
+
+describe('[PWRX] Service.requestPasswordReset', function () {
+  let service;
+
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+    service = new pryv.Service(testData.serviceInfoUrl);
+  });
+
+  it('[PWRA] rejects when required args are missing', async function () {
+    let caught;
+    try {
+      await service.requestPasswordReset(testData.username);
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).to.be.instanceOf(pryv.PryvError);
+  });
+
+  it('[PWRB] either resolves or throws PryvError (server may require trusted appId)', async function () {
+    this.timeout(15000);
+    // Pryv platforms typically restrict password-reset to a trusted-appId
+    // allowlist (pryv.me does). On a permissive deployment this resolves;
+    // on a stricter one we expect a structured PryvError, not a raw throw.
+    let caught;
+    try {
+      await service.requestPasswordReset(testData.username, 'jslib-test');
+    } catch (e) {
+      caught = e;
+    }
+    if (caught) {
+      expect(caught).to.be.instanceOf(pryv.PryvError);
+      expect(caught.status).to.be.gte(400);
+    }
+  });
+  // Note: a "user does not exist" path can't be exercised against pryv.me
+  // because per-user DNS doesn't resolve for unregistered usernames — fetch
+  // throws TypeError before any HTTP exchange. That's an environmental
+  // limit, not a code path; the bogus-reset-token test below covers the
+  // server-side error-mapping equivalent.
+});
+
+describe('[PWSX] Service.resetPassword', function () {
+  let service;
+
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+    service = new pryv.Service(testData.serviceInfoUrl);
+  });
+
+  it('[PWSA] rejects when required args are missing', async function () {
+    let caught;
+    try {
+      await service.resetPassword(testData.username, 'newpw', '', 'jslib-test');
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).to.be.instanceOf(pryv.PryvError);
+  });
+
+  it('[PWSB] throws PryvError with structured fields on bogus reset token', async function () {
+    this.timeout(15000);
+    let caught;
+    try {
+      await service.resetPassword(
+        testData.username,
+        testData.password + 'X',
+        'bogus-reset-token-' + cuid().slice(0, 8),
+        'jslib-test'
+      );
+    } catch (e) {
+      caught = e;
+    }
+    expect(caught).to.be.instanceOf(pryv.PryvError);
+    expect(caught.status).to.be.gte(400);
+    expect(caught.response).to.have.property('status');
+  });
+});

package/test/Service.userExists.test.js

@@ -0,0 +1,29 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect, pryv, testData */
+
+const { createId: cuid } = require('@paralleldrive/cuid2');
+
+describe('[USRX] Service.userExists', function () {
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+  });
+
+  it('[USRA] returns true for a registered user', async function () {
+    this.timeout(15000);
+    const service = new pryv.Service(testData.serviceInfoUrl);
+    const exists = await service.userExists(testData.username);
+    expect(exists).to.equal(true);
+  });
+
+  it('[USRB] returns false for an unknown user (404)', async function () {
+    this.timeout(15000);
+    const service = new pryv.Service(testData.serviceInfoUrl);
+    const fakeUser = 'no-' + cuid().slice(0, 12);
+    const exists = await service.userExists(fakeUser);
+    expect(exists).to.equal(false);
+  });
+});

package/test/Service.userIdForEmail.test.js

@@ -0,0 +1,30 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, expect, pryv, testData */
+
+const { createId: cuid } = require('@paralleldrive/cuid2');
+
+describe('[UEMX] Service.userIdForEmail', function () {
+  before(async function () {
+    this.timeout(15000);
+    await testData.prepare();
+  });
+
+  it('[UEMA] returns the username for a known email', async function () {
+    this.timeout(15000);
+    const service = new pryv.Service(testData.serviceInfoUrl);
+    const knownEmail = testData.username + '@pryv.io';
+    const userId = await service.userIdForEmail(knownEmail);
+    expect(userId).to.equal(testData.username);
+  });
+
+  it('[UEMB] returns null for an unknown email', async function () {
+    this.timeout(15000);
+    const service = new pryv.Service(testData.serviceInfoUrl);
+    const unknownEmail = 'ghost-' + cuid().slice(0, 12) + '@example.com';
+    const userId = await service.userIdForEmail(unknownEmail);
+    expect(userId).to.equal(null);
+  });
+});

package/test/utils.test.js

@@ -59,4 +59,48 @@ describe('[UTLX] utils', function () {
     expect(apiEndpoint).to.equal(testData.apiEndpoint);
     done();
   });
+
+  // Plan 66 — composite access references.
+
+  it('[UTLF] parseAccessRef on a bare cuid returns { base, serial: null }', function () {
+    const ref = pryv.utils.parseAccessRef('abc123def456');
+    expect(ref).to.eql({ base: 'abc123def456', serial: null });
+  });
+
+  it('[UTLG] parseAccessRef on a composite returns { base, serial }', function () {
+    const ref = pryv.utils.parseAccessRef('abc123:7');
+    expect(ref).to.eql({ base: 'abc123', serial: 7 });
+  });
+
+  it('[UTLH] parseAccessRef on garbage throws', function () {
+    expect(() => pryv.utils.parseAccessRef('')).to.throw();
+    expect(() => pryv.utils.parseAccessRef(':1')).to.throw();
+    expect(() => pryv.utils.parseAccessRef('abc:notanumber')).to.throw();
+    expect(() => pryv.utils.parseAccessRef('abc:0')).to.throw();
+    expect(() => pryv.utils.parseAccessRef('abc:-1')).to.throw();
+    expect(() => pryv.utils.parseAccessRef(null)).to.throw();
+  });
+
+  it('[UTLI] serializeAccessRef round-trips parseAccessRef', function () {
+    const samples = ['plainCuid', 'plainCuid:1', 'plainCuid:42'];
+    for (const s of samples) {
+      expect(pryv.utils.serializeAccessRef(pryv.utils.parseAccessRef(s))).to.equal(s);
+    }
+  });
+
+  it('[UTLJ] serializeAccessRef rejects bad inputs', function () {
+    expect(() => pryv.utils.serializeAccessRef(null)).to.throw();
+    expect(() => pryv.utils.serializeAccessRef({ base: '' })).to.throw();
+    expect(() => pryv.utils.serializeAccessRef({ base: 'abc', serial: 0 })).to.throw();
+    expect(() => pryv.utils.serializeAccessRef({ base: 'abc', serial: 1.5 })).to.throw();
+  });
+
+  it('[UTLK] StaleAccessIdError extends PryvError', function () {
+    const err = new pryv.StaleAccessIdError('stale!', { provided: 'abc:1', currentSerial: 2 });
+    expect(err).to.be.instanceOf(pryv.StaleAccessIdError);
+    expect(err).to.be.instanceOf(pryv.PryvError);
+    expect(err.data.provided).to.equal('abc:1');
+    expect(err.data.currentSerial).to.equal(2);
+    expect(err.name).to.equal('StaleAccessIdError');
+  });
 });