228 lines
15 KiB
JavaScript
228 lines
15 KiB
JavaScript
import { readFile } from 'node:fs/promises';
|
|
|
|
const base = process.env.EP_API_URL || 'http://127.0.0.1:8090';
|
|
const apiBase = `${base}/api/v1`;
|
|
|
|
function assert(condition, message) {
|
|
if (!condition) throw new Error(message);
|
|
}
|
|
|
|
async function request(path, options = {}, expectedStatus = 200) {
|
|
const response = await fetch(apiBase + path, options);
|
|
const text = await response.text();
|
|
let body;
|
|
try {
|
|
body = JSON.parse(text);
|
|
} catch {
|
|
throw new Error(`${path} returned non-JSON (${response.status}): ${text.slice(0, 160)}`);
|
|
}
|
|
if (response.status !== expectedStatus || (expectedStatus >= 200 && expectedStatus < 300 && body.code !== 0)) {
|
|
throw new Error(`${path} failed: HTTP ${response.status}, code ${body.code}, ${body.message || ''}`);
|
|
}
|
|
return body;
|
|
}
|
|
|
|
function json(body, token) {
|
|
return {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json', ...(token ? { Authorization: `Bearer ${token}` } : {}) },
|
|
body: JSON.stringify(body),
|
|
};
|
|
}
|
|
|
|
async function waitFor(predicate, timeoutMs = 5000) {
|
|
const deadline = Date.now() + timeoutMs;
|
|
while (Date.now() < deadline) {
|
|
const value = await predicate();
|
|
if (value) return value;
|
|
await new Promise((resolve) => setTimeout(resolve, 100));
|
|
}
|
|
throw new Error('timed out waiting for condition');
|
|
}
|
|
|
|
async function openBrowserWS(token) {
|
|
assert(typeof WebSocket === 'function', 'Node WebSocket is unavailable');
|
|
const socket = new WebSocket(`${base.replace(/^http/, 'ws')}/ws/browser?token=${encodeURIComponent(token)}`);
|
|
await new Promise((resolve, reject) => {
|
|
const timer = setTimeout(() => reject(new Error('Browser WS open timeout')), 3000);
|
|
socket.addEventListener('open', () => {
|
|
clearTimeout(timer);
|
|
resolve();
|
|
});
|
|
socket.addEventListener('error', () => {
|
|
clearTimeout(timer);
|
|
reject(new Error('Browser WS open failed'));
|
|
});
|
|
});
|
|
return socket;
|
|
}
|
|
|
|
async function main() {
|
|
const health = await fetch(`${base}/health`);
|
|
assert(health.ok, `health failed: HTTP ${health.status}`);
|
|
const agentRoute = await fetch(`${apiBase}/agent/devices`);
|
|
assert(agentRoute.status === 404, `mock mode must hide Agent routes, got ${agentRoute.status}`);
|
|
|
|
const suffix = `${Date.now()}-${Math.random().toString(16).slice(2)}`;
|
|
const email = `web-smoke-${suffix}@everypublish.local`;
|
|
const password = 'WebSmoke-pass-2026';
|
|
const registered = await request('/auth/register', json({ email, password, nickname: 'Web Smoke' }));
|
|
const token = registered.data.accessToken;
|
|
assert(token, 'registration did not return access token');
|
|
|
|
const loggedIn = await request('/auth/login', json({ email, password }));
|
|
assert(loggedIn.data.accessToken && loggedIn.data.refreshToken, 'login did not return token pair');
|
|
const refreshed = await request('/auth/refresh', {
|
|
method: 'POST',
|
|
headers: { 'Content-Type': 'application/json' },
|
|
body: JSON.stringify({ refreshToken: loggedIn.data.refreshToken }),
|
|
});
|
|
assert(refreshed.data.accessToken && refreshed.data.refreshToken, 'refresh did not rotate token pair');
|
|
|
|
const me = await request('/auth/me', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(me.data.workspaceId && me.data.memberRole === 'owner', 'auth/me workspace role missing');
|
|
const runtime = await request('/runtime/status', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(runtime.data.executorMode && Array.isArray(runtime.data.adapters) && runtime.data.db && runtime.data.redis, 'runtime status incomplete');
|
|
const workspaces = await request('/workspaces', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(workspaces.data.list?.length === 1, 'default workspace missing');
|
|
const workspaceId = workspaces.data.list[0].id;
|
|
const originalWorkspaceName = workspaces.data.list[0].name;
|
|
await request(`/workspaces/${workspaceId}`, { method: 'PUT', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }, body: JSON.stringify({ name: `${originalWorkspaceName} smoke` }) });
|
|
await request(`/workspaces/${workspaceId}`, { method: 'PUT', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }, body: JSON.stringify({ name: originalWorkspaceName }) });
|
|
const memberEmail = `web-smoke-member-${suffix}@everypublish.local`;
|
|
const memberRegistered = await request('/auth/register', json({ email: memberEmail, password: 'MemberSmoke-pass-2026', nickname: 'Member Smoke' }));
|
|
const memberToken = memberRegistered.data.accessToken;
|
|
const invitation = await request('/members/invite', json({ email: memberEmail, role: 'viewer' }, token));
|
|
await request('/members/join', json({ token: invitation.data.token }, memberToken));
|
|
const memberWorkspace = await request('/workspaces', { headers: { Authorization: `Bearer ${memberToken}` } });
|
|
await request(`/auth/switch-workspace/${workspaceId}`, json({}, memberToken));
|
|
const memberSwitched = await request(`/auth/switch-workspace/${workspaceId}`, json({}, memberToken));
|
|
await request('/accounts', json({ platform: 'douyin', remark: 'viewer forbidden' }, memberSwitched.data.accessToken), 403);
|
|
const memberRefreshed = await request('/auth/refresh', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ refreshToken: memberSwitched.data.refreshToken }) });
|
|
const memberMe = await request('/auth/me', { headers: { Authorization: `Bearer ${memberRefreshed.data.accessToken}` } });
|
|
assert(memberMe.data.workspaceId === workspaceId, 'refresh lost selected workspace');
|
|
const memberRows = await request('/members', { headers: { Authorization: `Bearer ${token}` } });
|
|
const invitedMember = memberRows.data.list.find((item) => item.email === memberEmail);
|
|
assert(invitedMember?.role === 'viewer', 'member invitation/join failed');
|
|
await request(`/members/${invitedMember.id}`, { method: 'DELETE', headers: { Authorization: `Bearer ${token}` } });
|
|
await request('/tasks', json({ title: 'unauthorized smoke', accountIds: [1], materialIds: [1] }), 401);
|
|
|
|
const socket = await openBrowserWS(token);
|
|
const events = [];
|
|
socket.addEventListener('message', (event) => {
|
|
try {
|
|
events.push(JSON.parse(event.data));
|
|
} catch {
|
|
// Ignore malformed event and let the final assertion fail if needed.
|
|
}
|
|
});
|
|
|
|
const account = await request('/accounts', json({ platform: 'douyin', remark: 'web smoke' }, token));
|
|
const accountId = account.data.id;
|
|
const bind = await request(`/accounts/${accountId}/bind`, { ...json({}, token) });
|
|
const challengeId = bind.data.challengeId;
|
|
const bindAgain = await request(`/accounts/${accountId}/bind`, { ...json({}, token) });
|
|
assert(bindAgain.data.challengeId === challengeId, 'repeated bind created duplicate active challenge');
|
|
const challengeList = await request('/challenges', { headers: { Authorization: `Bearer ${token}` } });
|
|
const challenge = challengeList.data.list.find((item) => item.id === challengeId);
|
|
assert(challenge?.kind === 'qr' && challenge.qrUrl?.startsWith('mock://'), 'mock QR challenge was not created');
|
|
await request(`/accounts/${accountId}`, { method: 'PUT', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }, body: JSON.stringify({ remark: 'web smoke updated' }) });
|
|
await request(`/accounts/${accountId}/credentials`, json({ cookies: 'SESSDATA=mock; bili_jct=mock; DedeUserID=1' }, token), 409);
|
|
await request(`/accounts/${accountId}/check`, { ...json({}, token) }, 409);
|
|
await request(`/challenges/${challengeId}/solve`, json({}, token), 400);
|
|
await request(`/challenges/${challengeId}/solve`, json({ value: 'web-smoke-login' }, token));
|
|
const activeAccounts = await request('/accounts?status=active', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(activeAccounts.data.list.some((item) => item.id === accountId), 'account did not become active');
|
|
|
|
const secondAccount = await request('/accounts', json({ platform: 'douyin', remark: 'challenge lifecycle' }, token));
|
|
const secondAccountId = secondAccount.data.id;
|
|
const secondBind = await request(`/accounts/${secondAccountId}/bind`, { ...json({}, token) });
|
|
await request(`/challenges/${secondBind.data.challengeId}/suspend`, json({}, token));
|
|
let secondChallenge = (await request('/challenges', { headers: { Authorization: `Bearer ${token}` } })).data.list.find((item) => item.id === secondBind.data.challengeId);
|
|
assert(secondChallenge?.status === 'suspended', 'challenge suspend did not persist');
|
|
const resent = await request(`/challenges/${secondBind.data.challengeId}/resend`, json({}, token));
|
|
assert(resent.data.qrUrl?.startsWith('mock://'), 'mock challenge resend did not return QR');
|
|
await request(`/challenges/${secondBind.data.challengeId}/solve`, json({ value: 'web-smoke-resend' }, token));
|
|
|
|
const bytes = await readFile(new URL('../references/social-auto-upload/videos/demo.mp4', import.meta.url));
|
|
const form = new FormData();
|
|
form.append('file', new Blob([bytes], { type: 'video/mp4' }), 'demo.mp4');
|
|
const material = await request('/materials', { method: 'POST', headers: { Authorization: `Bearer ${token}` }, body: form });
|
|
const materialId = material.data.material.id;
|
|
assert(material.data.material.kind === 'video', 'mp4 upload was not classified as video');
|
|
|
|
const materialURL = await request(`/materials/${materialId}/url`, { headers: { Authorization: `Bearer ${token}` } });
|
|
const firstDownload = await fetch(materialURL.data.url);
|
|
assert(firstDownload.ok, `signed material URL failed: HTTP ${firstDownload.status}`);
|
|
await firstDownload.arrayBuffer();
|
|
const secondDownload = await fetch(materialURL.data.url);
|
|
assert(secondDownload.status === 404 || secondDownload.status === 410, `signed URL was reusable: HTTP ${secondDownload.status}`);
|
|
const previewURL = await request(`/materials/${materialId}/url`, { headers: { Authorization: `Bearer ${token}` } });
|
|
const previewDownload = await fetch(previewURL.data.url + '?inline=1');
|
|
assert(previewDownload.ok && (previewDownload.headers.get('content-type') || '').includes('video'), 'inline material preview failed');
|
|
await previewDownload.arrayBuffer();
|
|
const materialList = await request('/materials?kind=video&size=100', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(materialList.data.list.some((item) => item.id === materialId), 'material kind filter missed upload');
|
|
|
|
const task = await request('/tasks', json({
|
|
title: 'Web smoke task',
|
|
content: 'Web-only smoke test',
|
|
tags: ['smoke'],
|
|
accountIds: [accountId],
|
|
materialIds: [materialId],
|
|
}, token));
|
|
await request('/tasks', json({ title: 'Web smoke invalid schedule', content: 'invalid', accountIds: [accountId], materialIds: [materialId], scheduleAt: Date.now() - 1000 }, token), 400);
|
|
const taskId = task.data.id;
|
|
await request(`/tasks/${taskId}/submit`, { ...json({}, token) });
|
|
await request(`/tasks/${taskId}/approve`, { ...json({}, token) });
|
|
|
|
// The first local worker tick can be delayed by a cold MySQL/Go process.
|
|
// Give the mock executor enough room without changing its state semantics.
|
|
const finalTask = await waitFor(async () => {
|
|
const result = await request(`/tasks/${taskId}`, { headers: { Authorization: `Bearer ${token}` } });
|
|
return result.data.status === 'success' ? result.data : null;
|
|
}, 10000);
|
|
assert(finalTask.publishedUrls.includes('mock://'), 'mock result URL missing');
|
|
assert(finalTask.receipts.includes('mock executor completed'), 'mock receipt missing');
|
|
|
|
const timeline = await request(`/tasks/${taskId}/events`, { headers: { Authorization: `Bearer ${token}` } });
|
|
const statuses = timeline.data.list.map((event) => event.status);
|
|
assert(statuses.join('>') === 'draft>pending_review>queued>dispatched>running>success', `unexpected task timeline: ${statuses.join('>')}`);
|
|
await waitFor(() => events.some((event) => event.type === 'task.status' || event.type === 'challenge.status'), 3000);
|
|
|
|
const rejectedTask = await request('/tasks', json({ title: 'Web smoke reject', content: 'reject path', accountIds: [accountId], materialIds: [materialId] }, token));
|
|
await request(`/tasks/${rejectedTask.data.id}/submit`, { ...json({}, token) });
|
|
await request(`/tasks/${rejectedTask.data.id}/reject`, json({ note: '需要补充说明' }, token));
|
|
await request(`/tasks/${rejectedTask.data.id}/resubmit`, json({}, token));
|
|
await request(`/tasks/${rejectedTask.data.id}/cancel`, json({}, token));
|
|
const rejectedFinal = await request(`/tasks/${rejectedTask.data.id}`, { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(rejectedFinal.data.status === 'cancelled', 'reject/resubmit/cancel flow failed');
|
|
|
|
const draftTask = await request('/tasks', json({ title: 'Web smoke delete', content: 'delete path', accountIds: [accountId], materialIds: [materialId] }, token));
|
|
await request(`/tasks/${draftTask.data.id}`, { method: 'DELETE', headers: { Authorization: `Bearer ${token}` } });
|
|
const scheduledTask = await request('/tasks', json({ title: 'Web smoke schedule', content: 'schedule path', accountIds: [accountId], materialIds: [materialId], scheduleAt: Date.now() + 3600000 }, token));
|
|
await request(`/tasks/${scheduledTask.data.id}`, { method: 'PUT', headers: { 'Content-Type': 'application/json', Authorization: `Bearer ${token}` }, body: JSON.stringify({ title: 'Web smoke schedule', content: 'schedule path', tags: [], accountIds: [accountId], materialIds: [materialId], scheduleAt: null }) });
|
|
const immediateTask = await request(`/tasks/${scheduledTask.data.id}`, { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(!immediateTask.data.scheduleAt, 'schedule clear did not persist');
|
|
const notifications = await request('/notifications', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(Array.isArray(notifications.data.list), 'notification list missing');
|
|
await request('/notifications/read-all', json({}, token));
|
|
const audits = await request('/audit-logs?size=20', { headers: { Authorization: `Bearer ${token}` } });
|
|
assert(Array.isArray(audits.data.list), 'audit log list missing');
|
|
const nextPassword = 'WebSmoke-next-2026';
|
|
await request('/auth/password', json({ currentPassword: password, newPassword: nextPassword }, token));
|
|
const relogin = await request('/auth/login', json({ email, password: nextPassword }));
|
|
assert(relogin.data.accessToken, 'changed password could not login');
|
|
await request(`/accounts/${secondAccountId}/unbind`, json({}, token));
|
|
await request(`/accounts/${secondAccountId}`, { method: 'DELETE', headers: { Authorization: `Bearer ${token}` } });
|
|
await request(`/materials/${materialId}`, { method: 'DELETE', headers: { Authorization: `Bearer ${token}` } });
|
|
|
|
socket.close();
|
|
console.log(JSON.stringify({ ok: true, accountId, materialId, taskId, timeline: statuses, browserEvents: events.length, coverage: ['auth', 'workspace', 'members', 'runtime', 'permissions', 'account', 'challenge-resend', 'materials', 'task-success', 'task-reject-resubmit-cancel', 'task-schedule-edit', 'notifications', 'audit'] }));
|
|
}
|
|
|
|
main().catch((error) => {
|
|
console.error(`web-smoke failed: ${error.message}`);
|
|
process.exitCode = 1;
|
|
});
|