a733a927f3
Preserve Settings as an independent navigation destination while landing the reviewed notification and skill-management updates. Keep the server and CLI skill contracts versioned and validated so the merged tree can be verified by the delivery gate.
361 lines
11 KiB
Dart
361 lines
11 KiB
Dart
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:pipelines_app/features/attention/domain/attention_models.dart';
|
|
|
|
Map<String, dynamic> run([Map<String, dynamic> overrides = const {}]) => {
|
|
'id': 1,
|
|
'name': 'Plan and land',
|
|
'title': null,
|
|
'status': 'failed',
|
|
'created_at': '2026-10-19T10:00:00Z',
|
|
'finished_at': '2026-10-19T10:05:00Z',
|
|
'diagnostic': '',
|
|
...overrides,
|
|
};
|
|
|
|
void main() {
|
|
group('qualification', () {
|
|
test('only waiting and failed qualify; every other status asks nobody', () {
|
|
expect(attentionKindOf('waiting'), AttentionKind.decision);
|
|
expect(attentionKindOf('failed'), AttentionKind.failed);
|
|
for (final status in [
|
|
'queued',
|
|
'running',
|
|
'succeeded',
|
|
'canceled',
|
|
'cancelled',
|
|
'interrupted',
|
|
'active',
|
|
'blocked',
|
|
'skipped',
|
|
'unknown',
|
|
'',
|
|
' ',
|
|
null,
|
|
'FAILED?',
|
|
]) {
|
|
expect(
|
|
attentionKindOf(status),
|
|
isNull,
|
|
reason: 'status ${status ?? 'null'} must not qualify',
|
|
);
|
|
}
|
|
});
|
|
|
|
test('trims and lowercases the server words', () {
|
|
expect(attentionKindOf(' Waiting '), AttentionKind.decision);
|
|
expect(attentionKindOf('Failed\n'), AttentionKind.failed);
|
|
expect(attentionKindOf('WAITING'), AttentionKind.decision);
|
|
});
|
|
|
|
test('ranks are Decision 0 then Failed 1', () {
|
|
expect(AttentionKind.decision.rank, 0);
|
|
expect(AttentionKind.failed.rank, 1);
|
|
});
|
|
|
|
test('waiting excludes audit/export handoffs, not resource waits', () {
|
|
expect(
|
|
attentionKindForRun(run({'status': 'waiting'})),
|
|
AttentionKind.decision,
|
|
);
|
|
expect(
|
|
attentionKindForRun(
|
|
run({'status': 'waiting', 'export_pending_sequence': 4}),
|
|
),
|
|
isNull,
|
|
);
|
|
expect(
|
|
attentionKindForRun(
|
|
run({'status': 'waiting', 'export_pending_sequence': ' 2 '}),
|
|
),
|
|
isNull,
|
|
);
|
|
expect(
|
|
attentionKindForRun(
|
|
run({'status': 'waiting', 'export_pending_sequence': 0}),
|
|
),
|
|
AttentionKind.decision,
|
|
);
|
|
// web/src/attention.js and Attention.kt never consult resource_wait; the
|
|
// server retired it, so a stale value must not hide a real decision.
|
|
for (final stale in [
|
|
{'resource': 'device-1'},
|
|
'device-1',
|
|
true,
|
|
1,
|
|
]) {
|
|
expect(
|
|
attentionKindForRun(
|
|
run({'status': 'waiting', 'resource_wait': stale}),
|
|
),
|
|
AttentionKind.decision,
|
|
reason: 'resource_wait $stale must not suppress a decision',
|
|
);
|
|
}
|
|
// A failed run stays failed even if a stale export field survived.
|
|
expect(
|
|
attentionKindForRun(
|
|
run({'status': 'failed', 'export_pending_sequence': 4}),
|
|
),
|
|
AttentionKind.failed,
|
|
);
|
|
expect(
|
|
attentionKindForRun(
|
|
run({'status': 'failed', 'failure_kind': 'expected'}),
|
|
),
|
|
isNull,
|
|
);
|
|
});
|
|
|
|
test(
|
|
'nonqualifying runs are dropped entirely, including malformed ids',
|
|
() {
|
|
final entries = attentionEntries([
|
|
run({'id': 1, 'status': 'succeeded'}),
|
|
run({'id': 2, 'status': 'running'}),
|
|
run({'id': 3, 'status': 'failed'}),
|
|
run({'id': 4, 'status': 'queued'}),
|
|
run({'id': 'not-a-number', 'status': 'failed'}),
|
|
run({'id': 0, 'status': 'failed'}),
|
|
]);
|
|
expect(entries.map((entry) => entry.runId), [3]);
|
|
expect(attentionEntries(null), isEmpty);
|
|
},
|
|
);
|
|
});
|
|
|
|
group('identity and wording', () {
|
|
test('identity is exactly {runId}:{kind}', () {
|
|
expect(attentionKey(440, AttentionKind.failed), '440:Failed');
|
|
expect(attentionKey(12, AttentionKind.decision), '12:Decision');
|
|
});
|
|
|
|
test('label is the trimmed title else the pipeline name', () {
|
|
expect(attentionEntryFor(run({'title': ' My run '}))!.label, 'My run');
|
|
expect(attentionEntryFor(run({'title': ' '}))!.label, 'Plan and land');
|
|
expect(attentionEntryFor(run({'title': null}))!.label, 'Plan and land');
|
|
});
|
|
|
|
test(
|
|
'detail is the decision line or the trimmed diagnostic else Run failed',
|
|
() {
|
|
expect(
|
|
attentionDetail(AttentionKind.decision, run({'status': 'waiting'})),
|
|
'Waiting for your decision',
|
|
);
|
|
expect(
|
|
attentionDetail(
|
|
AttentionKind.failed,
|
|
run({'diagnostic': ' boom '}),
|
|
),
|
|
'boom',
|
|
);
|
|
expect(
|
|
attentionDetail(AttentionKind.failed, run({'diagnostic': ' '})),
|
|
'Run failed',
|
|
);
|
|
expect(
|
|
attentionDetail(AttentionKind.failed, run({'diagnostic': null})),
|
|
'Run failed',
|
|
);
|
|
expect(
|
|
attentionDetail(
|
|
AttentionKind.failed,
|
|
run({
|
|
'diagnostic': 'generic diagnostic',
|
|
'failure_reason': 'Provider authentication failed',
|
|
}),
|
|
),
|
|
'Provider authentication failed',
|
|
);
|
|
expect(
|
|
attentionDetail(
|
|
AttentionKind.failed,
|
|
run({
|
|
'diagnostic': 'generic diagnostic',
|
|
'failure_reason': ' ',
|
|
}),
|
|
),
|
|
'generic diagnostic',
|
|
);
|
|
},
|
|
);
|
|
|
|
test('row description is exactly {pipeline} · {detail}', () {
|
|
final entry = attentionEntryFor(
|
|
run({'title': 'T', 'diagnostic': 'failed hard'}),
|
|
)!;
|
|
expect(attentionRowDescription(entry), 'Plan and land · failed hard');
|
|
});
|
|
|
|
test('badge label is bare Notifications when empty, else the count', () {
|
|
expect(attentionBadgeLabel(0), 'Notifications');
|
|
expect(attentionBadgeLabel(-3), 'Notifications');
|
|
expect(attentionBadgeLabel(1), 'Notifications, 1 needing attention');
|
|
expect(attentionBadgeLabel(171), 'Notifications, 171 needing attention');
|
|
});
|
|
|
|
test('the entry keeps the whole summary, including unknown fields', () {
|
|
final source = run({
|
|
'unknown_future_field': {'keep': true},
|
|
'id': 7,
|
|
});
|
|
final entry = attentionEntryFor(source)!;
|
|
expect(entry.run['unknown_future_field'], {'keep': true});
|
|
expect(entry.run, same(source));
|
|
});
|
|
});
|
|
|
|
group('ordering', () {
|
|
test('kind rank, then recency descending, then run id descending', () {
|
|
final entries = attentionEntries([
|
|
run({
|
|
'id': 10,
|
|
'status': 'failed',
|
|
'finished_at': '2026-10-19T10:00:00Z',
|
|
}),
|
|
run({
|
|
'id': 11,
|
|
'status': 'waiting',
|
|
'finished_at': '2026-10-19T09:00:00Z',
|
|
}),
|
|
run({
|
|
'id': 12,
|
|
'status': 'failed',
|
|
'finished_at': '2026-10-19T11:00:00Z',
|
|
}),
|
|
run({
|
|
'id': 13,
|
|
'status': 'waiting',
|
|
'finished_at': '2026-10-19T08:00:00Z',
|
|
}),
|
|
]);
|
|
expect(entries.map((entry) => entry.runId), [11, 13, 12, 10]);
|
|
});
|
|
|
|
test('recency falls back to created_at when finished_at is blank', () {
|
|
final entries = attentionEntries([
|
|
run({
|
|
'id': 1,
|
|
'status': 'failed',
|
|
'finished_at': '',
|
|
'created_at': '2026-10-19T12:00:00Z',
|
|
}),
|
|
run({
|
|
'id': 2,
|
|
'status': 'failed',
|
|
'finished_at': '2026-10-19T11:00:00Z',
|
|
}),
|
|
]);
|
|
expect(entries.map((entry) => entry.runId), [1, 2]);
|
|
});
|
|
|
|
test('equal kind and recency tie by run id descending and stay stable', () {
|
|
final rows = [
|
|
run({'id': 3, 'finished_at': '2026-10-19T10:00:00Z'}),
|
|
run({'id': 9, 'finished_at': '2026-10-19T10:00:00Z'}),
|
|
run({'id': 5, 'finished_at': '2026-10-19T10:00:00Z'}),
|
|
];
|
|
expect(attentionEntries(rows).map((entry) => entry.runId), [9, 5, 3]);
|
|
expect(attentionEntries(rows.reversed).map((entry) => entry.runId), [
|
|
9,
|
|
5,
|
|
3,
|
|
]);
|
|
});
|
|
});
|
|
|
|
group('local-day window', () {
|
|
final since = DateTime.utc(2026, 10, 20);
|
|
final rows = [
|
|
run({'id': 1, 'finished_at': '2026-10-19T21:33:27Z'}),
|
|
run({'id': 2, 'finished_at': '2026-10-20T10:00:00Z'}),
|
|
];
|
|
|
|
test('startOfLocalDay is local midnight, injectable for tests', () {
|
|
final now = DateTime(2026, 10, 20, 15, 4, 5, 6);
|
|
final start = startOfLocalDay(now: now);
|
|
expect(start, DateTime(2026, 10, 20));
|
|
expect(start.hour, 0);
|
|
expect(start.minute, 0);
|
|
expect(start.second, 0);
|
|
expect(start.millisecond, 0);
|
|
expect(start.isBefore(now), isTrue);
|
|
expect(start.toLocal(), start);
|
|
});
|
|
|
|
test('a cutoff drops older work and keeps newer work', () {
|
|
expect(attentionEntries(rows, since: since).map((entry) => entry.runId), [
|
|
2,
|
|
]);
|
|
});
|
|
|
|
test('no cutoff, and an epoch-zero cutoff, show everything', () {
|
|
expect(attentionEntries(rows).map((entry) => entry.runId), [2, 1]);
|
|
expect(
|
|
attentionEntries(
|
|
rows,
|
|
since: DateTime.fromMillisecondsSinceEpoch(0),
|
|
).map((entry) => entry.runId),
|
|
[2, 1],
|
|
);
|
|
});
|
|
|
|
test('the cutoff applies to waiting decisions as well as failures', () {
|
|
expect(
|
|
attentionEntries([
|
|
run({
|
|
'id': 3,
|
|
'status': 'waiting',
|
|
'finished_at': '2026-10-19T09:00:00Z',
|
|
}),
|
|
], since: since),
|
|
isEmpty,
|
|
);
|
|
});
|
|
|
|
test('unparseable or blank recency is kept, as in the browser', () {
|
|
for (final recency in ['', ' ', 'not a timestamp']) {
|
|
final kept = attentionEntries([
|
|
run({'id': 4, 'finished_at': recency, 'created_at': recency}),
|
|
], since: since);
|
|
expect(
|
|
kept.map((entry) => entry.runId),
|
|
[4],
|
|
reason: 'recency ${recency.isEmpty ? '<blank>' : recency} is kept',
|
|
);
|
|
}
|
|
});
|
|
|
|
test('finished_at is the recency the cutoff reads, else created_at', () {
|
|
expect(
|
|
attentionEntries([
|
|
run({
|
|
'id': 5,
|
|
'created_at': '2026-10-18T09:00:00Z',
|
|
'finished_at': '2026-10-20T09:00:00Z',
|
|
}),
|
|
], since: since).map((entry) => entry.runId),
|
|
[5],
|
|
);
|
|
expect(
|
|
attentionEntries([
|
|
run({
|
|
'id': 6,
|
|
'created_at': '2026-10-18T09:00:00Z',
|
|
'finished_at': '',
|
|
}),
|
|
], since: since),
|
|
isEmpty,
|
|
);
|
|
});
|
|
|
|
test('dismissal and the cutoff compose', () {
|
|
final dismissed = attentionDismiss(const {}, '2:Failed');
|
|
expect(
|
|
attentionEntries(rows, dismissed: dismissed, since: since),
|
|
isEmpty,
|
|
);
|
|
});
|
|
});
|
|
}
|