137 lines
6.3 KiB
JavaScript
137 lines
6.3 KiB
JavaScript
// 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`);
|
|
}
|
|
});
|