282 lines
9.1 KiB
Dart
282 lines
9.1 KiB
Dart
import 'package:flutter_test/flutter_test.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/artifact_document.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/artifact_groups.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/artifact_record.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/artifact_summary.dart';
|
|
import 'package:pipelines_app/features/artifacts/domain/gallery_navigation.dart';
|
|
|
|
import 'artifact_fixtures.dart';
|
|
|
|
Map<String, dynamic> _doc(
|
|
String name, {
|
|
String contentType = 'text/markdown',
|
|
int sizeBytes = 12,
|
|
}) => artifact(name, contentType: contentType, sizeBytes: sizeBytes);
|
|
|
|
ArtifactGroup _docGroup(List<String> recorded) {
|
|
final recordedStep = step(
|
|
stage: 'review',
|
|
visit: 1,
|
|
artifacts: [for (final name in recorded) _doc(name)],
|
|
);
|
|
return ArtifactGroup(
|
|
stageKey: 'review',
|
|
visit: 1,
|
|
artifacts: const <ArtifactRecord>[],
|
|
documents: visitDocuments(recordedStep),
|
|
);
|
|
}
|
|
|
|
void main() {
|
|
group('visit documents', () {
|
|
test('a recorded document carries its exact recorded record', () {
|
|
final docs = visitDocuments(
|
|
step(
|
|
stage: 'review',
|
|
visit: 1,
|
|
artifacts: [
|
|
_doc('input.md', sizeBytes: 12),
|
|
_doc('memory.md', sizeBytes: 34),
|
|
_doc('output.md', sizeBytes: 56),
|
|
_doc('session.html', contentType: 'text/html', sizeBytes: 78),
|
|
],
|
|
),
|
|
);
|
|
expect(docs.map((doc) => doc.name), turnDocumentNames);
|
|
expect(docs.every((doc) => doc.record != null), isTrue);
|
|
expect(docs.every((doc) => doc.absence.isEmpty), isTrue);
|
|
expect(docs[0].record!.contentType, 'text/markdown');
|
|
expect(docs[0].record!.sizeBytes, 12);
|
|
expect(docs[3].record!.contentType, 'text/html');
|
|
expect(docs[3].record!.sizeBytes, 78);
|
|
});
|
|
|
|
test('only input and output absent messages use the audit words', () {
|
|
final docs = visitDocuments(
|
|
step(
|
|
stage: 'review',
|
|
visit: 1,
|
|
artifacts: [_doc('input.md'), _doc('output.md')],
|
|
),
|
|
);
|
|
expect(docs[1].record, isNull);
|
|
expect(docs[1].absence, 'No memory recorded for this visit.');
|
|
expect(docs[3].record, isNull);
|
|
expect(docs[3].absence, 'This visit has no harness session.');
|
|
});
|
|
|
|
test('a missing capture yields no slots, never four missing documents', () {
|
|
final docs = visitDocuments(
|
|
step(stage: 'review', visit: 1, includeArtifacts: false),
|
|
);
|
|
expect(docs, isEmpty);
|
|
});
|
|
|
|
test('step fields never stand in for a missing document', () {
|
|
final docs = visitDocuments(<String, dynamic>{
|
|
'stage': 'review',
|
|
'sequence': 1,
|
|
'status': 'completed',
|
|
'input': 'looks like input',
|
|
'memory': 'looks like memory',
|
|
'output': 'looks like output',
|
|
'artifacts': <Map<String, dynamic>>[],
|
|
});
|
|
expect(docs, isEmpty);
|
|
});
|
|
|
|
test('a recorded session id is not reported as no session', () {
|
|
final docs = visitDocuments(<String, dynamic>{
|
|
'stage': 'review',
|
|
'sequence': 1,
|
|
'status': 'completed',
|
|
'session_id': 'ses-42',
|
|
'artifacts': <Map<String, dynamic>>[_doc('input.md')],
|
|
});
|
|
expect(
|
|
docs[3].absence,
|
|
'Session ses-42 is recorded. Its export is not yet available.',
|
|
);
|
|
});
|
|
|
|
test('the session export is external-only even when sniffed as text', () {
|
|
final docs = visitDocuments(
|
|
step(
|
|
stage: 'review',
|
|
visit: 1,
|
|
artifacts: [
|
|
_doc('input.md'),
|
|
_doc('session.html', contentType: 'text/plain', sizeBytes: 99),
|
|
],
|
|
),
|
|
);
|
|
expect(docs[3].externalOnly, isTrue);
|
|
expect(docs[3].opensInViewer, isFalse);
|
|
expect(docs[0].opensInViewer, isTrue);
|
|
});
|
|
|
|
test('the turn document names share the stage filter order', () {
|
|
expect(turnDocumentNames, systemArtifactNames);
|
|
});
|
|
|
|
// Every remaining branch of the contextual session wording is exact product
|
|
// copy, so each is pinned rather than reached only through the probe.
|
|
String sessionAbsence(Map<String, dynamic> fields) =>
|
|
visitDocuments(<String, dynamic>{
|
|
'stage': 'review',
|
|
'sequence': 1,
|
|
'artifacts': <Map<String, dynamic>>[_doc('input.md')],
|
|
...fields,
|
|
})[3].absence;
|
|
|
|
test('a skipped or stopped stage never claims a harness session', () {
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'status': 'skipped'}),
|
|
'This visit was skipped; no harness session was started.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'outcome': 'skipped'}),
|
|
'This visit was skipped; no harness session was started.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'status': 'canceled'}),
|
|
'The stage stopped before a harness session was recorded.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'status': 'interrupted'}),
|
|
'The stage stopped before a harness session was recorded.',
|
|
);
|
|
});
|
|
|
|
test('a model stage states whether its session is running or failed', () {
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'status': 'running', 'model': 'luna'}),
|
|
'The stage session is being created.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'status': 'failed', 'model': 'luna'}),
|
|
'The stage did not create a harness session.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{
|
|
'status': 'failed',
|
|
'model': 'luna',
|
|
'diagnostic': 'provider rejected the request.',
|
|
}),
|
|
'The stage did not create a harness session.'
|
|
' provider rejected the request.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{'provider': 'local'}),
|
|
'Runtime error: this model stage has no recorded session identity.',
|
|
);
|
|
});
|
|
|
|
test('a recorded session reports its export recovery state', () {
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{
|
|
'session_id': 'ses-9',
|
|
'session_export_recovery': <String, dynamic>{'status': 'pending'},
|
|
}),
|
|
'Session ses-9 is recorded. Its export is pending recovery.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{
|
|
'session_id': 'ses-9',
|
|
'session_export_recovery': <String, dynamic>{'status': 'running'},
|
|
}),
|
|
'Session ses-9 is recorded. Its export is pending recovery.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{
|
|
'session_export': <String, dynamic>{
|
|
'session_id': 'ses-8',
|
|
'status': 'complete',
|
|
},
|
|
}),
|
|
'Session ses-8 is recorded.'
|
|
' Its export is not available in the artifact inventory.',
|
|
);
|
|
expect(
|
|
sessionAbsence(<String, dynamic>{
|
|
'session_export': <String, dynamic>{
|
|
'session_id': 'ses-7',
|
|
'status': 'failed',
|
|
'diagnostic': 'Disk full.',
|
|
},
|
|
}),
|
|
'Session ses-7 is recorded. Its export is failed. Disk full.',
|
|
);
|
|
});
|
|
});
|
|
|
|
group('gallery groups', () {
|
|
test('groups documents per visit without changing stage grouping', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'review',
|
|
sequence: 1,
|
|
visit: 1,
|
|
artifacts: [_doc('input.md'), _doc('output.md')],
|
|
),
|
|
step(
|
|
stage: 'review',
|
|
sequence: 2,
|
|
visit: 2,
|
|
artifacts: [_doc('input.md'), _doc('memory.md')],
|
|
),
|
|
];
|
|
expect(artifactGroups(steps), isEmpty);
|
|
final groups = galleryGroups(steps);
|
|
expect(groups.map((group) => group.visit), <int>[1, 2]);
|
|
expect(groups[0].artifacts, isEmpty);
|
|
expect(groups[0].documents[0].record!.sizeBytes, 12);
|
|
expect(groups[1].documents[2].record, isNull);
|
|
expect(groups.map((group) => group.recordedCount), <int>[2, 2]);
|
|
});
|
|
|
|
test('a visit with neither artifacts nor recorded documents is absent', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(stage: 'a', sequence: 1, includeArtifacts: false),
|
|
step(stage: 'a', sequence: 2, artifacts: const []),
|
|
];
|
|
expect(galleryGroups(steps), isEmpty);
|
|
});
|
|
|
|
test('the header counts recorded documents and stage artifacts', () {
|
|
final steps = <Map<String, dynamic>>[
|
|
step(
|
|
stage: 'review',
|
|
sequence: 1,
|
|
visit: 1,
|
|
artifacts: [
|
|
artifact('report.csv', contentType: 'text/csv'),
|
|
_doc('input.md'),
|
|
_doc('output.md'),
|
|
],
|
|
),
|
|
];
|
|
expect(
|
|
artifactsHeader(steps, executing: false),
|
|
'Artifacts · 3 recorded',
|
|
);
|
|
});
|
|
|
|
test(
|
|
'markdown documents page in the viewer but session.html never does',
|
|
() {
|
|
final group = _docGroup(<String>[
|
|
'input.md',
|
|
'output.md',
|
|
'session.html',
|
|
]);
|
|
final pages = pagedArtifacts(<ArtifactGroup>[group]);
|
|
expect(pages.map((page) => page.artifact.name), <String>[
|
|
'input.md',
|
|
'output.md',
|
|
]);
|
|
},
|
|
);
|
|
});
|
|
}
|