// Tests for the "remember me" checkbox of Syndria98/dragonroll#48: the login form lets the user keep // the session on the device, and a login without it ends when the browser does. // // `frontend/app/services/TokenStore.js` is dependency-free ESM, so it is imported for real against // stubbed browser storages; the flow around it is checked in the sources the same way // `tests/sidebar-entity-entry.test.js` reads its component. // // Run with `npm test` from the repository root, or `node --test tests/`. const { test } = require("node:test"); const assert = require("node:assert/strict"); const fs = require("node:fs"); const path = require("node:path"); const { pathToFileURL } = require("node:url"); function readSource(...parts) { return fs.readFileSync(path.join(__dirname, "..", ...parts), "utf8"); } const loginWindow = readSource("frontend", "app", "components", "windows", "LoginWindow.vue"); const serviceLink = readSource("frontend", "app", "components", "views", "ServiceLinkAuthorize.vue"); const user = readSource("frontend", "app", "services", "User.js"); const server = readSource("frontend", "app", "services", "Server.js"); const backendUser = readSource("backend", "src", "routes", "user.js"); // -- the token store, for real ------------------------------------------------ function fakeStorage() { const entries = new Map(); return { getItem: (key) => (entries.has(key) ? entries.get(key) : null), setItem: (key, value) => entries.set(key, String(value)), removeItem: (key) => entries.delete(key), }; } async function loadTokenStore() { const store = await import( pathToFileURL(path.join(__dirname, "..", "frontend", "app", "services", "TokenStore.js")).href ); // The module only touches the storages inside its functions, so fresh stubs per test are enough. globalThis.localStorage = fakeStorage(); globalThis.sessionStorage = fakeStorage(); return store; } test("a remembered login keeps the token in localStorage", async () => { const { GetToken, SetToken } = await loadTokenStore(); SetToken("tok", true); assert.equal(GetToken(), "tok"); assert.equal(globalThis.localStorage.getItem("token"), "tok"); assert.equal(globalThis.sessionStorage.getItem("token"), null); }); test("a login without remember keeps the token only for the browser session", async () => { const { GetToken, SetToken } = await loadTokenStore(); SetToken("tok", false); assert.equal(GetToken(), "tok"); assert.equal(globalThis.sessionStorage.getItem("token"), "tok"); // Closing the browser clears sessionStorage, so the session ends with it. assert.equal(globalThis.localStorage.getItem("token"), null); }); test("a new login replaces the token instead of leaving it in the other store", async () => { const { GetToken, SetToken, ClearToken } = await loadTokenStore(); SetToken("remembered", true); SetToken("session", false); assert.equal(globalThis.localStorage.getItem("token"), null); assert.equal(GetToken(), "session"); ClearToken(); SetToken("remembered", true); SetToken("session", false); SetToken("remembered-again", true); assert.equal(globalThis.sessionStorage.getItem("token"), null); assert.equal(GetToken(), "remembered-again"); }); test("clearing the token empties both stores", async () => { const { GetToken, ClearToken } = await loadTokenStore(); globalThis.localStorage.setItem("token", "leftover-remembered"); globalThis.sessionStorage.setItem("token", "leftover-session"); ClearToken(); assert.equal(globalThis.localStorage.getItem("token"), null); assert.equal(globalThis.sessionStorage.getItem("token"), null); assert.equal(GetToken(), null); }); // -- the login form ------------------------------------------------------------ test("the login form has a remember-me checkbox wired to the login", () => { assert.match(loginWindow, /type="checkbox"[^>]*v-model="remember"/, "expected a checkbox bound to `remember`"); assert.match(loginWindow, /\$t\('login\.remember-me'\)/, "the checkbox label must be translated"); assert.match(loginWindow, /post\('\/user\/login',\s*\{[^}]*remember:\s*remember\.value/, "the login request must carry the flag"); assert.match(loginWindow, /SetUser\(\s*data\.token,\s*remember\.value\s*\)/, "the token must be stored per the flag"); }); test("every place that reads the token goes through the token store", () => { for (const [name, source] of [["User.js", user], ["Server.js", server]]) { assert.doesNotMatch(source, /Storage\.getItem\(\s*['"]token['"]/, `${name} must not pick a store on its own`); assert.match(source, /from ['"]\.\/TokenStore['"]/, `${name} must import the token store`); assert.match(source, /GetToken\(\)/, `${name} must read the token through GetToken`); } const logout = /function LogoutUser\(\)\s*\{([\s\S]*?)\n\}/.exec(user)?.[1]; assert.ok(logout, "expected a LogoutUser function"); assert.match(logout, /ClearToken\(\)/, "logging out must clear the token from both stores"); }); test("the service link sign-in keeps its persistent session", () => { // That flow has no checkbox; passing remember explicitly keeps the token in localStorage as before. assert.match(serviceLink, /SetUser\(\s*response\.data\.token,\s*true\s*\)/); }); // -- the backend lifetime ------------------------------------------------------ test("a remembered login signs a longer-lived token", () => { assert.match(backendUser, /const\s*\{[^}]*remember[^}]*\}\s*=\s*req\.body/, "the login must read the flag"); const expiresIn = /expiresIn:\s*([^,})]+)/.exec(backendUser)?.[1]; assert.ok(expiresIn, "expected jwt.sign to set an expiresIn"); const [long, short] = expiresIn.match(/\d+/g).map(Number); assert.ok(long > short, `a remembered session (${long}s) must outlive a plain one (${short}s)`); assert.equal(short, 172800, "a plain login keeps the 48 h lifetime"); }); // -- i18n ---------------------------------------------------------------------- test("the remember-me label exists in every locale", () => { for (const lang of ["en", "es", "ca"]) { const strings = JSON.parse(readSource("frontend", "i18n", "locales", lang, "login.json")); assert.ok(strings["remember-me"]?.trim(), `locales/${lang}/login.json needs a remember-me string`); } });