170 lines
13 KiB
JavaScript
170 lines
13 KiB
JavaScript
// Explicit, disposable local PostgreSQL only. Never reads .env or uses the app DB.
|
||
// LTJT_ARRANGEMENT_TEST_DATABASE_URL=postgresql://...@127.0.0.1:PORT/ledger_test \
|
||
// node --import tsx tools/arrangement-ledger-postgres-smoke.mjs
|
||
import assert from 'node:assert/strict';
|
||
import { randomUUID } from 'node:crypto';
|
||
import { readFile, readdir } from 'node:fs/promises';
|
||
import { loadConfig } from '../control-plane/src/config.ts';
|
||
import { getPool, closePool, quoteIdentifier } from '../control-plane/src/db.ts';
|
||
import { encryptText } from '../control-plane/src/crypto.ts';
|
||
import { ArrangementLedger, currentArrangements } from '../control-plane/src/arrangement-ledger.ts';
|
||
import { TaskService } from '../control-plane/src/task-service.ts';
|
||
import { TeamProgressLedger } from '../control-plane/src/team-progress.ts';
|
||
import { taskResultText } from '../control-plane/src/agentbus.ts';
|
||
|
||
const rawUrl = process.env.LTJT_ARRANGEMENT_TEST_DATABASE_URL;
|
||
if (!rawUrl) throw new Error('Set LTJT_ARRANGEMENT_TEST_DATABASE_URL to a disposable local ledger_test database.');
|
||
const url = new URL(rawUrl);
|
||
assert.ok(['127.0.0.1', 'localhost', '[::1]'].includes(url.hostname) && url.pathname === '/ledger_test');
|
||
const schema = `ledger_smoke_${randomUUID().replaceAll('-', '')}`;
|
||
const config = loadConfig({ NODE_ENV: 'test', DATABASE_URL: rawUrl, DATABASE_SCHEMA: schema,
|
||
FIELD_ENCRYPTION_KEY: Buffer.alloc(32, 31).toString('base64') });
|
||
const pool = getPool(config);
|
||
const ledger = new ArrangementLedger(config);
|
||
const progress = new TeamProgressLedger(config);
|
||
let created = false;
|
||
try {
|
||
await pool.query(`CREATE SCHEMA ${quoteIdentifier(schema)}`);
|
||
created = true;
|
||
const migrationDir = new URL('../control-plane/migrations/', import.meta.url);
|
||
const migrations = (await readdir(migrationDir)).filter(name => /^\d+_.+\.sql$/.test(name)).sort();
|
||
for (const name of migrations) await pool.query(await readFile(new URL(name, migrationDir), 'utf8'));
|
||
const org = (await pool.query(`INSERT INTO organizations (slug, name) VALUES ('ledger-fixture', 'Ledger fixture') RETURNING id`)).rows[0].id;
|
||
const otherOrg = (await pool.query(`INSERT INTO organizations (slug, name) VALUES ('ledger-other', 'Other fixture') RETURNING id`)).rows[0].id;
|
||
const users = (await pool.query(`INSERT INTO users (organization_id, username, password_hash, role)
|
||
VALUES ($1,'ledger-a','fixture','user'),($1,'ledger-b','fixture','user'),($1,'ledger-admin','fixture','admin') RETURNING id, username`, [org])).rows;
|
||
const context = name => ({ organizationId: org, userId: users.find(u => u.username === name).id, role: 'user', requestId: 'ledger-smoke' });
|
||
const ownerA = context('ledger-a'), ownerB = context('ledger-b');
|
||
const service = new TaskService(config);
|
||
// No browser or ERP is involved. All remaining persistence and auth paths are real.
|
||
service.requireBrowserConnection = async () => {};
|
||
|
||
async function task(owner, action = 'arrangement_hotel', mode = 'create', rowId = '100', group = 'LW-TEST-A') {
|
||
const taskId = `TASK-${randomUUID()}`, executionId = randomUUID();
|
||
const operation = { action, data: { existing_refs: { identifier: group }, arrangement: {
|
||
mode, target: { row_id: rowId }, start_date: '2026-09-16', end_date: '2026-09-17', room_count: 8
|
||
} } };
|
||
const result = { status: 'completed', execution_id: executionId, no_erp_write: false, write_attempted: true,
|
||
report: { status: 'lifecycle_completed', resolved_refs: { identifier: group, kind: 'independent_order' },
|
||
server_response: { completed: true }, requery: { matched: true, subpage: { matched: true,
|
||
arrangement_target: { row_id: rowId, resource_id: '700', item_value: 'TWN', quantity_value: '8', cleared: mode === 'clear' },
|
||
checks: [{ field: action === 'arrangement_guide' ? 'daoyou0' : 'danwei0', matched: true, actual: '实际资源' }]
|
||
} } } };
|
||
const inserted = await pool.query(`INSERT INTO tasks
|
||
(organization_id, task_id, created_by, assigned_user_id, status, stage, lease_owner, operation, operation_ciphertext)
|
||
VALUES ($1,$2,$3,$3,'running','lifecycle_live','browser:fixture',$4,$5) RETURNING id`,
|
||
[org, taskId, owner.userId, { action }, encryptText(config, JSON.stringify(operation))]);
|
||
await pool.query(`INSERT INTO task_attempts (id, organization_id, task_id, attempt_no, phase, status, details)
|
||
VALUES ($1,$2,$3,1,'erp','running',$4)`, [executionId, org, inserted.rows[0].id, { connection_id: 'fixture' }]);
|
||
return { taskId, executionId, operation, result };
|
||
}
|
||
const complete = (owner, item) => service.recordExecutionResult(owner, item.taskId, item.result, 'fixture', item.executionId, { skipArtifactPersistence: true });
|
||
const first = await task(ownerA);
|
||
const receipt = await complete(ownerA, first);
|
||
assert.match(receipt.important_message.text, /酒店：已安排/);
|
||
assert.equal(taskResultText(receipt), receipt.important_message.text, 'AgentBus preserves the summary');
|
||
await complete(ownerA, first);
|
||
assert.equal((await ledger.history(pool, ownerA, 'LW-TEST-A')).length, 1, 'idempotent result ingestion');
|
||
assert.equal((await ledger.history(pool, ownerB, 'LW-TEST-A')).length, 0);
|
||
assert.equal((await ledger.history(pool, { ...ownerA, organizationId: otherOrg }, 'LW-TEST-A')).length, 0);
|
||
const guide = await task(ownerA, 'arrangement_guide');
|
||
const next = await complete(ownerA, guide);
|
||
assert.match(next.important_message.text, /导游：已安排[\s\S]*酒店：已安排/);
|
||
assert.match((await service.getTask(org, first.taskId, ownerA)).important_message.text, /导游：未安排/, 'old receipt stays frozen');
|
||
await service.hardDeleteTask(ownerA, first.taskId);
|
||
const retained = await ledger.history(pool, ownerA, 'LW-TEST-A');
|
||
assert.ok(retained.find(e => e.source_task_id === first.taskId).source_task_deleted_at);
|
||
assert.equal(retained.find(e => e.source_task_id === first.taskId).details.resource_name, '实际资源');
|
||
assert.equal((await pool.query('SELECT 1 FROM task_attempts WHERE id = $1', [first.executionId])).rowCount, 0);
|
||
assert.equal(currentArrangements(retained).length, 2, 'task cascade leaves ledger intact');
|
||
assert.ok((await progress.history(pool, ownerA, 'LW-TEST-A')).find(e => e.source_task_id === first.taskId).source_task_deleted_at);
|
||
|
||
const secondHotel = await task(ownerA, 'arrangement_hotel', 'create', '200');
|
||
await complete(ownerA, secondHotel);
|
||
await complete(ownerA, await task(ownerA, 'arrangement_hotel', 'clear', '100'));
|
||
assert.equal(currentArrangements(await ledger.history(pool, ownerA, 'LW-TEST-A')).filter(e => e.action === 'arrangement_hotel').length, 1);
|
||
|
||
// A failure after ledger insertion must roll back both task outcome and ledger.
|
||
const rollback = await task(ownerA, 'arrangement_vehicle');
|
||
const emit = service.emitEvent;
|
||
service.emitEvent = async () => { throw new Error('injected-event-failure'); };
|
||
await assert.rejects(complete(ownerA, rollback), /injected-event-failure/);
|
||
service.emitEvent = emit;
|
||
assert.equal((await pool.query('SELECT status FROM tasks WHERE task_id = $1', [rollback.taskId])).rows[0].status, 'running');
|
||
assert.ok(!(await ledger.history(pool, ownerA, 'LW-TEST-A')).some(e => e.execution_id === rollback.executionId));
|
||
assert.ok(!(await progress.history(pool, ownerA, 'LW-TEST-A')).some(e => e.execution_id === rollback.executionId));
|
||
|
||
// Deleting an archived, pre-feature success as the first interaction backfills it.
|
||
const historic = await task(ownerB, 'arrangement_transport');
|
||
await pool.query(`UPDATE tasks SET status = 'completed', archived_at = now(), success_receipt_at = now(),
|
||
execution_result_ciphertext = $2, execution_result = $3 WHERE task_id = $1`, [historic.taskId, encryptText(config, JSON.stringify(historic.result)), {execution_id:historic.executionId}]);
|
||
await service.hardDeleteTask(ownerB, historic.taskId);
|
||
const backfill = await ledger.history(pool, ownerB, 'LW-TEST-A');
|
||
assert.equal(backfill.length, 1);
|
||
assert.equal(backfill[0].action, 'arrangement_transport');
|
||
assert.equal((await progress.history(pool, ownerB, 'LW-TEST-A')).length, 1);
|
||
assert.ok(backfill[0].source_task_deleted_at);
|
||
assert.ok(!(await ledger.history(pool, ownerA, 'LW-TEST-A')).some(e => e.execution_id === historic.executionId));
|
||
|
||
await assert.rejects(pool.query(`INSERT INTO arrangement_ledger_owners (organization_id, owner_user_id) VALUES ($1,$2)`,
|
||
[org, context('ledger-admin').userId]), e => e.code === '23514');
|
||
await assert.rejects(pool.query(`INSERT INTO arrangement_ledger_owners (organization_id, owner_user_id) VALUES ($1,$2)`,
|
||
[otherOrg, ownerA.userId]), e => e.code === '23503');
|
||
// Exercise the same transactional API for non-arrangement operations.
|
||
async function business(owner, action, data, refs, extra = {}) {
|
||
const item = await task(owner, action);
|
||
item.operation = {action, data};
|
||
item.result = {...item.result, summary:{action}, report:{...item.result.report, resolved_refs:refs}, ...extra};
|
||
await pool.query('UPDATE tasks SET operation = $2, operation_ciphertext = $3 WHERE task_id = $1',
|
||
[item.taskId,{action},encryptText(config,JSON.stringify(item.operation))]);
|
||
return item;
|
||
}
|
||
const parentRefs = {kind:'shared_plan',identifier:'LW-PROGRESS'};
|
||
const childRefs = {kind:'shared_child_order',identifier:'D300',parent_group_no:'LW-PROGRESS'};
|
||
const plan = await business(ownerA,'shared_plan_create',{},parentRefs);
|
||
await complete(ownerA,plan);
|
||
const child = await business(ownerA,'shared_child_order_create',{},childRefs,{erp_receipt:{order_number:'D300',parent_group_no:'LW-PROGRESS'}});
|
||
await complete(ownerA,child);
|
||
for (const count of [20,18]) {
|
||
const item = await business(ownerA,'passenger_list_import',{passenger_list:{row_count:count,tsv:'PRIVATE ROSTER'}},childRefs);
|
||
const outcome = await complete(ownerA,item);
|
||
assert.match(outcome.important_message.text,new RegExp('D300 名单：已导入，最近一次 '+count+' 人'));
|
||
assert.doesNotMatch(outcome.important_message.text,/PRIVATE ROSTER/);
|
||
if(count===18) await service.hardDeleteTask(ownerA,item.taskId);
|
||
}
|
||
const cancel = await business(ownerA,'order_cancel',{transition:{to_status:'已取消'}},parentRefs);
|
||
cancel.result.report.requery={matched:true,child_status_propagation_matched:true,child_refs:[{ddid:'300'}]};
|
||
await complete(ownerA,cancel);
|
||
const restore = await business(ownerA,'order_restore',{transition:{to_status:'已恢复'}},parentRefs);
|
||
const restored = await complete(ownerA,restore);
|
||
assert.match(restored.important_message.text,/订单状态：已恢复/);
|
||
assert.match(restored.important_message.text,/子单 D300.*已取消/);
|
||
assert.match(restored.important_message.text,/最近一次 18 人/,'latest roster survives deletion');
|
||
assert.match((await service.getTask(org,plan.taskId,ownerA)).important_message.text,/本系统记录子单：0个/,'old snapshot stays frozen');
|
||
assert.equal((await progress.history(pool,ownerB,'LW-PROGRESS')).length,0);
|
||
assert.equal((await progress.history(pool,{...ownerA,organizationId:otherOrg},'LW-PROGRESS')).length,0);
|
||
const partial = await business(ownerA,'shared_child_order_batch_create',{},parentRefs,{
|
||
status:'reconciliation_pending',uncertain:true,report:{status:'split_child_batch_stopped_after_write',batch_results:[
|
||
{status:'completed',adapter_status:'split_child_completed',parent_group_no:'LW-PARTIAL',child_order_no:'D401',blockers:[]},
|
||
{status:'uncertain',parent_group_no:'LW-PARTIAL',child_order_no:'D402'}]}
|
||
});
|
||
const partialOutcome = await complete(ownerA,partial);
|
||
assert.equal(partialOutcome.status,'reconciliation_pending');
|
||
assert.deepEqual((await progress.history(pool,ownerA,'LW-PARTIAL')).map(e=>e.subject_number),['D401']);
|
||
assert.ok(!partialOutcome.success_receipt,'partial progress does not produce a success receipt');
|
||
await assert.rejects(pool.query('INSERT INTO team_progress_owners (organization_id, owner_user_id) VALUES ($1,$2)',
|
||
[org,context('ledger-admin').userId]),e=>e.code==='23514');
|
||
await assert.rejects(pool.query('INSERT INTO team_progress_owners (organization_id, owner_user_id) VALUES ($1,$2)',
|
||
[otherOrg,ownerA.userId]),e=>e.code==='23503');
|
||
console.log(JSON.stringify({ ok: true, migrations: migrations.length, verified: [
|
||
'real migrations', 'result ingestion and public/AgentBus receipts', 'deduplication', 'account/org isolation',
|
||
'frozen receipts', 'force-delete retention', 'row-specific clear', 'transaction rollback',
|
||
'archived historical backfill before delete', 'admin and cross-org ownership constraints',
|
||
'non-arrangement receipts', 'per-child latest roster without private data', 'retained roster after delete', 'parent restore preserves child cancellation',
|
||
'partial batch proven rows without false task success'
|
||
] }));
|
||
} finally {
|
||
if (created) await pool.query(`DROP SCHEMA ${quoteIdentifier(schema)} CASCADE`);
|
||
await closePool();
|
||
}
|