297 lines
9.1 KiB
TypeScript
297 lines
9.1 KiB
TypeScript
import Database from 'better-sqlite3';
|
|
import { describe, expect, it } from 'vitest';
|
|
|
|
import { migrateDatabase } from '../../infrastructure/database/migrations.js';
|
|
import { JobQueryError, JobQueryService } from './job-query-service.js';
|
|
|
|
const t1 = '2026-07-17T10:00:00.000Z';
|
|
const t2 = '2026-07-17T11:00:00.000Z';
|
|
|
|
function setup(): { db: Database.Database; subject: JobQueryService } {
|
|
const db = new Database(':memory:');
|
|
migrateDatabase(db);
|
|
return { db, subject: new JobQueryService(db) };
|
|
}
|
|
|
|
function insertJob(
|
|
db: Database.Database,
|
|
values: Partial<Record<'id' | 'root' | 'operation' | 'status' | 'created', unknown>> = {},
|
|
): void {
|
|
const id = values.id ?? 'job-1';
|
|
const root = Object.prototype.hasOwnProperty.call(values, 'root') ? values.root : id;
|
|
db.prepare(
|
|
`INSERT INTO jobs
|
|
(id, root_job_id, operation_id, risk_level, status, requested_by, request_id,
|
|
parameters_digest, created_at, updated_at)
|
|
VALUES (?, ?, ?, 'R1', ?, 'actor', 'request-1', 'digest', ?, ?)`,
|
|
).run(
|
|
id,
|
|
root,
|
|
values.operation ?? 'op.one',
|
|
values.status ?? 'succeeded',
|
|
values.created ?? t1,
|
|
values.created ?? t1,
|
|
);
|
|
}
|
|
|
|
function insertItem(db: Database.Database, overrides: Record<string, unknown> = {}): void {
|
|
const row = {
|
|
id: 'item-1',
|
|
job: 'job-1',
|
|
instance: 'instance-1',
|
|
status: 'succeeded',
|
|
source: null,
|
|
error: null,
|
|
created: t1,
|
|
...overrides,
|
|
};
|
|
db.prepare(
|
|
`INSERT INTO job_items
|
|
(id, job_id, instance_id, attempt_number, status, error_json, source_job_item_id,
|
|
created_at, updated_at)
|
|
VALUES (?, ?, ?, 1, ?, ?, ?, ?, ?)`,
|
|
).run(row.id, row.job, row.instance, row.status, row.error, row.source, row.created, row.created);
|
|
}
|
|
|
|
function insertAttempt(db: Database.Database, overrides: Record<string, unknown> = {}): void {
|
|
const row = {
|
|
id: 'attempt-1',
|
|
job: 'job-1',
|
|
status: 'succeeded',
|
|
started: t1,
|
|
finished: t2,
|
|
created: t1,
|
|
...overrides,
|
|
};
|
|
db.prepare(
|
|
`INSERT INTO job_attempts (id, job_id, status, started_at, finished_at, created_at)
|
|
VALUES (?, ?, ?, ?, ?, ?)`,
|
|
).run(row.id, row.job, row.status, row.started, row.finished, row.created);
|
|
}
|
|
|
|
function expectCode(action: () => unknown, code: string): void {
|
|
try {
|
|
action();
|
|
} catch (error) {
|
|
expect(error).toBeInstanceOf(JobQueryError);
|
|
expect((error as JobQueryError).code).toBe(code);
|
|
return;
|
|
}
|
|
throw new Error('expected JobQueryError');
|
|
}
|
|
|
|
describe('JobQueryService', () => {
|
|
it.each(['queued', 'running', 'cancelling'])(
|
|
'projects only terminal items while a %s job is active and retains its running attempt',
|
|
(status) => {
|
|
const { db, subject } = setup();
|
|
insertJob(db, { status });
|
|
insertItem(db, { id: 'terminal', instance: 'done', status: 'succeeded' });
|
|
insertItem(db, { id: 'internal', instance: 'pending', status: 'running' });
|
|
insertAttempt(db, { status: 'running', finished: null });
|
|
|
|
expect(subject.get('job-1')).toMatchObject({
|
|
status,
|
|
items: [{ id: 'terminal', targetId: 'done', state: 'succeeded' }],
|
|
attempts: [{ id: 'attempt-1', state: 'running', startedAt: t1 }],
|
|
});
|
|
},
|
|
);
|
|
|
|
it('returns the exact frozen projection with deterministic child ordering', () => {
|
|
const { db, subject } = setup();
|
|
insertJob(db);
|
|
insertItem(db, { id: 'item-z', instance: 'target-z' });
|
|
insertItem(db, { id: 'item-a', instance: 'target-a', source: 'item-z' });
|
|
insertAttempt(db, { id: 'attempt-z', started: t1 });
|
|
insertAttempt(db, { id: 'attempt-a', started: t1, status: 'running', finished: null });
|
|
|
|
expect(subject.get('job-1')).toEqual({
|
|
id: 'job-1',
|
|
operationId: 'op.one',
|
|
status: 'succeeded',
|
|
rootJobId: 'job-1',
|
|
items: [
|
|
{ id: 'item-a', targetId: 'target-a', state: 'succeeded', sourceJobItemId: 'item-z' },
|
|
{ id: 'item-z', targetId: 'target-z', state: 'succeeded' },
|
|
],
|
|
attempts: [
|
|
{ id: 'attempt-a', state: 'running', startedAt: t1 },
|
|
{ id: 'attempt-z', state: 'succeeded', startedAt: t1, finishedAt: t2 },
|
|
],
|
|
createdAt: t1,
|
|
});
|
|
});
|
|
|
|
it('paginates in SQL with filters and an ascending id tie-break independent of direction', () => {
|
|
const { db, subject } = setup();
|
|
insertJob(db, { id: 'z', operation: 'same', created: t2 });
|
|
insertJob(db, { id: 'a', operation: 'same', created: t2 });
|
|
insertJob(db, { id: 'other', operation: 'other', created: t1 });
|
|
insertItem(db, { id: 'z-item', job: 'z', instance: 'wanted' });
|
|
insertItem(db, { id: 'a-item', job: 'a', instance: 'wanted' });
|
|
|
|
expect(
|
|
subject.list({
|
|
page: 1,
|
|
pageSize: 1,
|
|
sort: 'createdAt',
|
|
direction: 'desc',
|
|
operationId: 'same',
|
|
status: 'succeeded',
|
|
rootJobId: 'z',
|
|
instanceId: 'wanted',
|
|
}),
|
|
).toEqual({
|
|
items: [expect.objectContaining({ id: 'z' })],
|
|
page: { page: 1, pageSize: 1, total: 1 },
|
|
});
|
|
expect(
|
|
subject.list({ sort: 'createdAt', direction: 'desc' }).items.map(({ id }) => id),
|
|
).toEqual(['a', 'z', 'other']);
|
|
});
|
|
|
|
it('reports not found without exposing database details', () => {
|
|
const { subject } = setup();
|
|
expect(() => subject.get('missing')).toThrow('Job was not found');
|
|
expectCode(() => subject.get('missing'), 'NOT_FOUND');
|
|
});
|
|
|
|
it.each([
|
|
[{ page: 0 }, 'page'],
|
|
[{ page: 1.5 }, 'page'],
|
|
[{ pageSize: 0 }, 'pageSize'],
|
|
[{ pageSize: 101 }, 'pageSize'],
|
|
[{ sort: 'id' }, 'sort'],
|
|
[{ direction: 'sideways' }, 'direction'],
|
|
])('rejects invalid query input: %j', (query, field) => {
|
|
const { subject } = setup();
|
|
expect(() => subject.list(query as never)).toThrow(new RegExp(field, 'i'));
|
|
expectCode(() => subject.list(query as never), 'VALIDATION_FAILED');
|
|
});
|
|
|
|
it.each([
|
|
[
|
|
'job status',
|
|
() => {
|
|
const x = setup();
|
|
insertJob(x.db, { status: 'invented' });
|
|
return x;
|
|
},
|
|
],
|
|
[
|
|
'missing root',
|
|
() => {
|
|
const x = setup();
|
|
insertJob(x.db, { root: null });
|
|
return x;
|
|
},
|
|
],
|
|
[
|
|
'running item',
|
|
() => {
|
|
const x = setup();
|
|
insertJob(x.db);
|
|
insertItem(x.db, { status: 'running' });
|
|
return x;
|
|
},
|
|
],
|
|
[
|
|
'attempt state',
|
|
() => {
|
|
const x = setup();
|
|
insertJob(x.db);
|
|
x.db.pragma('ignore_check_constraints = ON');
|
|
insertAttempt(x.db, { status: 'queued' });
|
|
return x;
|
|
},
|
|
],
|
|
[
|
|
'timestamp',
|
|
() => {
|
|
const x = setup();
|
|
insertJob(x.db, { created: '2026-07-17T10:00:00Z' });
|
|
return x;
|
|
},
|
|
],
|
|
])('fails the whole selection as UNREPRESENTABLE for invalid persisted %s', (_name, make) => {
|
|
const { subject } = make();
|
|
expectCode(() => subject.list(), 'UNREPRESENTABLE');
|
|
});
|
|
|
|
it.each([
|
|
[
|
|
'items',
|
|
(db: Database.Database, count: number) => {
|
|
const insert = db.prepare(
|
|
`INSERT INTO job_items
|
|
(id, job_id, instance_id, attempt_number, status, created_at, updated_at)
|
|
VALUES (?, 'job-1', 'instance-1', ?, 'succeeded', ?, ?)`,
|
|
);
|
|
db.transaction(() => {
|
|
for (let index = 1; index <= count; index += 1)
|
|
insert.run(`item-${index}`, index, t1, t1);
|
|
})();
|
|
},
|
|
],
|
|
[
|
|
'attempts',
|
|
(db: Database.Database, count: number) => {
|
|
const insert = db.prepare(
|
|
`INSERT INTO job_attempts (id, job_id, status, started_at, finished_at, created_at)
|
|
VALUES (?, 'job-1', 'succeeded', ?, ?, ?)`,
|
|
);
|
|
db.transaction(() => {
|
|
for (let index = 1; index <= count; index += 1)
|
|
insert.run(`attempt-${index}`, t1, t2, t1);
|
|
})();
|
|
},
|
|
],
|
|
])('bounds hydrated child %s at 1000 rows per selected job', (_name, populate) => {
|
|
const atBound = setup();
|
|
insertJob(atBound.db);
|
|
populate(atBound.db, 1000);
|
|
expect(atBound.subject.get('job-1')).toBeDefined();
|
|
|
|
const overBound = setup();
|
|
insertJob(overBound.db);
|
|
populate(overBound.db, 1001);
|
|
expectCode(() => overBound.subject.get('job-1'), 'UNREPRESENTABLE');
|
|
});
|
|
|
|
it('emits only a closed redacted item error and omits malformed optional errors', () => {
|
|
const { db, subject } = setup();
|
|
insertJob(db);
|
|
insertItem(db, {
|
|
id: 'good',
|
|
instance: 'instance-good',
|
|
error: JSON.stringify({
|
|
type: 'https://evil/secret',
|
|
title: 'database password leaked',
|
|
status: 502,
|
|
detail: 'password=secret',
|
|
code: 'UPSTREAM_FAILED',
|
|
requestId: 'req-safe',
|
|
extra: 'secret',
|
|
}),
|
|
});
|
|
insertItem(db, { id: 'bad', instance: 'instance-bad', error: '{bad json' });
|
|
expect(subject.get('job-1').items).toEqual([
|
|
{ id: 'bad', targetId: 'instance-bad', state: 'succeeded' },
|
|
{
|
|
id: 'good',
|
|
targetId: 'instance-good',
|
|
state: 'succeeded',
|
|
error: {
|
|
type: 'about:blank',
|
|
title: 'Job item failed',
|
|
status: 502,
|
|
detail: 'The job item did not complete successfully.',
|
|
code: 'UPSTREAM_FAILED',
|
|
requestId: 'req-safe',
|
|
},
|
|
},
|
|
]);
|
|
});
|
|
});
|