pryv 3.12.1 → 3.14.2

package/test/Service.accessRequestHandoff.test.js

@@ -0,0 +1,153 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, afterEach, expect, pryv */
+
+/**
+ * [ARQH] Credential hand-off (shared-secret delivery) in `connectFromKey`.
+ *
+ * When an access request asked for `credentialHandoff: 'shared-secret'`, the
+ * ACCEPTED poll body carries a one-time `handoff` key and a token-less
+ * `apiEndpoint` instead of the token. `connectFromKey` must redeem that key
+ * once, build a token-bearing `Connection`, and reuse the cached result on a
+ * second call (the one-time secret cannot be redeemed twice). A legacy inline
+ * body must keep working unchanged.
+ *
+ * Driven through a stubbed global fetch: what is tested is this library's
+ * handling of the two ACCEPTED shapes.
+ */
+
+const SERVICE_INFO = {
+  register: 'https://reg.test.local/',
+  access: 'https://reg.test.local/access',
+  api: 'https://{username}.test.local/',
+  name: 'Test'
+};
+
+let keyCounter = 0;
+function freshKey () { return 'poll-key-' + (++keyCounter); }
+
+describe('[ARQH] auth-request credential hand-off', function () {
+  let realFetch;
+  let retrieveCalls;
+  let retrievePosts;
+
+  /**
+   * Stub fetch: serve service-info, answer the poll GET with `pollBody`, and
+   * answer `shared-secrets/retrieve` with `retrieveResponse` (counting calls).
+   */
+  function stubFetch (pollBody, retrieveResponse) {
+    realFetch = global.fetch;
+    retrieveCalls = 0;
+    retrievePosts = [];
+    global.fetch = async function (url, options) {
+      const u = String(url);
+      if (u.includes('shared-secrets/retrieve')) {
+        retrieveCalls++;
+        retrievePosts.push(JSON.parse(options.body));
+        return {
+          ok: retrieveResponse.ok !== false,
+          status: retrieveResponse.status || 200,
+          json: async () => retrieveResponse.body
+        };
+      }
+      if (u.includes('/access')) { // the poll GET
+        return { ok: true, status: 200, json: async () => pollBody };
+      }
+      return { ok: true, status: 200, json: async () => SERVICE_INFO }; // service-info
+    };
+  }
+
+  afterEach(function () {
+    if (realFetch) global.fetch = realFetch;
+    realFetch = null;
+  });
+
+  it('[SARH1] redeems a hand-off ACCEPTED body once and builds a token-bearing connection', async function () {
+    const key = freshKey();
+    stubFetch(
+      {
+        status: 'ACCEPTED',
+        username: 'alice',
+        apiEndpoint: 'https://alice.test.local/', // token-less
+        handoff: { type: 'shared-secret', key: 'evt1.' + 'a'.repeat(40) }
+      },
+      { body: { secret: { username: 'alice', token: 'tok-123', apiEndpoint: 'https://alice.test.local/' } } }
+    );
+
+    const service = new pryv.Service('https://reg.test.local/service/info');
+    await service.info();
+    const conn = await service.connectFromKey(key);
+
+    expect(retrieveCalls).to.equal(1);
+    expect(retrievePosts[0].key).to.equal('evt1.' + 'a'.repeat(40));
+    expect(conn.token).to.equal('tok-123');
+    expect(conn.apiEndpoint).to.contain('tok-123@');
+    expect(conn.apiEndpoint).to.contain('alice.test.local');
+  });
+
+  it('[SARH2] redeems only once across two connectFromKey calls for the same key (module cache)', async function () {
+    const key = freshKey();
+    stubFetch(
+      {
+        status: 'ACCEPTED',
+        username: 'bob',
+        apiEndpoint: 'https://bob.test.local/',
+        handoff: { type: 'shared-secret', key: 'evt2.' + 'b'.repeat(40) }
+      },
+      { body: { secret: { username: 'bob', token: 'tok-xyz', apiEndpoint: 'https://bob.test.local/' } } }
+    );
+
+    // Module-level convenience builds a fresh Service each call; the shared
+    // cache is what stops a second redeem of the one-shot secret.
+    const c1 = await pryv.connectFromKey(key, 'https://reg.test.local/service/info');
+    const c2 = await pryv.connectFromKey(key, 'https://reg.test.local/service/info');
+
+    expect(retrieveCalls).to.equal(1);
+    expect(c1.token).to.equal('tok-xyz');
+    expect(c2.token).to.equal('tok-xyz');
+  });
+
+  it('[SARH3] leaves a legacy inline ACCEPTED body unchanged (no retrieve)', async function () {
+    const key = freshKey();
+    stubFetch(
+      {
+        status: 'ACCEPTED',
+        username: 'carol',
+        token: 'tok-inline',
+        apiEndpoint: 'https://tok-inline@carol.test.local/'
+      },
+      { body: { secret: {} } }
+    );
+
+    const service = new pryv.Service('https://reg.test.local/service/info');
+    await service.info();
+    const conn = await service.connectFromKey(key);
+
+    expect(retrieveCalls).to.equal(0);
+    expect(conn.token).to.equal('tok-inline');
+  });
+
+  it('[SARH4] surfaces a consumed/expired hand-off as a PryvError telling the caller to restart', async function () {
+    const key = freshKey();
+    stubFetch(
+      {
+        status: 'ACCEPTED',
+        username: 'dan',
+        apiEndpoint: 'https://dan.test.local/',
+        handoff: { type: 'shared-secret', key: 'evt4.' + 'd'.repeat(40) }
+      },
+      { ok: false, status: 403, body: { error: { id: 'forbidden', message: 'used', data: { id: 'shared-secret-unavailable' } } } }
+    );
+
+    const service = new pryv.Service('https://reg.test.local/service/info');
+    await service.info();
+    let caught;
+    try {
+      await service.connectFromKey(key);
+    } catch (e) { caught = e; }
+    expect(caught).to.be.instanceof(pryv.PryvError);
+    expect(caught.id).to.equal('credential-handoff-failed');
+  });
+});

