Files
zyt/identity-admin/tests/http.test.mjs
T
2026-11-11 13:53:14 +08:00

505 lines
28 KiB
JavaScript

import assert from 'node:assert/strict';
import { randomBytes } from 'node:crypto';
import test from 'node:test';
const suppliedBaseUrl = process.env.IAM_TEST_BASE_URL;
const allowWrite = process.env.IAM_TEST_ALLOW_WRITE === '1';
const account = process.env.IAM_TEST_ACCOUNT;
const password = process.env.IAM_TEST_PASSWORD;
const validationStatuses = [400, 409, 422];
const prefix = `iamtest_${Date.now().toString(36)}_${randomBytes(4).toString('hex')}`;
const testPassword = `Iam!${randomBytes(8).toString('hex')}aA3`;
function localBaseUrl(rawUrl) {
const url = new URL(rawUrl);
assert.ok(['http:', 'https:'].includes(url.protocol), 'Use an HTTP(S) test server');
assert.ok(['localhost', '127.0.0.1'].includes(url.hostname), 'Tests may only connect to localhost or 127.0.0.1');
assert.equal(url.username, '', 'Do not put credentials in IAM_TEST_BASE_URL');
assert.equal(url.password, '', 'Do not put credentials in IAM_TEST_BASE_URL');
assert.equal(url.search, '', 'IAM_TEST_BASE_URL must not contain a query');
assert.equal(url.hash, '', 'IAM_TEST_BASE_URL must not contain a fragment');
url.pathname = url.pathname.replace(/\/+$/, '');
assert.equal(url.pathname, '/adminapi', 'IAM_TEST_BASE_URL must end with /adminapi');
return url;
}
function flattenTree(nodes) {
assert.ok(Array.isArray(nodes), 'Expected a tree array');
return nodes.flatMap((node) => [node, ...flattenTree(node.children ?? [])]);
}
function ids(values) {
assert.ok(Array.isArray(values), 'Expected an ID array');
return values.map(Number).sort((a, b) => a - b);
}
function isRoot(value) {
return value === true || value === 1 || value === '1';
}
test('identity-admin HTTP integration', {
concurrency: false,
skip: !suppliedBaseUrl && 'Set IAM_TEST_BASE_URL to an isolated local /adminapi server',
}, async (t) => {
// Validate before issuing any request, including public GETs. Fetch must never follow redirects.
const baseUrl = localBaseUrl(suppliedBaseUrl);
async function request(path, { method = 'GET', token, body } = {}) {
assert.ok(method === 'GET' || allowWrite, 'Non-GET requests require IAM_TEST_ALLOW_WRITE=1');
const response = await fetch(`${baseUrl.href.replace(/\/$/, '')}/${path.replace(/^\//, '')}`, {
method,
redirect: 'error',
signal: AbortSignal.timeout(15_000),
headers: {
Accept: 'application/json',
...(body === undefined ? {} : { 'Content-Type': 'application/json' }),
...(token ? { Authorization: `Bearer ${token}` } : {}),
},
...(body === undefined ? {} : { body: JSON.stringify(body) }),
});
let envelope;
try {
envelope = JSON.parse(await response.text());
} catch {
assert.fail(`${method} ${path} returned non-JSON (HTTP ${response.status})`);
}
assert.ok(envelope && typeof envelope === 'object' && !Array.isArray(envelope), `${method} ${path}: expected a response envelope`);
return { status: response.status, envelope, path, method };
}
function success(result) {
const context = `${result.method} ${result.path}: HTTP ${result.status}, ${result.envelope.msg ?? ''}`;
assert.ok(result.status >= 200 && result.status < 300, context);
assert.equal(result.envelope.code, 1, context);
return result.envelope.data;
}
function failure(result, statuses) {
const context = `${result.method} ${result.path}: HTTP ${result.status}, ${result.envelope.msg ?? ''}`;
assert.ok(statuses.includes(result.status), `${context}; expected ${statuses.join('/')}`);
assert.equal(result.envelope.code, 0, context);
}
await t.test('health is public and protected endpoints reject missing or invalid sessions', async () => {
success(await request('health'));
failure(await request('auth.admin/mySelf'), [401]);
failure(await request('auth.admin/mySelf', { token: `invalid-${prefix}` }), [401]);
});
await t.test('authenticated and mutation scenarios', {
concurrency: false,
skip: !allowWrite && 'Set IAM_TEST_ALLOW_WRITE=1; login also creates a session',
}, async (suite) => {
assert.ok(account, 'Set IAM_TEST_ACCOUNT to the initialized root account');
assert.ok(password, 'Set IAM_TEST_PASSWORD to its explicitly chosen password');
let rootToken;
let rootSelf;
let options;
const records = [];
const fixture = {};
async function login(loginAccount, loginPassword) {
const data = success(await request('login/account', {
method: 'POST', body: { account: loginAccount, password: loginPassword },
}));
assert.equal(typeof data?.token, 'string', 'Login must return a token');
assert.ok(data.token.length > 0, 'Login token must not be empty');
return data.token;
}
async function rows(kind) {
if (kind === 'dept' || kind === 'menu') {
return flattenTree(success(await request(`auth.${kind}/lists`, { token: rootToken })));
}
const result = [];
for (let page = 1; ; page += 1) {
const data = success(await request(`auth.${kind}/lists?page_no=${page}&page_size=100&keyword=${encodeURIComponent(prefix)}`, { token: rootToken }));
assert.ok(Array.isArray(data?.lists), `Expected ${kind} lists`);
result.push(...data.lists);
if (data.lists.length === 0 || result.length >= Number(data.count)) break;
assert.ok(page < 100, 'Pagination did not terminate');
}
return result;
}
async function findRecord(kind, marker) {
return (await rows(kind)).find((row) => (kind === 'admin' ? row.account : row.name) === marker);
}
// Register successful creation before asserting the HTTP status or looking up its ID.
// This also catches an authorization regression that unexpectedly accepts an add request.
function registerCreated(kind, fields, result) {
if (result.envelope.code !== 1) return undefined;
const data = result.envelope.data;
const candidate = data && typeof data === 'object' ? data.id : data;
const id = Number(candidate);
const record = {
kind,
marker: kind === 'admin' ? fields.account : fields.name,
id: Number.isInteger(id) && id > 0 ? id : undefined,
};
records.push(record);
return record;
}
async function create(kind, fields) {
const result = await request(`auth.${kind}/add`, { method: 'POST', token: rootToken, body: fields });
const tracked = registerCreated(kind, fields, result);
success(result);
assert.ok(tracked, `Could not track new ${kind}`);
const row = await findRecord(kind, tracked.marker);
assert.ok(row, `New ${kind} must appear in lists`);
tracked.id = Number(row.id);
assert.ok(Number.isInteger(tracked.id) && tracked.id > 0, 'Created ID must be a positive integer');
assert.notEqual(tracked.id, kind === 'admin' ? Number(rootSelf.id) : -1, 'Never treat the initialized root as a fixture');
return { ...fields, ...row, id: tracked.id };
}
async function edit(kind, fields) {
return request(`auth.${kind}/edit`, { method: 'POST', token: rootToken, body: fields });
}
async function remove(kind, id, token = rootToken) {
return request(`auth.${kind}/delete`, { method: 'POST', token, body: { id } });
}
async function expectRejectedAdd(kind, fields, statuses = validationStatuses) {
const result = await request(`auth.${kind}/add`, { method: 'POST', token: rootToken, body: fields });
registerCreated(kind, fields, result);
failure(result, statuses);
}
function adminFields(row, overrides = {}) {
return {
id: row.id, account: row.account, name: row.name, disable: row.disable,
role_id: row.role_id, dept_id: row.dept_id, password: '', ...overrides,
};
}
function roleFields(row, overrides = {}) {
return {
id: row.id, name: row.name, desc: row.desc ?? '', sort: row.sort ?? 0,
disable: row.disable ?? 0, menu_id: row.menu_id, ...overrides,
};
}
function deptFields(row, overrides = {}) {
return { id: row.id, pid: row.pid, name: row.name, sort: row.sort ?? 0, disable: row.disable ?? 0, ...overrides };
}
function menuFields(row, overrides = {}) {
return {
id: row.id, pid: row.pid, type: row.type, name: row.name, paths: row.paths ?? '',
component: row.component ?? '', perms: row.perms ?? '', icon: row.icon ?? '',
sort: row.sort ?? 0, is_show: row.is_show ?? 1, disable: row.disable ?? 0, ...overrides,
};
}
async function cleanup() {
const errors = [];
for (const record of [...records].reverse()) {
try {
const matching = (await rows(record.kind)).filter((row) => (record.kind === 'admin' ? row.account : row.name) === record.marker);
const current = record.id === undefined ? matching[0] : matching.find((row) => Number(row.id) === record.id);
if (!current) continue; // The test may already have removed its own record.
const currentId = Number(current.id);
assert.ok(record.marker.startsWith(prefix), 'Cleanup is limited to this run\'s random prefix');
if (record.id !== undefined) assert.equal(currentId, record.id, 'Cleanup ID changed');
if (record.kind === 'admin') assert.notEqual(currentId, Number(rootSelf.id), 'Cleanup must never delete root');
success(await remove(record.kind, currentId));
} catch (error) {
errors.push(`${record.kind} ${record.marker}: ${error.message}`);
}
}
assert.deepEqual(errors, [], `Fixture cleanup failed; inspect only records beginning with ${prefix}`);
}
try {
try {
await suite.test('login → mySelf and options; unknown endpoint is 404', async () => {
rootToken = await login(account, password);
rootSelf = success(await request('auth.admin/mySelf', { token: rootToken }));
assert.equal(rootSelf.account, account);
assert.ok(Number(rootSelf.id) > 0);
assert.ok(isRoot(rootSelf.is_root), 'Run against the initialized root account');
for (const field of ['role_id', 'dept_id', 'permissions', 'menus']) assert.ok(Array.isArray(rootSelf[field]), `mySelf.${field} must be an array`);
assert.ok(rootSelf.permissions.includes('*'));
options = success(await request('auth/options', { token: rootToken }));
for (const field of ['roles', 'depts', 'menus']) assert.ok(Array.isArray(options[field]), `options.${field} must be an array`);
failure(await request(`missing-${prefix}`, { token: rootToken }), [404]);
});
if (!rootSelf || !options) return;
let fixtureReady = false;
await suite.test('create departments, menus, roles and a user with multiple roles and departments', async () => {
const allMenus = flattenTree(options.menus);
const permissionIds = (permission) => {
const matching = allMenus.filter((menu) => menu.perms === permission && Number(menu.disable) === 0);
assert.ok(matching.length > 0, `Initialization must provide ${permission}`);
return matching.map((menu) => Number(menu.id));
};
fixture.userReadMenuIds = permissionIds('auth.admin/lists');
fixture.deptReadMenuIds = permissionIds('auth.dept/lists');
fixture.parentDept = await create('dept', { pid: 0, name: `${prefix}_parent`, sort: 0, disable: 0 });
fixture.childDept = await create('dept', { pid: fixture.parentDept.id, name: `${prefix}_child`, sort: 0, disable: 0 });
fixture.otherDept = await create('dept', { pid: 0, name: `${prefix}_other`, sort: 0, disable: 0 });
const directory = { type: 'M', paths: '', component: '', perms: '', icon: '', sort: 0, is_show: 1, disable: 0 };
fixture.parentMenu = await create('menu', { ...directory, pid: 0, name: `${prefix}_menu_parent` });
fixture.childMenu = await create('menu', { ...directory, pid: fixture.parentMenu.id, name: `${prefix}_menu_child` });
fixture.customMenu = await create('menu', {
...directory, pid: fixture.childMenu.id, type: 'C', name: `${prefix}_custom`,
paths: `/${prefix}_custom`, component: 'common/custom', perms: 'auth.admin/lists',
});
fixture.userRole = await create('role', { name: `${prefix}_users`, desc: 'HTTP test', sort: 0, disable: 0, menu_id: fixture.userReadMenuIds });
fixture.deptRole = await create('role', { name: `${prefix}_depts`, desc: 'HTTP test', sort: 0, disable: 0, menu_id: fixture.deptReadMenuIds });
fixture.user = await create('admin', {
account: `${prefix}_user`, name: `${prefix}_user`, password: testPassword, disable: 0,
role_id: [fixture.userRole.id, fixture.deptRole.id], dept_id: [fixture.childDept.id, fixture.otherDept.id],
});
assert.deepEqual(ids(fixture.user.role_id), ids([fixture.userRole.id, fixture.deptRole.id]));
assert.deepEqual(ids(fixture.user.dept_id), ids([fixture.childDept.id, fixture.otherDept.id]));
fixture.token = await login(fixture.user.account, testPassword);
fixtureReady = true;
});
if (!fixtureReady) return;
const missingId = Math.max(
...flattenTree(options.depts).map((row) => Number(row.id)),
...flattenTree(options.menus).map((row) => Number(row.id)),
...options.roles.map((row) => Number(row.id)),
...records.map((record) => record.id ?? 0), 0,
) + 1_000_000;
await suite.test('account uniqueness and nonexistent associations are validated', async () => {
const duplicate = { ...adminFields(fixture.user), password: testPassword };
delete duplicate.id;
await expectRejectedAdd('admin', duplicate);
const base = {
name: `${prefix}_invalid`, password: testPassword, disable: 0,
role_id: [fixture.userRole.id], dept_id: [fixture.childDept.id],
};
await expectRejectedAdd('admin', { ...base, account: `${prefix}_rmiss`, role_id: [missingId] });
await expectRejectedAdd('admin', { ...base, account: `${prefix}_dmiss`, dept_id: [missingId] });
await expectRejectedAdd('role', { name: `${prefix}_bad_menu`, desc: '', sort: 0, disable: 0, menu_id: [missingId] });
});
await suite.test('reserved and malformed custom-page paths are rejected with HTTP 422', async (paths) => {
const rejectedPaths = [
'/login', '/profile', '/403',
`//${prefix}`, `/${prefix}//page`, `/${prefix}/`, '/dashboard',
];
for (const [index, path] of rejectedPaths.entries()) {
await paths.test(path, async () => {
await expectRejectedAdd('menu', {
pid: 0, type: 'C', name: `${prefix}_bad_path${index}`, paths: path,
component: 'common/custom', perms: 'auth.admin/lists', icon: '',
sort: 0, is_show: 1, disable: 0,
}, [422]);
});
}
});
await suite.test('department and menu cycles are rejected without changing the tree', async () => {
failure(await edit('dept', deptFields(fixture.parentDept, { pid: fixture.childDept.id })), validationStatuses);
failure(await edit('dept', deptFields(fixture.childDept, { pid: fixture.childDept.id })), validationStatuses);
failure(await edit('menu', menuFields(fixture.parentMenu, { pid: fixture.childMenu.id })), validationStatuses);
failure(await edit('menu', menuFields(fixture.childMenu, { pid: fixture.childMenu.id })), validationStatuses);
assert.equal(Number((await findRecord('dept', fixture.parentDept.name)).pid), 0);
assert.equal(Number((await findRecord('menu', fixture.parentMenu.name)).pid), 0);
});
await suite.test('child nodes and user associations protect departments, menus and roles from deletion', async () => {
failure(await remove('dept', fixture.parentDept.id), validationStatuses);
failure(await remove('dept', fixture.childDept.id), validationStatuses);
failure(await remove('role', fixture.userRole.id), validationStatuses);
failure(await remove('menu', fixture.parentMenu.id), validationStatuses);
assert.ok(await findRecord('dept', fixture.childDept.name));
assert.ok(await findRecord('role', fixture.userRole.name));
assert.ok(await findRecord('menu', fixture.parentMenu.name));
});
await suite.test('multiple roles contribute a permission union to an existing session', async () => {
const self = success(await request('auth.admin/mySelf', { token: fixture.token }));
assert.deepEqual(ids(self.role_id), ids([fixture.userRole.id, fixture.deptRole.id]));
assert.deepEqual(ids(self.dept_id), ids([fixture.childDept.id, fixture.otherDept.id]));
assert.ok(self.permissions.includes('auth.admin/lists'));
assert.ok(self.permissions.includes('auth.dept/lists'));
assert.ok(!self.permissions.includes('*'));
success(await request('auth.admin/lists?page_no=1&page_size=100', { token: fixture.token }));
success(await request('auth.dept/lists', { token: fixture.token }));
failure(await request('auth.role/lists?page_no=1&page_size=100', { token: fixture.token }), [403]);
});
await suite.test('disabling a role immediately removes its permissions from the existing token', async () => {
const token = fixture.token;
success(await request('auth.admin/lists?page_no=1&page_size=100', { token }));
try {
success(await edit('role', roleFields(fixture.userRole, { disable: 1 })));
failure(await request('auth.admin/lists?page_no=1&page_size=100', { token }), [403]);
success(await request('auth.dept/lists', { token }));
const self = success(await request('auth.admin/mySelf', { token }));
assert.ok(!self.permissions.includes('auth.admin/lists'));
assert.ok(self.permissions.includes('auth.dept/lists'));
} finally {
success(await edit('role', roleFields(fixture.userRole)));
}
success(await request('auth.admin/lists?page_no=1&page_size=100', { token }));
});
await suite.test('a saved custom page is visible in mySelf after its role grant', async () => {
try {
success(await edit('role', roleFields(fixture.userRole, { menu_id: [fixture.customMenu.id] })));
const self = success(await request('auth.admin/mySelf', { token: fixture.token }));
const menus = flattenTree(self.menus);
const custom = menus.find((menu) => Number(menu.id) === fixture.customMenu.id);
assert.ok(custom, 'The granted custom page must appear in mySelf.menus');
assert.equal(custom.paths, fixture.customMenu.paths);
assert.equal(custom.component, 'common/custom');
assert.equal(custom.perms, 'auth.admin/lists');
assert.ok(menus.some((menu) => Number(menu.id) === fixture.parentMenu.id), 'Granted pages retain their ancestors');
assert.ok(menus.some((menu) => Number(menu.id) === fixture.childMenu.id));
assert.ok(self.permissions.includes('auth.admin/lists'));
success(await request('auth.admin/lists?page_no=1&page_size=100', { token: fixture.token }));
} finally {
success(await edit('role', roleFields(fixture.userRole)));
}
});
await suite.test('disabling an ancestor menu immediately removes descendant permissions from the existing token', async () => {
const token = fixture.token;
try {
// Remove the seeded grant, so this permission is supplied only by our own descendant page.
success(await edit('role', roleFields(fixture.userRole, { menu_id: [fixture.customMenu.id] })));
success(await request('auth.admin/lists?page_no=1&page_size=100', { token }));
success(await edit('menu', menuFields(fixture.parentMenu, { disable: 1 })));
failure(await request('auth.admin/lists?page_no=1&page_size=100', { token }), [403]);
success(await request('auth.dept/lists', { token }));
const self = success(await request('auth.admin/mySelf', { token }));
assert.ok(!self.permissions.includes('auth.admin/lists'));
assert.ok(self.permissions.includes('auth.dept/lists'));
const menus = flattenTree(self.menus);
for (const menu of [fixture.parentMenu, fixture.childMenu, fixture.customMenu]) {
assert.ok(!menus.some((row) => Number(row.id) === menu.id), 'Disabled ancestors and their descendants must leave mySelf.menus');
}
success(await edit('menu', menuFields(fixture.parentMenu)));
success(await request('auth.admin/lists?page_no=1&page_size=100', { token }));
assert.ok(flattenTree(success(await request('auth.admin/mySelf', { token })).menus)
.some((menu) => Number(menu.id) === fixture.customMenu.id), 'Re-enabling an ancestor restores the granted page on the same token');
} finally {
success(await edit('menu', menuFields(fixture.parentMenu)));
success(await edit('role', roleFields(fixture.userRole)));
}
});
await suite.test('a read-only account receives HTTP 403 from every write endpoint', async (permissions) => {
const payloads = {
admin: { account: `${prefix}_deny`, name: `${prefix}_deny`, password: testPassword, disable: 0, role_id: [], dept_id: [] },
role: { name: `${prefix}_denied_role`, desc: '', sort: 0, disable: 0, menu_id: [] },
dept: { name: `${prefix}_denied_dept`, pid: 0, sort: 0, disable: 0 },
menu: { name: `${prefix}_denied_menu`, pid: 0, type: 'M', paths: '', component: '', perms: '', icon: '', sort: 0, is_show: 1, disable: 0 },
};
for (const [kind, fields] of Object.entries(payloads)) {
for (const action of ['add', 'edit', 'delete']) {
await permissions.test(`${kind}/${action}`, async () => {
const body = action === 'add' ? fields : action === 'edit' ? { ...fields, id: missingId } : { id: missingId };
const result = await request(`auth.${kind}/${action}`, { method: 'POST', token: fixture.token, body });
if (action === 'add') registerCreated(kind, fields, result);
failure(result, [403]);
});
}
}
});
await suite.test('menu_id=[] clears authorization immediately while the other role remains effective', async () => {
try {
success(await edit('role', roleFields(fixture.userRole, { menu_id: [] })));
const role = await findRecord('role', fixture.userRole.name);
assert.deepEqual(role.menu_id, [], 'An empty menu_id must be persisted');
failure(await request('auth.admin/lists?page_no=1&page_size=100', { token: fixture.token }), [403]);
success(await request('auth.dept/lists', { token: fixture.token }));
const self = success(await request('auth.admin/mySelf', { token: fixture.token }));
assert.ok(!self.permissions.includes('auth.admin/lists'));
assert.ok(self.permissions.includes('auth.dept/lists'));
} finally {
success(await edit('role', roleFields(fixture.userRole)));
}
success(await request('auth.admin/lists?page_no=1&page_size=100', { token: fixture.token }));
});
await suite.test('a disabled department cannot receive a new user association', async () => {
try {
success(await edit('dept', deptFields(fixture.otherDept, { disable: 1 })));
await expectRejectedAdd('admin', {
account: `${prefix}_off`, name: `${prefix}_disabled_dept`, password: testPassword,
disable: 0, role_id: [fixture.userRole.id], dept_id: [fixture.otherDept.id],
});
} finally {
success(await edit('dept', deptFields(fixture.otherDept)));
}
});
await suite.test('disabling an account invalidates its existing session and prevents login', async () => {
try {
success(await edit('admin', adminFields(fixture.user, { disable: 1 })));
failure(await request('auth.admin/mySelf', { token: fixture.token }), [401]);
failure(await request('login/account', { method: 'POST', body: { account: fixture.user.account, password: testPassword } }), [401]);
} finally {
success(await edit('admin', adminFields(fixture.user, { disable: 0 })));
}
fixture.token = await login(fixture.user.account, testPassword);
});
await suite.test('logout revokes the current token', async () => {
const token = await login(fixture.user.account, testPassword);
success(await request('login/logout', { method: 'POST', token }));
failure(await request('auth.admin/mySelf', { token }), [401]);
success(await request('auth.admin/mySelf', { token: fixture.token }));
});
await suite.test('changing password revokes all old tokens and requires the new password', async () => {
const secondToken = await login(fixture.user.account, testPassword);
const newPassword = `New!${randomBytes(8).toString('hex')}aA3`;
success(await request('auth.admin/password', {
method: 'POST', token: fixture.token,
body: { old_password: testPassword, password: newPassword, password_confirm: newPassword },
}));
failure(await request('auth.admin/mySelf', { token: fixture.token }), [401]);
failure(await request('auth.admin/mySelf', { token: secondToken }), [401]);
failure(await request('login/account', { method: 'POST', body: { account: fixture.user.account, password: testPassword } }), [401]);
fixture.token = await login(fixture.user.account, newPassword);
assert.equal(success(await request('auth.admin/mySelf', { token: fixture.token })).account, fixture.user.account);
});
await suite.test('management input cannot promote a test user to root', async () => {
const result = await edit('admin', { ...adminFields(fixture.user), is_root: 1 });
if (result.envelope.code === 0) failure(result, validationStatuses);
else success(result); // Ignoring an unsupported field is also safe.
const self = success(await request('auth.admin/mySelf', { token: fixture.token }));
assert.ok(!isRoot(self.is_root), 'Management input must never grant root status');
assert.ok(!self.permissions.includes('*'), 'Management input must never grant root permissions');
});
} finally {
// Users were created after roles; roles after menus/departments. Reverse order respects relations.
if (rootToken && rootSelf) await cleanup();
}
// All fixture cleanup is complete before probing this critical protection. Never delete root.
if (rootToken && rootSelf) {
await suite.test('the initialized root account cannot be disabled', async () => {
failure(await edit('admin', adminFields(rootSelf, { disable: 1 })), [400, 403, 409, 422]);
const self = success(await request('auth.admin/mySelf', { token: rootToken }));
assert.ok(isRoot(self.is_root));
});
}
} finally {
if (rootToken) {
const result = await request('login/logout', { method: 'POST', token: rootToken });
// A failed root-protection assertion may already have invalidated this session.
if (result.status === 401) failure(result, [401]);
else success(result);
}
}
});
});