WMS_MAIN/test/support/system_method_client.js
2026-03-23 17:10:07 +08:00

138 lines
3.4 KiB
JavaScript

'use strict';
const fs = require('node:fs');
const path = require('node:path');
const assert = require('node:assert/strict');
const BASE_URL = process.env.SYSTEM_TEST_BASE_URL || 'http://127.0.0.1:6060';
const TOKEN_FILE = process.env.SYSTEM_TEST_TOKEN_FILE
|| path.join(process.cwd(), 'test', '.runtime', 'system_user_token.json');
const USERNAME = process.env.SYSTEM_TEST_USERNAME || 'liufumingren';
const PASSWORD = process.env.SYSTEM_TEST_PASSWORD || '111111';
function nowSec() {
return Math.floor(Date.now() / 1000);
}
function decodeJwtPayload(token) {
try {
const payloadSegment = token.split('.')[1];
if (!payloadSegment) return null;
const normalized = payloadSegment.replace(/-/g, '+').replace(/_/g, '/');
const padded = normalized + '='.repeat((4 - normalized.length % 4) % 4);
return JSON.parse(Buffer.from(padded, 'base64').toString('utf8'));
} catch {
return null;
}
}
function isTokenUsable(token) {
if (!token) return false;
const payload = decodeJwtPayload(token);
if (!payload || !payload.exp) return false;
return payload.exp - nowSec() > 120;
}
function readCachedToken() {
if (!fs.existsSync(TOKEN_FILE)) return null;
try {
const content = fs.readFileSync(TOKEN_FILE, 'utf8');
const parsed = JSON.parse(content);
const token = parsed && parsed.token;
return isTokenUsable(token) ? token : null;
} catch {
return null;
}
}
function writeCachedToken(token) {
fs.mkdirSync(path.dirname(TOKEN_FILE), { recursive: true });
const payload = decodeJwtPayload(token);
const record = {
token,
username: USERNAME,
cachedAt: new Date().toISOString(),
exp: payload && payload.exp ? payload.exp : null,
};
fs.writeFileSync(TOKEN_FILE, JSON.stringify(record, null, 2), 'utf8');
}
async function invokeSystemMethod(method, body = {}, token, extra = {}) {
const timestamp = nowSec();
const url = `${BASE_URL}/system?method=${encodeURIComponent(method)}&v=1.0&timestamp=${timestamp}`;
const platform = extra && extra.platform ? extra.platform : 'web';
const project = extra && extra.project ? extra.project : 'wms';
const headers = {
platform,
project,
'Content-Type': 'application/json',
};
if (token) {
headers.Authorization = `Bearer ${token}`;
}
const response = await fetch(url, {
method: 'POST',
headers,
body: JSON.stringify(body),
});
const text = await response.text();
let json;
try {
json = JSON.parse(text);
} catch {
throw new Error(`Invalid JSON from ${method}: ${text}`);
}
return {
status: response.status,
body: json,
};
}
async function getAuthToken(options = {}) {
const { forceLogin = false } = options;
if (!forceLogin) {
const cached = readCachedToken();
if (cached) {
return { token: cached, fromCache: true };
}
}
const loginRes = await invokeSystemMethod('user.login', {
username: USERNAME,
password: PASSWORD,
});
assert.equal(loginRes.status, 200, 'user.login should return HTTP 200');
assert.equal(loginRes.body.flag, 'success', `user.login should succeed: ${JSON.stringify(loginRes.body)}`);
const token = loginRes.body
&& loginRes.body.data
&& loginRes.body.data.token;
assert.ok(token, 'user.login response should contain token');
writeCachedToken(token);
return {
token,
fromCache: false,
};
}
module.exports = {
BASE_URL,
TOKEN_FILE,
USERNAME,
invokeSystemMethod,
getAuthToken,
readCachedToken,
};