package/test/Service.errorBodies.test.js

@@ -0,0 +1,82 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, afterEach, expect, pryv */
+
+/**
+ * [SEBX] A malformed server answer never lands in the error message.
+ *
+ * `login`, `mfaVerify` and `startAccessRequest` throw when a 2xx answer lacks
+ * what they need. The answer may hold secrets (a misplaced token) or the
+ * request's data, and error messages end up in logs and on screen: it rides
+ * on `innerObject` only. `fetch` is stubbed: no server.
+ */
+
+const SECRET = 'S3CRET-in-the-answer';
+const SERVICE_INFO = {
+  register: 'https://reg.seb.test.local/',
+  access: 'https://access.seb.test.local/access/',
+  api: 'https://{username}.seb.test.local/',
+  name: 'Test'
+};
+
+describe('[SEBX] malformed answers stay out of error messages', function () {
+  let realFetch;
+
+  /** Service info on GET; `postBody` with HTTP 200 on every POST. */
+  function stubFetch (postBody) {
+    realFetch = global.fetch;
+    global.fetch = async function (url, options) {
+      if (options?.method === 'POST') return { ok: true, status: 200, json: async () => postBody };
+      return { ok: true, status: 200, json: async () => SERVICE_INFO };
+    };
+  }
+
+  afterEach(function () {
+    if (realFetch) global.fetch = realFetch;
+    realFetch = null;
+  });
+
+  async function caught (promise) {
+    try {
+      await promise;
+    } catch (e) {
+      return e;
+    }
+    throw new Error('expected a rejection');
+  }
+
+  it('[SEB1] login: an answer without token', async () => {
+    const body = { session: SECRET };
+    stubFetch(body);
+    const service = new pryv.Service('https://reg.seb.test.local/service/info');
+    const e = await caught(service.login('alice', 'pw', 'app-id'));
+    expect(e).to.be.instanceOf(pryv.PryvError);
+    expect(e.message).to.include('Invalid login response');
+    expect(e.message).to.not.include(SECRET);
+    expect(e.innerObject).to.deep.equal(body);
+  });
+
+  it('[SEB2] mfaVerify: an answer without token', async () => {
+    const body = { session: SECRET };
+    stubFetch(body);
+    const service = new pryv.Service('https://reg.seb.test.local/service/info');
+    const e = await caught(service.mfaVerify('alice', 'mfa-token', '123456'));
+    expect(e).to.be.instanceOf(pryv.PryvError);
+    expect(e.message).to.include('did not return a token');
+    expect(e.message).to.not.include(SECRET);
+    expect(e.innerObject).to.deep.equal(body);
+  });
+
+  it('[SEB3] startAccessRequest: an answer without key or poll', async () => {
+    const body = { requestedPermissions: [{ streamId: SECRET, level: 'read' }] };
+    stubFetch(body);
+    const service = new pryv.Service('https://reg.seb.test.local/service/info');
+    const e = await caught(service.startAccessRequest({ requestingAppId: 'app-id', requestedPermissions: [] }));
+    expect(e).to.be.instanceOf(pryv.PryvError);
+    expect(e.message).to.include('Invalid access-request response');
+    expect(e.message).to.not.include(SECRET);
+    expect(e.innerObject).to.deep.equal(body);
+  });
+});

