ihasmail/server/src/accountinfo.test.ts

import { test } from "node:test";
import assert from "node:assert/strict";
import { getAccountInfo, hasStalwartRegistry, interpretAccountInfo } from "./upstream.js";

/**
 * The account locale used to be read only from `x:Account/get`, which needs
 * the `sysAccountGet` permission — one the built-in `user` role is not given.
 * Ordinary users therefore silently fell back to the browser locale. Stalwart
 * 0.16 exposes the same field on `x:AccountSettings`, which users *can* read,
 * so both are asked for and whichever answers wins. Both are 0.16 methods:
 * this is a permissions fallback, not a version one.
 */

type Responses = [string, Record<string, unknown>, string][];

const settingsOk = (locale: string): Responses[number] => ["x:AccountSettings/get", { list: [{ id: "singleton", locale }] }, "s"];
const accountOk = (locale: string): Responses[number] => ["x:Account/get", { list: [{ id: "a1", locale }] }, "a"];
const failed = (id: string, type: string): Responses[number] => ["error", { type }, id];

test("prefers the locale a regular user is allowed to read", () => {
  const info = interpretAccountInfo([settingsOk("de_DE.UTF-8"), accountOk("fr_FR")]);
  assert.equal(info.locale, "de-DE");
});

test("falls back to x:Account when the settings object is forbidden", () => {
  const info = interpretAccountInfo([failed("s", "forbidden"), accountOk("sr_RS@latin")]);
  assert.equal(info.locale, "sr-Latn-RS");
});

test("an account with no locale set yields none, rather than a guess", () => {
  const info = interpretAccountInfo([["x:AccountSettings/get", { list: [] }, "s"], failed("a", "forbidden")]);
  assert.equal(info.locale, null);
});

test("neither answering leaves the locale unknown", () => {
  assert.deepEqual(interpretAccountInfo([failed("s", "forbidden"), failed("a", "forbidden")]), { locale: null, edition: null, permissions: [] });
  assert.deepEqual(interpretAccountInfo([]), { locale: null, edition: null, permissions: [] });
});

test("locales that carry no language are dropped, not passed through", () => {
  assert.equal(interpretAccountInfo([settingsOk("C")]).locale, null);
  assert.equal(interpretAccountInfo([settingsOk("POSIX")]).locale, null);
});

test("a server without the registry is not asked for anything", async () => {
  // Sign-in refuses these, so getAccountInfo should never reach the wire for
  // one - and must not, since a server that cannot parse `urn:stalwart:jmap`
  // fails the whole request rather than the one call.
  const session = { capabilities: { "urn:ietf:params:jmap:core": {}, "urn:ietf:params:jmap:mail": {} }, accounts: {}, primaryAccounts: {} };
  const info = await getAccountInfo("session-unsupported", "Basic x", session as never);
  assert.deepEqual(info, { locale: null, edition: null, permissions: [] });
});

test("no capabilities at all is treated the same way", async () => {
  const info = await getAccountInfo("session-no-caps", "Basic x", { accounts: {}, primaryAccounts: {} } as never);
  assert.equal(info.locale, null);
});

/**
 * Where Stalwart actually advertises `urn:stalwart:jmap`.
 *
 * Not in the session-level `capabilities`: `Session::new` builds those from a
 * fixed list that has never carried this capability, in any 0.16.x. It is
 * handed out per-account instead, so it lands in `primaryAccounts` and in each
 * account's `accountCapabilities`. Looking only at the session level called
 * every real 0.16 server too old, which sent self-service credentials to a
 * REST endpoint 0.16 had removed and made the About page report the wrong
 * thing.
 *
 * This check now decides whether a sign-in is allowed at all, so getting it
 * wrong would lock every user out of a perfectly good server.
 */
const STALWART = "urn:stalwart:jmap";
const baseCaps = { "urn:ietf:params:jmap:core": {}, "urn:ietf:params:jmap:mail": {} };

test("a 0.16 server is recognised from primaryAccounts, where it advertises itself", () => {
  assert.equal(
    hasStalwartRegistry({ capabilities: baseCaps, accounts: {}, primaryAccounts: { [STALWART]: "a1" } }),
    true,
  );
});

test("a 0.16 server is recognised from an account's capabilities", () => {
  assert.equal(
    hasStalwartRegistry({
      capabilities: baseCaps,
      accounts: { a1: { accountCapabilities: { "urn:ietf:params:jmap:mail": {}, [STALWART]: {} } } },
      primaryAccounts: {},
    }),
    true,
  );
});

test("the session level still counts, for a server that ever advertises it there", () => {
  assert.equal(hasStalwartRegistry({ capabilities: { ...baseCaps, [STALWART]: {} }, accounts: {}, primaryAccounts: {} }), true);
});

test("a server that advertises it nowhere is one we do not support", () => {
  assert.equal(hasStalwartRegistry({ capabilities: baseCaps, accounts: { a1: { accountCapabilities: baseCaps } }, primaryAccounts: { "urn:ietf:params:jmap:mail": "a1" } }), false);
  assert.equal(hasStalwartRegistry(undefined), false);
});

test("a shared account carrying the capability is enough to recognise the server", () => {
  assert.equal(
    hasStalwartRegistry({
      capabilities: baseCaps,
      accounts: { a1: { accountCapabilities: baseCaps }, a2: { accountCapabilities: { [STALWART]: {} } } },
      primaryAccounts: {},
    }),
    true,
  );
});

/**
 * With a domain mapped to its own Stalwart (#238), everything asked about the
 * account has to go to that server. The locale lookup resolved Stalwart's
 * `apiUrl` against the default server instead, so a mapped account's locale
 * was requested from a server that had never heard of it.
 */
test("account info is asked of the server that issued the session", async () => {
  const seen: string[] = [];
  const realFetch = globalThis.fetch;
  globalThis.fetch = (async (input: string | URL | Request) => {
    seen.push(String(input instanceof Request ? input.url : input));
    return new Response(JSON.stringify({ methodResponses: [], edition: "oss" }), { status: 200, headers: { "content-type": "application/json" } });
  }) as typeof fetch;
  try {
    const session = {
      capabilities: baseCaps,
      accounts: { a1: { accountCapabilities: { [STALWART]: {} } } },
      primaryAccounts: { [STALWART]: "a1" },
      apiUrl: "https://mail.mapped.test/jmap/",
      baseUrl: "https://mail.mapped.test",
    };
    await getAccountInfo("session-mapped-domain", "Basic x", session as never);
  } finally {
    globalThis.fetch = realFetch;
  }
  assert.ok(seen.length >= 2, "asks for both the locale and the edition");
  for (const url of seen) assert.ok(url.startsWith("https://mail.mapped.test/"), `${url} went to the wrong server`);
});