feat(app): turn documents in the artifact gallery

This commit is contained in:
2026-10-22 03:24:40 +01:00
parent 4f684ba467
commit 3fa4657be7
18 changed files with 1365 additions and 168 deletions
@@ -0,0 +1,281 @@
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',
]);
},
);
});
}
@@ -0,0 +1,183 @@
import 'dart:typed_data';
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/artifacts/ui/artifact_external_open.dart';
import 'package:pipelines_app/features/artifacts/ui/artifact_gallery_page.dart';
import 'package:pipelines_app/features/artifacts/ui/artifact_viewer_fetch.dart';
import 'package:pipelines_app/features/artifacts/ui/artifact_viewer_page.dart';
import '../domain/artifact_fixtures.dart';
enum _Platform { material, cupertino }
const String _endpoint = 'ws://127.0.0.1:8081/connect';
JsonMap _recorded(
String name, {
required String contentType,
required int sizeBytes,
}) => artifact(name, contentType: contentType, sizeBytes: sizeBytes);
/// Visit 1 records every turn document except memory. Visit 2 records input and
/// memory only, so both visits carry recorded and missing document slots.
List<JsonMap> _steps() => <JsonMap>[
step(
stage: 'review',
sequence: 1,
visit: 1,
artifacts: [
_recorded('report.csv', contentType: 'text/csv', sizeBytes: 23),
_recorded('input.md', contentType: 'text/markdown', sizeBytes: 120),
_recorded('output.md', contentType: 'text/markdown', sizeBytes: 240),
_recorded('session.html', contentType: 'text/plain', sizeBytes: 512),
],
),
step(
stage: 'review',
sequence: 2,
visit: 2,
artifacts: [
_recorded('notes.md', contentType: 'text/markdown', sizeBytes: 64),
_recorded('input.md', contentType: 'text/markdown', sizeBytes: 130),
_recorded('memory.md', contentType: 'text/markdown', sizeBytes: 256),
],
),
];
Future<void> _pump(
WidgetTester tester,
_Platform platform, {
List<JsonMap>? steps,
ArtifactFetch? fetch,
ArtifactExternalOpen? openExternal,
}) async {
tester.view.physicalSize = const Size(900, 2600);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.resetPhysicalSize);
addTearDown(tester.view.resetDevicePixelRatio);
final page = ArtifactGalleryPage(
steps: steps ?? _steps(),
configuredEndpoint: _endpoint,
openExternal: openExternal ?? (_) async => true,
fetch:
fetch ??
(_) async => ArtifactFetchResult(
status: 200,
bytes: Uint8List.fromList('# Recorded input'.codeUnits),
),
markdownBuilder: (context, value) => Text(value),
);
await tester.pumpWidget(
platform == _Platform.material
? MaterialApp(home: page)
: CupertinoApp(home: page),
);
await tester.pumpAndSettle();
}
Finder _dialog(_Platform platform, String text) => find.descendant(
of: find.byType(
platform == _Platform.material ? AlertDialog : CupertinoAlertDialog,
),
matching: find.text(text),
);
void main() {
for (final platform in _Platform.values) {
testWidgets('${platform.name}: every recorded document is an entry', (
tester,
) async {
await _pump(tester, platform);
expect(find.text('Turn documents'), findsNWidgets(2));
expect(find.text('input.md'), findsNWidgets(2));
expect(find.text('output.md'), findsNWidgets(2));
expect(find.text('session.html'), findsNWidgets(2));
expect(find.text('memory.md'), findsNWidgets(2));
expect(find.text('text/markdown · 120\u00a0B'), findsOneWidget);
expect(find.text('text/plain · 512\u00a0B'), findsOneWidget);
});
testWidgets('${platform.name}: missing documents show exact wording', (
tester,
) async {
await _pump(tester, platform);
expect(find.text('No memory recorded for this visit.'), findsOneWidget);
expect(find.text('No output recorded.'), findsOneWidget);
expect(find.text('This visit has no harness session.'), findsOneWidget);
expect(find.text('No input recorded.'), findsNothing);
});
testWidgets('${platform.name}: markdown opens the existing renderer', (
tester,
) async {
await _pump(tester, platform);
await tester.tap(find.text('input.md').first);
await tester.pumpAndSettle();
expect(find.byType(ArtifactViewerPage), findsOneWidget);
expect(find.text('# Recorded input'), findsOneWidget);
expect(find.text('review · visit 1'), findsOneWidget);
expect(find.text('text/markdown · 120\u00a0B'), findsOneWidget);
});
testWidgets(
'${platform.name}: absent rows are informational, not controls',
(tester) async {
await _pump(tester, platform);
final absence = find.text('No output recorded.');
expect(absence, findsOneWidget);
if (platform == _Platform.material) {
// Not disabled: the absence line is content, not a skipped action, and
// is painted with the normal secondary label colour.
final tile = tester.widget<ListTile>(
find.ancestor(of: absence, matching: find.byType(ListTile)),
);
expect(tile.enabled, isTrue);
expect(tile.onTap, isNull);
expect(
tester.widget<Text>(absence).style?.color,
Theme.of(tester.element(absence)).colorScheme.onSurfaceVariant,
);
} else {
expect(
find.ancestor(of: absence, matching: find.byType(CupertinoButton)),
findsNothing,
);
}
await tester.tap(absence);
await tester.pumpAndSettle();
expect(find.byType(ArtifactViewerPage), findsNothing);
expect(find.byType(AlertDialog), findsNothing);
expect(find.byType(CupertinoAlertDialog), findsNothing);
},
);
testWidgets('${platform.name}: session.html stays external-only', (
tester,
) async {
final opened = <Uri>[];
await _pump(
tester,
platform,
openExternal: (uri) async {
opened.add(uri);
return true;
},
fetch: (_) async => throw StateError('x'),
);
await tester.tap(find.text('session.html').first);
await tester.pumpAndSettle();
expect(find.byType(ArtifactViewerPage), findsNothing);
expect(_dialog(platform, 'session.html'), findsOneWidget);
expect(_dialog(platform, 'text/plain · 512\u00a0B'), findsOneWidget);
await tester.tap(_dialog(platform, 'Open'));
await tester.pumpAndSettle();
expect(find.byType(ArtifactViewerPage), findsNothing);
expect(opened, [
Uri.parse('http://127.0.0.1:8081/artifacts/1/1/session.html'),
]);
});
}
}
@@ -515,4 +515,42 @@ void main() {
// The viewer and its markdown add no Material control to a Cupertino host.
expect(find.byType(Material), findsNothing);
});
testWidgets('Material paging stays inside 320px at 2x text', (tester) async {
tester.view.physicalSize = const Size(640, 1200);
tester.view.devicePixelRatio = 2;
tester.platformDispatcher.textScaleFactorTestValue = 2;
addTearDown(tester.view.resetPhysicalSize);
addTearDown(tester.view.resetDevicePixelRatio);
addTearDown(tester.platformDispatcher.clearTextScaleFactorTestValue);
final first = recordedArtifact(
'a.png',
url: '/artifacts/1/1/a.png',
contentType: 'image/png',
);
final second = recordedArtifact(
'b.png',
url: '/artifacts/1/2/b.png',
contentType: 'image/png',
);
final groups = [
_group([first], visit: 1),
_group([second], visit: 2),
];
await _pumpViewer(
tester,
groups: groups,
selected: artifactVisitIdentity(groups[0], first),
);
expect(tester.takeException(), isNull);
// Both labelled controls are whole: a clipped Row overflowed the viewport.
for (final label in ['Previous artifact', 'Next artifact']) {
final rect = tester.getRect(find.text(label));
expect(rect.left, greaterThanOrEqualTo(0), reason: label);
expect(rect.right, lessThanOrEqualTo(320), reason: label);
expect(rect.width, greaterThan(0), reason: label);
}
});
}