package/test/Service.mfa.test.js

@@ -65,8 +65,8 @@ describe('[MFLX] Service MFA', function () {
     });
   });
 
-  describe('[MERX] MfaRequiredError', function () {
-    it('[MERA] is exported on the package root and extends PryvError', function () {
+  describe('[MFEX] MfaRequiredError', function () {
+    it('[MFEA] is exported on the package root and extends PryvError', function () {
       expect(pryv.MfaRequiredError).to.be.a('function');
       const err = new pryv.MfaRequiredError(
         'tok-abc',
@@ -81,7 +81,7 @@ describe('[MFLX] Service MFA', function () {
       expect(err.name).to.equal('MfaRequiredError');
     });
 
-    it('[MERB] picks up id/message from API error body when provided', function () {
+    it('[MFEB] picks up id/message from API error body when provided', function () {
       const err = new pryv.MfaRequiredError(
         'tok-xyz',
         { status: 401 },
@@ -91,7 +91,7 @@ describe('[MFLX] Service MFA', function () {
       expect(err.message).to.equal('custom msg');
     });
 
-    it('[MERC] surfaces the MFA method from the API body when present', function () {
+    it('[MFEC] surfaces the MFA method from the API body when present', function () {
       const totp = new pryv.MfaRequiredError(
         'tok-1',
         { status: 200 },

package/test/Service.pollUrlByKey.test.js

@@ -0,0 +1,114 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, afterEach, expect, pryv */
+
+/**
+ * [PUKX] Polling an auth request by key reaches the core that holds it.
+ *
+ * On a multi-core platform a pending auth request lives on the core that
+ * created it, and the server answers the access request with a poll URL on
+ * that core, while the service's `access` URL may reach any core. Polling by
+ * key must use the server-issued URL when this process started the request.
+ * Observed: the URLs actually fetched (a stubbed global fetch), not only the
+ * result.
+ */
+
+const pollUrls = require('../src/lib/pollUrls');
+const AuthController = require('../src/Auth/AuthController');
+const utils = require('../src/utils');
+
+const SERVICE_INFO = {
+  register: 'https://reg.mc.test.local/',
+  access: 'https://access.mc.test.local/access/',
+  api: 'https://{username}.mc.test.local/',
+  name: 'Test'
+};
+
+let keyCounter = 0;
+function freshKey () { return 'puk-key-' + (++keyCounter); }
+function corePoll (key) { return 'https://core-a.mc.test.local/reg/access/' + key; }
+
+describe('[PUKX] polling an auth request by key', function () {
+  let realFetch;
+  let gets;
+
+  /** service-info, POST <access> -> NEED_SIGNIN with a core poll URL, GET -> `pollBody` */
+  function stubFetch (key, pollBody) {
+    realFetch = global.fetch;
+    gets = [];
+    global.fetch = async function (url, options) {
+      const u = String(url);
+      if (options?.method === 'POST' && u === SERVICE_INFO.access) {
+        return { ok: true, status: 201, json: async () => ({ status: 'NEED_SIGNIN', key, poll: corePoll(key), authUrl: 'https://ui.mc.test.local/access?key=' + key, poll_rate_ms: 1000 }) };
+      }
+      if (u.includes('/access/')) {
+        gets.push(u);
+        return { ok: true, status: 200, json: async () => pollBody };
+      }
+      return { ok: true, status: 200, json: async () => SERVICE_INFO };
+    };
+  }
+
+  afterEach(function () {
+    if (realFetch) global.fetch = realFetch;
+    realFetch = null;
+  });
+
+  it('[PUK1] remembers valid entries only, keeps a bounded number and expires them', function () {
+    const realNow = Date.now;
+    pollUrls.clear();
+    try {
+      pollUrls.remember('puk1-a', 'https://core-a.example.com/reg/access/puk1-a');
+      pollUrls.remember('puk1-b', 'javascript:alert(1)');
+      pollUrls.remember(null, 'https://core-a.example.com/reg/access/x');
+      expect(pollUrls.lookup('puk1-a')).to.equal('https://core-a.example.com/reg/access/puk1-a');
+      expect(pollUrls.lookup('puk1-b')).to.equal(null);
+      for (let i = 0; i < pollUrls.MAX_ENTRIES; i++) pollUrls.remember('puk1-fill-' + i, 'https://c.example.com/' + i);
+      expect(pollUrls.lookup('puk1-a')).to.equal(null); // oldest dropped
+      expect(pollUrls.lookup('puk1-fill-' + (pollUrls.MAX_ENTRIES - 1))).to.equal('https://c.example.com/' + (pollUrls.MAX_ENTRIES - 1));
+      const later = realNow() + pollUrls.TTL_MS + 1000;
+      Date.now = () => later;
+      expect(pollUrls.lookup('puk1-fill-' + (pollUrls.MAX_ENTRIES - 1))).to.equal(null); // expired
+    } finally {
+      Date.now = realNow;
+      pollUrls.clear();
+    }
+  });
+
+  it('[PUK2] pollAccessRequest(key) and connectFromKey(key) poll the core URL the server issued', async function () {
+    const key = freshKey();
+    stubFetch(key, { status: 'ACCEPTED', username: 'alice', apiEndpoint: 'https://tok@alice.mc.test.local/', token: 'tok' });
+    const service = new pryv.Service(null, SERVICE_INFO);
+    const env = await service.startAccessRequest({ requestingAppId: 'puk', requestedPermissions: [] });
+    expect(env.poll).to.equal(corePoll(key));
+
+    await service.pollAccessRequest(key);
+    // a fresh Service, as pryv.connectFromKey(key, url) builds one
+    const connection = await new pryv.Service(null, SERVICE_INFO).connectFromKey(key);
+    expect(gets).to.deep.equal([corePoll(key), corePoll(key)]);
+    expect(connection.apiEndpoint).to.equal('https://tok@alice.mc.test.local/');
+  });
+
+  it('[PUK3] a key this process never saw falls back to access + key', async function () {
+    const key = freshKey();
+    stubFetch(key, { status: 'NEED_SIGNIN' });
+    await new pryv.Service(null, SERVICE_INFO).pollAccessRequest(key);
+    expect(gets).to.deep.equal([SERVICE_INFO.access + key]);
+  });
+
+  it('[PUK4] a sign-in started by the button is remembered for connectFromKey', async function () {
+    const key = freshKey();
+    const { fetchPost, fetchGet } = utils;
+    utils.fetchPost = async () => ({ response: { ok: true }, body: { status: 'NEED_SIGNIN', key, poll: corePoll(key), poll_rate_ms: 1, authUrl: 'https://ui.mc.test.local/access?key=' + key } });
+    utils.fetchGet = async () => ({ response: { status: 200 }, body: { status: 'REFUSED' } });
+    const service = { infoSync: () => SERVICE_INFO, assets: async () => ({}) };
+    const auth = new AuthController({ authRequest: { requestingAppId: 'puk4', requestedPermissions: [] } }, service);
+    auth.serviceInfo = SERVICE_INFO;
+    try {
+      await auth.startAuthRequest();
+    } finally { utils.fetchPost = fetchPost; utils.fetchGet = fetchGet; }
+    expect(pollUrls.lookup(key)).to.equal(corePoll(key));
+  });
+});

package/test/browser-index.html

@@ -1,6 +1,7 @@
 <!DOCTYPE html>
 <html lang="en">
 <head>
+  <meta charset="utf-8" />
   <title>Pryv JS lib browser tests</title>
   <link rel="stylesheet" href="https://unpkg.com/mocha@10.8.2/mocha.css" />
 </head>