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

115 lines
8.3 KiB
JavaScript

import assert from 'node:assert/strict'
import { spawn } from 'node:child_process'
import { once } from 'node:events'
import { createServer } from 'node:net'
import { mkdtemp } from 'node:fs/promises'
import { tmpdir } from 'node:os'
import { join } from 'node:path'
import { fileURLToPath } from 'node:url'
import { createHash } from 'node:crypto'
import test from 'node:test'
import { createSharedUpstream, fixturePassword } from './shared-upstream.mjs'
const php = process.env.IAM_TEST_PHP || 'php'
const serverRoot = fileURLToPath(new URL('../server/', import.meta.url))
test('集团 HTTP 范围与一次性登录流程使用隔离身份源', { timeout: 60_000 }, async () => {
const runtime = await mkdtemp(join(tmpdir(), 'iam-group-http-'))
const upstream = await createSharedUpstream({ groupEnabled: true })
upstream.state.permissionOverrides.set('OriginalReader', ['auth.admin/lists'])
const socket = createServer().listen(0, '127.0.0.1')
await once(socket, 'listening')
const port = socket.address().port
await new Promise(resolve => socket.close(resolve))
const env = Object.fromEntries(Object.entries(process.env).filter(([key]) => !key.startsWith('IAM_')))
Object.assign(env, { IAM_DATA_MODE: 'shared', IAM_SOURCE_API_URL: upstream.url, IAM_RUNTIME_PATH: runtime,
IAM_GROUP_ENABLED: '1', IAM_GROUP_OWNER_IDS: '1', IAM_GROUP_DB_PATH: join(runtime, 'group.sqlite'),
IAM_HOSPITAL_BASE_URL: 'http://127.0.0.1:18090/admin', APP_DEBUG: '0' })
const child = spawn(php, ['-d', 'extension=pdo_sqlite', '-S', `127.0.0.1:${port}`, '-t', 'public', fileURLToPath(new URL('./isolated-api-router.php', import.meta.url))],
{ cwd: serverRoot, env, windowsHide: true, stdio: ['ignore', 'pipe', 'pipe'] })
child.stdout.resume()
child.stderr.resume()
const base = `http://127.0.0.1:${port}/adminapi`
const request = async (path, { token, data, headers = {} } = {}) => {
const response = await fetch(base + path, { method: data ? 'POST' : 'GET', redirect: 'error', signal: AbortSignal.timeout(8000),
headers: { ...(token ? { Authorization: `Bearer ${token}` } : {}), ...(data ? { 'Content-Type': 'application/json' } : {}), ...headers },
...(data ? { body: JSON.stringify(data) } : {}) })
const json = await response.json()
return { status: response.status, data: json.data, code: json.code, headers: response.headers }
}
const ok = response => { assert.equal(response.status, 200); assert.equal(response.code, 1); return response.data }
try {
let ready = false
for (let attempt = 0; attempt < 50; attempt++) {
try { if ((await request('/health')).status === 200) { ready = true; break } } catch {}
await new Promise(resolve => setTimeout(resolve, 100))
}
assert.ok(ready, 'Fixture server not ready')
assert.equal(ok(await request('/health')).group_enabled, true)
assert.equal((await request('/group/context')).status, 401)
const root = ok(await request('/login/account', { data: { account: 'OriginalRoot', password: fixturePassword } })).token
const reader = ok(await request('/login/account', { data: { account: 'OriginalReader', password: fixturePassword } })).token
const logins = upstream.requests('identity.session/login')
assert.equal(logins.length, 2)
assert.ok(logins.every(login => Number(login.body.terminal) === 11), 'Group logins must use the isolated source terminal')
for (const terminal of [1, 11]) {
assert.equal((await request('/login/account', { data: { account: 'OriginalRoot', password: fixturePassword, terminal } })).status, 422)
}
assert.equal(upstream.requests('identity.session/login').length, 2, 'Browser terminal overrides must not reach the source')
const context = ok(await request('/group/context', { token: root }))
assert.equal(context.is_group_admin, true)
assert.equal(context.applications[0].entry_url, 'http://127.0.0.1:18090/admin/group-login')
assert.equal(ok(await request('/auth.admin/mySelf', { token: root })).gid, context.identity.gid)
const companyPayload = { code: 'new-company', name: '新公司', parent_id: 0, disable: 0 }
assert.equal((await request('/group/company/save', { token: reader, data: companyPayload })).status, 403)
const company = ok(await request('/group/company/save', { token: root, data: companyPayload }))
assert.equal(company.is_directory_company, false)
assert.equal(company.structure_mode, 'group')
assert.equal((await request('/group/members?company_id=1', { token: reader })).status, 403)
const members = ok(await request('/group/members?company_id=1', { token: root }))
assert.equal(members.lists.length, upstream.state.users.length)
ok(await request('/group/member/save', { token: root, data: { company_id: company.id, admin_id: 2, member_status: 1, can_login: 1 } }))
assert.equal(ok(await request('/auth.admin/lists', { token: reader, headers: { 'X-Company-Id': String(company.id) } })).count, upstream.state.users.length)
assert.equal((await request('/auth.role/lists', { token: reader, headers: { 'X-Company-Id': String(company.id) } })).status, 403)
assert.deepEqual(ok(await request('/auth/options', { token: reader, headers: { 'X-Company-Id': String(company.id) } })), { roles: [], depts: [], menus: [] })
for (const path of ['/auth.menu/lists', '/auth.dept/lists']) {
assert.equal((await request(path, { token: reader, headers: { 'X-Company-Id': String(company.id) } })).status, 403)
assert.deepEqual(ok(await request(path, { token: root, headers: { 'X-Company-Id': String(company.id) } })), [])
}
assert.equal((await request('/auth.admin/lists', { token: reader, headers: { 'X-Company-Id': 'invalid' } })).status, 422)
assert.ok(ok(await request('/auth.admin/lists', { token: reader, headers: { 'X-Company-Id': '1' } })).lists.every(row => /^gid_[a-f0-9]{32}$/.test(row.gid)))
const verifier = 'a'.repeat(64)
const challenge = createHash('sha256').update(verifier).digest('base64url')
const authorization = { client_id: 'internet-hospital', redirect_uri: context.applications[0].entry_url,
state: 's'.repeat(64), code_challenge: challenge, code_challenge_method: 'S256' }
const issue = async () => {
const url = new URL(ok(await request('/group/sso/authorize', { token: reader, data: authorization })).redirect_url)
assert.equal(url.searchParams.get('state'), authorization.state)
assert.equal(url.searchParams.has('token'), false)
return url.searchParams.get('code')
}
const proof = code => ({ client_id: authorization.client_id, redirect_uri: authorization.redirect_uri, code, code_verifier: verifier })
const code = await issue()
assert.equal((await request('/group/sso/exchange', { data: proof(code), headers: { Origin: 'https://attacker.invalid' } })).status, 403)
const concurrent = await Promise.all([request('/group/sso/exchange', { data: proof(code), headers: { Origin: 'http://127.0.0.1:18090' } }), request('/group/sso/exchange', { data: proof(code) })])
assert.deepEqual(concurrent.map(item => item.status).sort(), [200, 422])
const exchanged = concurrent.find(item => item.status === 200)
assert.ok(/^[a-f0-9]{64}$/.test(exchanged.data.ticket))
assert.equal(exchanged.data.exchange_path, '/adminapi/identity.hospitalSso/exchange')
assert.equal('token' in exchanged.data, false)
assert.equal(exchanged.headers.get('access-control-allow-origin'), 'http://127.0.0.1:18090')
const revoked = await issue()
ok(await request('/group/member/save', { token: root, data: { company_id: 1, admin_id: 2, member_status: 0, can_login: 0 } }))
assert.ok(ok(await request('/group/sso/exchange', { data: proof(revoked) })).ticket)
assert.deepEqual(ok(await request('/auth/options', { token: reader })), { roles: [], depts: [], menus: [] })
assert.equal(ok(await request('/group/context', { token: reader })).applications[0].can_login, true)
const target = upstream.state.users.find(row => row.id === 2)
target.disable = 1
assert.equal((await request('/group/context', { token: reader })).status, 401)
assert.equal((await request('/group/sso/authorize', { token: root, data: { ...authorization, redirect_uri: 'http://127.0.0.1:18090/admin/group-login/evil' } })).status, 422)
} finally {
if (child.exitCode === null) { const stopped = once(child, 'exit'); child.kill(); await stopped }
await upstream.close()
}
})