138 lines
3.4 KiB
JavaScript
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×tamp=${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,
|
|
};
|