pryv 3.12.1 → 3.13.0

package/test/ProfileStore.test.js

@@ -0,0 +1,88 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, expect */
+
+const ProfileStore = require('../src/Auth/ProfileStore');
+
+const parent = { username: 'parent-doe', apiEndpoint: 'https://tok1@parent-doe.example.com/' };
+const kim = { username: 'kim-doe', apiEndpoint: 'https://tok2@kim-doe.example.com/', actingAs: { username: 'kim-doe', delegate: 'parent-doe' } };
+
+describe('[PSTX] ProfileStore', function () {
+  it('[PSTA] reads stored data of any version: nothing, deleted, a single account, several', function () {
+    expect(ProfileStore.read(null)).to.deep.equal({ active: null, profiles: [], authUrl: undefined });
+    expect(ProfileStore.read({ deleted: true }).profiles).to.deep.equal([]);
+    // a single account, as stored before profiles existed
+    const legacy = ProfileStore.read({ apiEndpoint: parent.apiEndpoint, username: parent.username, authUrl: 'https://ui.example.com/auth' });
+    expect(legacy.active).to.deep.equal(parent);
+    expect(legacy.profiles).to.deep.equal([parent]);
+    expect(legacy.authUrl).to.equal('https://ui.example.com/auth');
+    // the active account always comes first, once
+    const several = ProfileStore.read(Object.assign({}, kim, { profiles: [parent, kim] }));
+    expect(several.active).to.deep.equal(kim);
+    expect(several.profiles).to.deep.equal([kim, parent]);
+    // remembered accounts, none active
+    const none = ProfileStore.read({ profiles: [parent, kim] });
+    expect(none.active).to.equal(null);
+    expect(none.profiles).to.have.lengthOf(2);
+  });
+
+  it('[PSTB] activating keeps the most recent first, replaces the same username, and forgets beyond the limit', function () {
+    let store = ProfileStore.read(null);
+    store = ProfileStore.activate(store, parent);
+    store = ProfileStore.activate(store, kim);
+    expect(store.active.username).to.equal('kim-doe');
+    expect(store.profiles.map((p) => p.username)).to.deep.equal(['kim-doe', 'parent-doe']);
+    // a new sign-in to a remembered account replaces it (new token, flags cleared)
+    store = ProfileStore.markUnavailable(store, 'parent-doe');
+    store = ProfileStore.activate(store, Object.assign({}, parent, { apiEndpoint: 'https://tok3@parent-doe.example.com/' }));
+    expect(store.profiles).to.deep.equal([
+      { username: 'parent-doe', apiEndpoint: 'https://tok3@parent-doe.example.com/' },
+      kim
+    ]);
+    // the least recently used account goes first; the active one stays
+    for (let i = 0; i < 6; i++) {
+      store = ProfileStore.activate(store, { username: 'u' + i, apiEndpoint: 'https://t@u' + i + '.example.com/' }, 3);
+    }
+    expect(store.profiles.map((p) => p.username)).to.deep.equal(['u5', 'u4', 'u3']);
+    expect(ProfileStore.activate(store, parent).profiles).to.have.lengthOf(ProfileStore.DEFAULT_LIMIT - 1);
+  });
+
+  it('[PSTC] the stored form keeps the active account at the top level, readable by versions without profiles', function () {
+    const store = ProfileStore.activate(ProfileStore.activate(ProfileStore.read(null), parent), kim);
+    const data = ProfileStore.write(Object.assign(store, { authUrl: 'https://ui.example.com/auth' }));
+    expect(data.username).to.equal('kim-doe');
+    expect(data.apiEndpoint).to.equal(kim.apiEndpoint);
+    expect(data.actingAs).to.deep.equal(kim.actingAs);
+    expect(data.authUrl).to.equal('https://ui.example.com/auth');
+    expect(data.profiles).to.deep.equal([kim, parent]);
+    // no active account: no top-level credentials, so nothing signs in on reload
+    const loggedOut = ProfileStore.write(ProfileStore.remove(store, 'kim-doe'));
+    expect(loggedOut.username).to.equal(undefined);
+    expect(loggedOut.apiEndpoint).to.equal(undefined);
+    expect(loggedOut.profiles).to.deep.equal([parent]);
+    expect(ProfileStore.write(ProfileStore.read(null))).to.equal(null);
+    // unknown fields are not stored
+    const extra = ProfileStore.write(ProfileStore.activate(ProfileStore.read(null), Object.assign({ token: 'x', other: 1 }, parent)));
+    expect(extra.profiles[0]).to.deep.equal(parent);
+  });
+
+  it('[PSTD] a revoked account stays listed as unavailable and is no longer active', function () {
+    const store = ProfileStore.markUnavailable(ProfileStore.activate(ProfileStore.activate(ProfileStore.read(null), parent), kim), 'kim-doe');
+    expect(store.active).to.equal(null);
+    expect(store.profiles.find((p) => p.username === 'kim-doe').unavailable).to.equal(true);
+    const reread = ProfileStore.read(ProfileStore.write(store));
+    expect(reread.active).to.equal(null);
+    expect(reread.profiles.find((p) => p.username === 'kim-doe').unavailable).to.equal(true);
+  });
+
+  it('[PSTE] an ACCEPTED body marks the account as used through delegation only when its hint names that account', function () {
+    const hint = { isDelegatedAccess: true, controlledUsername: 'kim-doe', delegate: { username: 'parent-doe' } };
+    expect(ProfileStore.fromAccepted({ username: 'kim-doe', apiEndpoint: kim.apiEndpoint, delegation: hint })).to.deep.equal(kim);
+    expect(ProfileStore.fromAccepted({ username: 'parent-doe', apiEndpoint: parent.apiEndpoint })).to.deep.equal(parent);
+    // a hint about another account is ignored
+    expect(ProfileStore.fromAccepted({ username: 'lou-doe', apiEndpoint: 'https://t@lou.example.com/', delegation: hint }).actingAs).to.equal(undefined);
+    expect(ProfileStore.fromAccepted({ username: 'kim-doe', apiEndpoint: kim.apiEndpoint, delegation: { controlledUsername: 'kim-doe', delegate: { username: 'p' } } }).actingAs).to.equal(undefined);
+  });
+});

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/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>