128 lines
13 KiB
JavaScript
128 lines
13 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs';
|
|
import path from 'node:path';
|
|
import http from 'node:http';
|
|
import { execFileSync } from 'node:child_process';
|
|
import { createHash } from 'node:crypto';
|
|
import { chromium, expect } from 'playwright/test';
|
|
import { fixture, launchWorkbench } from '../tests/helpers.mjs';
|
|
import { deliveryGit, writeDeliveryFile } from '../tests/fixtures/delivery-project.mjs';
|
|
import { captureWorkspaceSource } from '../tests/fixtures/workspace-project.mjs';
|
|
|
|
const disposers = [], t = { after: fn => disposers.push(fn) }, f = fixture(t), baseline = path.resolve('benchmarks/react-delivery-v1/baseline');
|
|
const sha = bytes => createHash('sha256').update(bytes).digest('hex');
|
|
fs.cpSync(baseline, f.projectRoot, { recursive: true, filter: file => !file.split(path.sep).includes('node_modules') });
|
|
const protectedNames = ['package.json', 'package-lock.json', 'tsconfig.json', 'vite.config.mjs', 'index.html', 'test/domain.test.mjs', 'src/types.ts', 'src/main.tsx', 'src/styles.css'];
|
|
const protectedBytes = Object.fromEntries(protectedNames.map(relative => [relative, fs.readFileSync(path.join(f.projectRoot, relative))]));
|
|
const originalApp = fs.readFileSync(path.join(f.projectRoot, 'src/App.tsx'), 'utf8');
|
|
const fixes = {
|
|
'src/query.ts': "import type { Task } from './types.ts';\nexport function selectTasks(tasks: Task[], filter: string, query: string): Task[] {\n const text = query.trim().toLocaleLowerCase();\n return tasks.filter(task => (filter === 'done' ? task.done : filter === 'pending' ? !task.done : true) && task.title.toLocaleLowerCase().includes(text));\n}\n",
|
|
'src/summary.ts': "import type { Task } from './types.ts';\nexport function summarizeTasks(tasks: Task[]) {\n return { total: tasks.length, completed: tasks.filter(task => task.done).length, pendingHours: tasks.filter(task => !task.done).reduce((sum, task) => sum + task.hours, 0) };\n}\n",
|
|
'src/transition.ts': "import type { Task } from './types.ts';\nexport function toggleTask(tasks: Task[], id: string): Task[] {\n return tasks.map(task => task.id === id ? { ...task, done: !task.done } : task);\n}\n",
|
|
'src/App.tsx': originalApp.replace("toggleTask(current, 'missing')", 'toggleTask(current, task.id)'),
|
|
};
|
|
assert.notEqual(fixes['src/App.tsx'], originalApp);
|
|
writeDeliveryFile(f, 'owner-staged.txt', 'Owner baseline\n'); writeDeliveryFile(f, 'owner-unstaged.txt', 'Owner baseline\n');
|
|
deliveryGit(f, ['init', '--initial-branch=main']); deliveryGit(f, ['config', 'core.autocrlf', 'false']);
|
|
deliveryGit(f, ['config', 'user.name', 'Workbench QA']); deliveryGit(f, ['config', 'user.email', 'qa@workbench.invalid']);
|
|
deliveryGit(f, ['add', '--', '.']); deliveryGit(f, ['commit', '--no-gpg-sign', '-m', 'Seal React TypeScript delivery failure']);
|
|
writeDeliveryFile(f, 'owner-staged.txt', 'Owner staged change\n'); deliveryGit(f, ['add', '--', 'owner-staged.txt']);
|
|
writeDeliveryFile(f, 'owner-staged.txt', 'Owner working copy after staging\n'); writeDeliveryFile(f, 'owner-unstaged.txt', 'Owner unstaged change\n'); writeDeliveryFile(f, 'owner-untracked.txt', 'Owner untracked file\n');
|
|
const source = captureWorkspaceSource(f), npmCli = path.join(path.dirname(process.execPath), 'node_modules/npm/bin/npm-cli.js');
|
|
try {
|
|
const install = execFileSync(process.execPath, [npmCli, 'ci', '--offline', '--no-audit', '--no-fund'], { cwd: f.projectRoot, windowsHide: true, encoding: 'utf8', stdio: ['ignore', 'pipe', 'pipe'] });
|
|
fs.writeFileSync('.qa/react-engine-install.log', install);
|
|
} catch (error) { fs.writeFileSync('.qa/react-engine-install-failure.log', String(error.stdout || '') + '\n' + String(error.stderr || '')); throw error; }
|
|
const run = f.store.beginRun(f.session, 'Repair React filtering, actual statistics and one-task updates, preserve tests and configuration, verify types/build/browser and deliver a reviewed local Git commit.', false, f.store.config);
|
|
f.session.title = 'React TypeScript工程交付'; f.session.status = 'completed'; f.store.finishRun(f.session, run); f.store.save(f.session); f.store.close();
|
|
const host = await launchWorkbench(t, f.data), route = '/sessions/' + f.session.id;
|
|
assert.notEqual(new URL(host.url).port, '4318'); assert.equal(host.bootstrap.config.hasKey, false);
|
|
const state = () => host.api(route), passed = [], pageErrors = [], requestFailures = [];
|
|
let browser, page, appServer, session, first, job;
|
|
const mark = text => { passed.push(text); console.log('PASS ' + text); };
|
|
async function checks() {
|
|
session = await host.api(route + '/check-plans', {});
|
|
const plan = session.execution.plans.at(-1);
|
|
assert.deepEqual(plan.checks.map(check => check.name), ['test', 'typecheck', 'build']);
|
|
await host.api(route + '/check-jobs', { planId: plan.id });
|
|
await expect.poll(async () => { session = await state(); return session.execution.checks.at(-1)?.finishedAt; }, { timeout: 30000 }).toBeTruthy();
|
|
return session.execution.checks.at(-1);
|
|
}
|
|
async function snapshot(name) {
|
|
fs.mkdirSync('.qa/screenshots', { recursive: true });
|
|
await page.screenshot({ path: '.qa/screenshots/react-engine-' + name + '.png', scale: 'css' });
|
|
}
|
|
try {
|
|
first = await checks(); assert.equal(first.status, 'failed'); assert.ok(first.results[0].tests.failed > 0);
|
|
assert.equal(first.results[0].tests.total, 9); assert.equal(first.results[1].status, 'passed'); assert.equal(first.results[2].status, 'passed');
|
|
mark('the sealed React TypeScript project builds but its real domain tests first expose the functional failures');
|
|
const appRoot = path.join(f.projectRoot, 'dist');
|
|
appServer = http.createServer((request, response) => {
|
|
try {
|
|
const name = decodeURIComponent(new URL(request.url, 'http://localhost').pathname), file = path.resolve(appRoot, '.' + (name === '/' ? '/index.html' : name));
|
|
if (!file.startsWith(path.resolve(appRoot) + path.sep) || !fs.existsSync(file) || !fs.statSync(file).isFile()) { response.writeHead(404); response.end(); return; }
|
|
const mime = { '.html': 'text/html; charset=utf-8', '.js': 'text/javascript; charset=utf-8', '.css': 'text/css; charset=utf-8' }[path.extname(file)] || 'application/octet-stream';
|
|
response.writeHead(200, { 'Content-Type': mime, 'Cache-Control': 'no-store' }); response.end(fs.readFileSync(file));
|
|
} catch { response.writeHead(400); response.end(); }
|
|
});
|
|
await new Promise(resolve => appServer.listen(0, '127.0.0.1', resolve));
|
|
browser = await chromium.launch({ channel: 'msedge', headless: true }); page = await browser.newPage({ viewport: { width: 1280, height: 920 } });
|
|
page.on('pageerror', error => pageErrors.push(error.message)); page.on('requestfailed', request => requestFailures.push(request.url() + ': ' + request.failure()?.errorText));
|
|
const url = 'http://127.0.0.1:' + appServer.address().port;
|
|
await page.goto(url); await page.waitForLoadState('networkidle');
|
|
await page.getByLabel('任务状态').selectOption('pending');
|
|
await expect(page.locator('article')).toHaveCount(3); const brokenPending = await page.locator('article').count();
|
|
await snapshot('before'); mark('a real browser separately observes that the broken pending filter wrongly shows all three tasks');
|
|
|
|
for (const [relative, content] of Object.entries(fixes)) await host.api(route + '/proposals', { path: relative, content, reason: 'Repair the observed React delivery contract' });
|
|
session = await state();
|
|
session = await host.api(route + '/change-sets', { changeIds: session.changes.filter(change => change.status === 'pending').map(change => change.id) });
|
|
const batch = session.execution.changeSets.at(-1); await host.api(route + '/change-sets/' + batch.id + '/apply', { fingerprint: batch.fingerprint });
|
|
await expect.poll(async () => (await state()).execution.changeSets.at(-1).status).toBe('completed');
|
|
const actual = await checks(); assert.equal(actual.status, 'passed'); assert.equal(actual.results[0].tests.passed, 9);
|
|
assert.ok(actual.results.every(result => result.exitCode === 0)); assert.equal((await state()).execution.task.id, run.taskId);
|
|
mark('the four-file reviewed repair passes all nine domain tests, actual TypeScript checking and the Vite production build');
|
|
|
|
await page.reload(); await page.waitForLoadState('networkidle'); await expect(page.locator('article')).toHaveCount(3);
|
|
await page.getByLabel('任务状态').selectOption('pending'); await expect(page.locator('article')).toHaveCount(2);
|
|
await page.getByLabel('任务状态').selectOption('done'); await expect(page.locator('article')).toHaveCount(1);
|
|
await page.getByLabel('任务搜索').fill(' 不存在 '); await expect(page.locator('article')).toHaveCount(0); await expect(page.getByText('没有匹配的任务')).toBeVisible();
|
|
await page.getByLabel('任务搜索').fill(' 验证 '); await expect(page.locator('article')).toHaveCount(1);
|
|
await page.getByLabel('任务搜索').fill(''); await page.getByLabel('任务状态').selectOption('all');
|
|
await page.locator('article[data-task="api"]').getByRole('button', { name: '标为完成' }).click();
|
|
await expect(page.locator('article[data-task="api"] .tag')).toHaveText('已完成');
|
|
await expect(page.locator('article[data-task="tests"] .tag')).toHaveText('待完成');
|
|
await expect(page.getByLabel('项目统计').locator('div').filter({ hasText: '完成任务' }).locator('strong')).toHaveText('2');
|
|
await expect(page.getByLabel('项目统计').locator('div').filter({ hasText: '待办工时' }).locator('strong')).toHaveText('5小时');
|
|
await snapshot('desktop'); mark('the production React app passes real filtering, search, single-task toggling and updated statistics');
|
|
await page.setViewportSize({ width: 390, height: 844 }); await page.getByLabel('任务状态').selectOption('pending'); await expect(page.locator('article')).toHaveCount(1);
|
|
assert.ok(await page.locator('body').evaluate(node => node.scrollWidth <= 390)); await snapshot('mobile');
|
|
mark('the same built React app remains operable at 390px without horizontal overflow');
|
|
|
|
for (const [relative, bytes] of Object.entries(protectedBytes)) assert.ok(fs.readFileSync(path.join(f.projectRoot, relative)).equals(bytes), relative);
|
|
const plan = await host.api(route + '/delivery-plans', { message: 'fix: repair React delivery board behavior' });
|
|
const deliveryPlan = plan.execution.deliveryPlans.at(-1);
|
|
await host.api(route + '/delivery-jobs', { planId: deliveryPlan.id });
|
|
await expect.poll(async () => { session = await state(); return session.execution.deliveries.at(-1)?.reportArtifactId; }, { timeout: 30000 }).toBeTruthy();
|
|
job = session.execution.deliveries.at(-1);
|
|
assert.deepEqual(job.paths.slice().sort(), Object.keys(fixes).sort()); assert.deepEqual(captureWorkspaceSource(f).files, source.files);
|
|
assert.equal(deliveryGit(f, ['show', ':owner-staged.txt']).trim(), 'Owner staged change');
|
|
const report = JSON.parse((await host.api('/artifacts/' + job.reportArtifactId + '?session=' + session.id + '&limit=64000')).content);
|
|
assert.equal(report.status, 'verified_committed'); assert.equal(report.task.id, run.taskId); assert.equal(report.checks.at(-1).results[0].tests.passed, 9);
|
|
assert.equal(session.execution.checks[0].status, 'failed');
|
|
mark('Workbench Git commits only the four reviewed files and binds the actual checks while preserving tests, configuration and owner changes');
|
|
assert.deepEqual(pageErrors, []); assert.deepEqual(requestFailures, []);
|
|
const result = { success: true, version: host.bootstrap.version, at: new Date().toISOString(), browser: browser.version(), passed, pageErrors, requestFailures,
|
|
originalTests: first.results[0].tests, repairedTests: actual.results[0].tests, beforePending: brokenPending,
|
|
checks: actual.results.map(result => ({ name: result.name, status: result.status, exitCode: result.exitCode, tests: result.tests })),
|
|
commit: job.commit, changes: job.paths, protectedFiles: Object.fromEntries(Object.entries(protectedBytes).map(([relative, bytes]) => [relative, sha(bytes)])),
|
|
scope: 'Owned frozen React TypeScript project with offline-installed fixed dependencies, real npm/typecheck/build/browser and Workbench review/Git/report. API fixtures supply repairs; configured-model success is separate.' };
|
|
fs.writeFileSync(host.bootstrap.version === '1.8.0' ? 'docs/rea-engine-react-delivery-validation.json' : host.bootstrap.version === '1.9.0' ? 'docs/external-engines-react-delivery-validation.json' : 'docs/react-engine-delivery-validation.json', JSON.stringify(result, null, 2) + '\n'); console.log(JSON.stringify(result, null, 2));
|
|
} catch (error) {
|
|
await snapshot('failure').catch(() => {});
|
|
fs.writeFileSync('.qa/react-engine-delivery-failure.json', JSON.stringify({ error: error.message, passed, pageErrors, requestFailures, session }, null, 2)); throw error;
|
|
} finally {
|
|
await browser?.close(); if (appServer) { appServer.closeAllConnections(); await new Promise(resolve => appServer.close(resolve)); }
|
|
for (const dispose of disposers.reverse()) await dispose();
|
|
}
|