forked from wangziqi/gongxue-base
317 lines
15 KiB
JavaScript
317 lines
15 KiB
JavaScript
import assert from 'node:assert/strict';
|
|
import fs from 'node:fs/promises';
|
|
import path from 'node:path';
|
|
import pg from 'pg';
|
|
import { spawn } from 'node:child_process';
|
|
import JSZip from 'jszip';
|
|
|
|
const databaseUrl = process.env.DATABASE_URL || 'postgresql://postgres:postgres@127.0.0.1:54322/postgres';
|
|
const tenantId = '00000000-0000-0000-0000-000000000001';
|
|
const tenantAdminUserId = '00000000-0000-0000-0000-000000000102';
|
|
const collectionId = '00000000-0000-0000-0000-000000000615';
|
|
const localStorageRoot = '.local-storage-test';
|
|
|
|
const ids = {
|
|
pdfJob: '21000000-0000-0000-0000-000000000901',
|
|
docxJob: '21000000-0000-0000-0000-000000000902',
|
|
noAnswerDocxJob: '21000000-0000-0000-0000-000000000903',
|
|
dailyPdfJob: '21000000-0000-0000-0000-000000000904',
|
|
dailyZipJob: '21000000-0000-0000-0000-000000000905',
|
|
};
|
|
|
|
const jobIds = [ids.pdfJob, ids.docxJob, ids.noAnswerDocxJob, ids.dailyPdfJob, ids.dailyZipJob];
|
|
|
|
async function runWorkerOnce() {
|
|
const child = spawn(process.execPath, ['apps/worker/dist/apps/worker/src/index.js', '--once', '--job', 'exports'], {
|
|
cwd: process.cwd(),
|
|
env: {
|
|
...process.env,
|
|
DATABASE_URL: databaseUrl,
|
|
WORKER_EXPORT_BATCH_SIZE: '20',
|
|
WORKER_EXPORT_ID: 'export-worker-test',
|
|
STORAGE_DEFAULT_PROVIDER: 'local_dev',
|
|
STORAGE_DEFAULT_BUCKET: 'tenant-assets',
|
|
EXPORT_LOCAL_STORAGE_ROOT: localStorageRoot,
|
|
STORAGE_REQUIRE_TENANT_PREFIX: 'true',
|
|
},
|
|
stdio: ['ignore', 'pipe', 'pipe'],
|
|
windowsHide: true,
|
|
});
|
|
let output = '';
|
|
child.stdout.on('data', chunk => {
|
|
output += chunk.toString();
|
|
});
|
|
child.stderr.on('data', chunk => {
|
|
output += chunk.toString();
|
|
});
|
|
const code = await new Promise(resolve => child.on('exit', resolve));
|
|
assert.equal(code, 0, `worker should exit 0\n${output}`);
|
|
assert.match(output, /exports batch processed=\d+/, 'worker output should include exports summary');
|
|
return output;
|
|
}
|
|
|
|
async function cleanup(pool) {
|
|
await pool.query(
|
|
`
|
|
delete from public.audit_logs
|
|
where tenant_id = $1
|
|
and (
|
|
(target_type = 'content_export_job' and target_id = any($2::text[]))
|
|
or (target_type = 'content_asset' and details->>'exportJobId' = any($2::text[]))
|
|
)
|
|
`,
|
|
[tenantId, jobIds],
|
|
);
|
|
await pool.query(
|
|
`
|
|
delete from public.content_assets
|
|
where tenant_id = $1
|
|
and metadata->>'exportJobId' = any($2::text[])
|
|
`,
|
|
[tenantId, jobIds],
|
|
);
|
|
await pool.query(
|
|
`
|
|
delete from public.content_export_jobs
|
|
where tenant_id = $1 and id = any($2::uuid[])
|
|
`,
|
|
[tenantId, jobIds],
|
|
);
|
|
await fs.rm(path.resolve(process.cwd(), localStorageRoot), { recursive: true, force: true });
|
|
}
|
|
|
|
async function seed(pool) {
|
|
await pool.query(
|
|
`
|
|
insert into public.content_export_jobs (
|
|
id, tenant_id, created_by, export_type, format, scope_type, scope_id,
|
|
status, include_answers, include_explanations, include_video_refs,
|
|
question_count, summary, options, output_metadata, created_at, updated_at
|
|
)
|
|
values
|
|
(
|
|
$1, $4, $5, 'paper', 'pdf', 'collection', $6,
|
|
'pending', false, false, false,
|
|
0, '{"source":"export-worker-test"}'::jsonb,
|
|
'{"title":"导出测试无答案试卷","watermarkText":"内部水印","publishToAssets":true,"assetVisibility":"tenant","limit":50}'::jsonb,
|
|
'{"delivery":"content_asset_pending","maxQuestionLimit":50}'::jsonb,
|
|
now() - interval '1 minute', now() - interval '1 minute'
|
|
),
|
|
(
|
|
$2, $4, $5, 'paper', 'docx', 'collection', $6,
|
|
'pending', true, true, false,
|
|
0, '{"source":"export-worker-test"}'::jsonb,
|
|
'{"title":"导出测试含答案文档","watermarkText":"内部水印","publishToAssets":false,"assetVisibility":"private","limit":50}'::jsonb,
|
|
'{"delivery":"content_asset_pending","maxQuestionLimit":50}'::jsonb,
|
|
now() - interval '1 minute', now() - interval '1 minute'
|
|
),
|
|
(
|
|
$3, $4, $5, 'paper', 'docx', 'collection', $6,
|
|
'pending', false, false, false,
|
|
0, '{"source":"export-worker-test"}'::jsonb,
|
|
'{"title":"导出测试无答案文档","watermarkText":"内部水印","publishToAssets":false,"assetVisibility":"private","limit":50}'::jsonb,
|
|
'{"delivery":"content_asset_pending","maxQuestionLimit":50}'::jsonb,
|
|
now() - interval '1 minute', now() - interval '1 minute'
|
|
),
|
|
(
|
|
$7, $4, $5, 'daily_practice', 'pdf', 'collection', $6,
|
|
'pending', true, false, false,
|
|
0, '{"source":"export-worker-test"}'::jsonb,
|
|
'{"title":"每日一练测试","issue":"每日一练 第 1 期","date":"2026-06-29","watermarkText":"每日一练水印","publishToAssets":true,"assetVisibility":"tenant","limit":99,"brand":{"name":"恭学教育","english":"GONGXUE EDU","slogan":"专注高职升本","ctaLine":"每日一练 · 稳步上岸"}}'::jsonb,
|
|
'{"delivery":"content_asset_pending","maxQuestionLimit":8}'::jsonb,
|
|
now() - interval '1 minute', now() - interval '1 minute'
|
|
),
|
|
(
|
|
$8, $4, $5, 'daily_practice', 'daily_practice_zip', 'collection', $6,
|
|
'pending', false, false, false,
|
|
0, '{"source":"export-worker-test"}'::jsonb,
|
|
'{"title":"每日一练图片包测试","issue":"每日一练 第 2 期","date":"2026-06-29","theme":"ink","cardFormat":"1:1","watermarkText":"每日一练水印","publishToAssets":true,"assetVisibility":"tenant","limit":99,"brand":{"name":"恭学教育","english":"GONGXUE EDU","slogan":"专注高职升本","ctaLine":"每日一练 · 稳步上岸"}}'::jsonb,
|
|
'{"delivery":"content_asset_pending","maxQuestionLimit":8}'::jsonb,
|
|
now() - interval '1 minute', now() - interval '1 minute'
|
|
)
|
|
`,
|
|
[ids.pdfJob, ids.docxJob, ids.noAnswerDocxJob, tenantId, tenantAdminUserId, collectionId, ids.dailyPdfJob, ids.dailyZipJob],
|
|
);
|
|
}
|
|
|
|
function countFromWorkerOutput(output, name) {
|
|
const match = output.match(new RegExp(`${name}=(\\d+)`));
|
|
return match ? Number(match[1]) : 0;
|
|
}
|
|
|
|
async function generatedFileBody(asset) {
|
|
const fullPath = path.resolve(process.cwd(), localStorageRoot, asset.bucket, asset.object_key);
|
|
return fs.readFile(fullPath);
|
|
}
|
|
|
|
async function assertGeneratedFile(asset) {
|
|
const body = await generatedFileBody(asset);
|
|
assert.equal(body.length, Number(asset.file_size_bytes), 'generated file size should match content_assets');
|
|
assert.ok(body.length > 500, 'generated binary export should not be empty');
|
|
if (asset.mime_type === 'application/pdf') {
|
|
assert.equal(body.subarray(0, 4).toString('utf8'), '%PDF', 'PDF export should have PDF header');
|
|
} else if (asset.mime_type === 'application/zip') {
|
|
assert.equal(body.subarray(0, 2).toString('hex'), '504b', 'ZIP export should have ZIP header');
|
|
} else {
|
|
assert.equal(body.subarray(0, 2).toString('hex'), '504b', 'DOCX export should be a zipped Office file');
|
|
}
|
|
}
|
|
|
|
async function docxText(asset) {
|
|
const zip = await JSZip.loadAsync(await generatedFileBody(asset));
|
|
const xml = await zip.file('word/document.xml')?.async('string');
|
|
assert.ok(xml, 'DOCX should contain word/document.xml');
|
|
return xml
|
|
.replace(/<[^>]+>/g, '')
|
|
.replace(/</g, '<')
|
|
.replace(/>/g, '>')
|
|
.replace(/&/g, '&');
|
|
}
|
|
|
|
async function zipEntries(asset) {
|
|
const zip = await JSZip.loadAsync(await generatedFileBody(asset));
|
|
const manifestText = await zip.file('manifest.json')?.async('string');
|
|
const payloadText = await zip.file('payload.json')?.async('string');
|
|
assert.ok(manifestText, 'daily practice ZIP should contain manifest.json');
|
|
assert.ok(payloadText, 'daily practice ZIP should contain payload.json');
|
|
return {
|
|
manifest: JSON.parse(manifestText),
|
|
payload: JSON.parse(payloadText),
|
|
names: Object.keys(zip.files).filter(name => !zip.files[name].dir),
|
|
};
|
|
}
|
|
|
|
async function main() {
|
|
const pool = new pg.Pool({ connectionString: databaseUrl });
|
|
let seeded = false;
|
|
try {
|
|
await pool.query('begin');
|
|
await cleanup(pool);
|
|
await seed(pool);
|
|
await pool.query('commit');
|
|
seeded = true;
|
|
|
|
const output = await runWorkerOnce();
|
|
assert.ok(countFromWorkerOutput(output, 'completed') >= 5, 'worker should complete all binary export jobs');
|
|
|
|
const jobs = await pool.query(
|
|
`
|
|
select id, status, asset_id, question_count, output_metadata
|
|
from public.content_export_jobs
|
|
where tenant_id = $1 and id = any($2::uuid[])
|
|
order by id
|
|
`,
|
|
[tenantId, jobIds],
|
|
);
|
|
assert.equal(jobs.rowCount, 5, 'all export jobs should still exist');
|
|
for (const job of jobs.rows) {
|
|
assert.equal(job.status, 'completed', 'export job should be completed');
|
|
assert.ok(job.asset_id, 'completed export job should reference a content asset');
|
|
assert.equal(job.output_metadata?.delivery, 'content_asset', 'export job should switch delivery to content_asset');
|
|
assert.ok(job.output_metadata?.checksumSha256, 'export job should record output checksum');
|
|
assert.ok(Number(job.question_count) >= 1, 'export job should record question count');
|
|
}
|
|
|
|
const assets = await pool.query(
|
|
`
|
|
select id, asset_type, title, file_name, storage_provider, bucket,
|
|
object_key, mime_type, file_size_bytes, checksum_sha256,
|
|
upload_status, visibility, status, metadata
|
|
from public.content_assets
|
|
where tenant_id = $1 and metadata->>'exportJobId' = any($2::text[])
|
|
order by file_name
|
|
`,
|
|
[tenantId, jobIds],
|
|
);
|
|
assert.equal(assets.rowCount, 5, 'worker should create five export assets');
|
|
const pdfAsset = assets.rows.find(asset => asset.metadata?.exportJobId === ids.pdfJob);
|
|
const docxAsset = assets.rows.find(asset => asset.metadata?.exportJobId === ids.docxJob);
|
|
const noAnswerDocxAsset = assets.rows.find(asset => asset.metadata?.exportJobId === ids.noAnswerDocxJob);
|
|
const dailyPdfAsset = assets.rows.find(asset => asset.metadata?.exportJobId === ids.dailyPdfJob);
|
|
const dailyZipAsset = assets.rows.find(asset => asset.metadata?.exportJobId === ids.dailyZipJob);
|
|
assert.ok(pdfAsset, 'PDF export should create a PDF content asset');
|
|
assert.ok(docxAsset, 'DOCX export should create a Word content asset');
|
|
assert.ok(noAnswerDocxAsset, 'no-answer DOCX export should create a Word content asset');
|
|
assert.ok(dailyPdfAsset, 'daily practice PDF export should create a PDF content asset');
|
|
assert.ok(dailyZipAsset, 'daily practice ZIP export should create a package content asset');
|
|
assert.equal(pdfAsset.mime_type, 'application/pdf', 'PDF asset should use application/pdf');
|
|
assert.ok(docxAsset.mime_type?.includes('wordprocessingml'), 'DOCX asset should use Word MIME type');
|
|
assert.equal(dailyZipAsset.mime_type, 'application/zip', 'daily practice package should use application/zip');
|
|
assert.equal(dailyZipAsset.asset_type, 'package', 'daily practice ZIP should use package asset type');
|
|
assert.equal(pdfAsset.upload_status, 'verified', 'PDF asset should be verified');
|
|
assert.equal(docxAsset.upload_status, 'verified', 'DOCX asset should be verified');
|
|
assert.equal(noAnswerDocxAsset.upload_status, 'verified', 'no-answer DOCX asset should be verified');
|
|
assert.equal(dailyPdfAsset.upload_status, 'verified', 'daily practice PDF asset should be verified');
|
|
assert.equal(dailyZipAsset.upload_status, 'verified', 'daily practice ZIP asset should be verified');
|
|
assert.equal(pdfAsset.visibility, 'tenant', 'published PDF export should use requested asset visibility');
|
|
assert.equal(docxAsset.visibility, 'private', 'non-published DOCX export should remain private');
|
|
assert.equal(noAnswerDocxAsset.visibility, 'private', 'no-answer DOCX export should remain private');
|
|
assert.equal(dailyPdfAsset.visibility, 'tenant', 'daily practice PDF export should use requested asset visibility');
|
|
assert.equal(dailyZipAsset.visibility, 'tenant', 'daily practice ZIP export should use requested asset visibility');
|
|
assert.equal(dailyPdfAsset.metadata?.exportType, 'daily_practice', 'daily practice asset should keep export type metadata');
|
|
assert.equal(dailyZipAsset.metadata?.format, 'daily_practice_zip', 'daily practice package should keep export format metadata');
|
|
await assertGeneratedFile(pdfAsset);
|
|
await assertGeneratedFile(docxAsset);
|
|
await assertGeneratedFile(noAnswerDocxAsset);
|
|
await assertGeneratedFile(dailyPdfAsset);
|
|
await assertGeneratedFile(dailyZipAsset);
|
|
|
|
const answeredDocxText = await docxText(docxAsset);
|
|
assert.match(answeredDocxText, /答案/, 'DOCX with answers should include answer labels');
|
|
assert.match(answeredDocxText, /后端需要统一校验租户/, 'DOCX with answers should include subjective answer text');
|
|
const noAnswerDocxText = await docxText(noAnswerDocxAsset);
|
|
assert.doesNotMatch(noAnswerDocxText, /后端需要统一校验租户/, 'DOCX without answers should not leak subjective answer text');
|
|
assert.doesNotMatch(noAnswerDocxText, /基础加法。/, 'DOCX without explanations should not leak explanations');
|
|
|
|
const dailyZip = await zipEntries(dailyZipAsset);
|
|
assert.equal(dailyZip.manifest.exportType, 'daily_practice', 'daily practice package manifest should keep export type');
|
|
assert.equal(dailyZip.manifest.format, 'daily_practice_zip', 'daily practice package manifest should keep format');
|
|
assert.equal(dailyZip.manifest.safety?.includeAnswers, false, 'daily practice package should record answer redaction');
|
|
assert.ok(dailyZip.names.includes('collage.png'), 'daily practice package should include collage PNG');
|
|
assert.ok(dailyZip.names.includes('collage.svg'), 'daily practice package should include collage SVG source');
|
|
assert.equal(dailyZip.names.filter(name => /^cards\/card-\d{2}\.png$/.test(name)).length, 9, 'daily practice package should include nine PNG cards');
|
|
assert.equal(dailyZip.names.filter(name => /^cards\/card-\d{2}\.svg$/.test(name)).length, 9, 'daily practice package should include nine SVG card sources');
|
|
assert.equal(dailyZip.payload.questions?.[0]?.answerText, undefined, 'daily practice package payload should omit answer text when disabled');
|
|
assert.equal(dailyZip.payload.questions?.[0]?.explanation, undefined, 'daily practice package payload should omit explanations when disabled');
|
|
assert.ok(
|
|
dailyZip.payload.summary?.cardCount >= 1 && dailyZip.payload.summary?.cardCount <= 8,
|
|
'daily practice package payload should cap card count to the nine-grid question slots',
|
|
);
|
|
assert.equal(
|
|
dailyZip.payload.summary?.cardCount,
|
|
dailyZip.manifest.summary?.cardCount,
|
|
'daily practice package manifest and payload should agree on card count',
|
|
);
|
|
|
|
const audits = await pool.query(
|
|
`
|
|
select action, details
|
|
from public.audit_logs
|
|
where tenant_id = $1
|
|
and target_type = 'content_export_job'
|
|
and target_id = any($2::text[])
|
|
`,
|
|
[tenantId, jobIds],
|
|
);
|
|
assert.ok(
|
|
audits.rows.some(row => row.action === 'content.questions.export_rendered' && row.details?.assetId),
|
|
'worker should write rendered audit log',
|
|
);
|
|
|
|
console.log('Export worker integration test complete.');
|
|
} catch (error) {
|
|
await pool.query('rollback').catch(() => {});
|
|
throw error;
|
|
} finally {
|
|
if (seeded) {
|
|
await cleanup(pool).catch(() => {});
|
|
}
|
|
await pool.end();
|
|
}
|
|
}
|
|
|
|
main().catch(error => {
|
|
console.error(error);
|
|
process.exit(1);
|
|
});
|