Files
pipelines/app/test/features/pipelines/pipeline_graph_tab_test.dart
T
alan 53a8f668ca feat(app): start a pipeline from the detail view
Native Run action opens the web's prompt/workspace/notify dialog, sends the exact run_pipeline body against the pinned resolved version with one request key per confirmed attempt, keeps refusals in the dialog, reconciles a lost reply by key, and opens only the server-named run through the existing run route with one fresh Runs list read.

Adds a shared failure-reason helper so operators never see Dart runtime prefixes, and records the slice boundary in notes/P3-run.md.
2026-10-22 02:07:49 +01:00

299 lines
10 KiB
Dart

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/widgets/definition_graph_view.dart';
import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart';
import 'package:pipelines_app/features/graph/widgets/stage_definition_view.dart';
import 'package:pipelines_app/features/pipelines/screen.dart';
import 'package:pipelines_app/features/pipelines/widgets/pipeline_graph_tab.dart';
import 'fixtures.dart';
import 'test_helpers.dart';
Finder _node(String key) => find.byWidgetPredicate(
(widget) => widget is GraphStageNode && widget.node.key == key,
);
/// Taps a node, panning the stock canvas first when the node starts offscreen.
Future<void> _tapNode(WidgetTester tester, String key) async {
final viewport = tester.getRect(find.byType(InteractiveViewer));
final node = tester.getRect(_node(key));
if (!viewport.contains(node.center)) {
await tester.drag(
find.byType(InteractiveViewer),
viewport.center - node.center,
);
await tester.pumpAndSettle();
}
await tester.tap(_node(key));
await tester.pump();
}
Future<void> _pumpScreen(
WidgetTester tester,
Size size, {
double scale = 1,
FakeGateway? gateway,
int syncToken = 0,
}) async {
tester.view.physicalSize = size;
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(
MaterialApp(
builder: (context, child) => MediaQuery(
data: MediaQuery.of(
context,
).copyWith(textScaler: TextScaler.linear(scale)),
child: child!,
),
home: PipelinesScreen(
gateway: gateway ?? gatewayFor(PipelineFixture()),
syncToken: syncToken,
),
),
);
await tester.pumpAndSettle();
}
Future<void> _openGraphTab(WidgetTester tester, int pipelineId) async {
await tester.tap(find.byKey(Key('pipeline-row-$pipelineId')));
await tester.pumpAndSettle();
// The detail header scrolls when content-driven title/tab height needs it
// (the header gained the native Run action), so reach the tab like an
// operator would instead of requiring it to fit without scrolling.
await tester.ensureVisible(find.text('Graph'));
await tester.pumpAndSettle();
await tester.tap(find.text('Graph'));
await tester.pump();
await tester.pump();
}
void main() {
test('detail keeps the pinned graph verbatim without touching source', () {
final graph = reviewGraph();
final detail = PipelineDetail.fromJson(
pipelineDetail(
id: 9,
name: 'Pinned review',
version: 4,
latestVersion: 5,
source: 'exact: authored source',
stages: 2,
versions: [versionSummary(4, stages: 2)],
graph: graph,
shape: graph,
),
);
expect(detail.graph, graph);
expect(detail.shape, graph);
expect(detail.graph!['settings'], {'schedules': <dynamic>[]});
expect((detail.graph!['stages'] as List<dynamic>).first['future_field'], {
'kept': true,
});
expect(detail.source, 'exact: authored source');
expect(detail.versions.single.version, 4);
expect(detail.resolvedVersion, 4);
});
test('a reply without a graph keeps null instead of inventing one', () {
final detail = PipelineDetail.fromJson(
pipelineDetail(id: 2, name: 'Beta deploy', version: 1, latestVersion: 1),
);
expect(detail.graph, isNull);
expect(detail.shape, isNull);
});
// The note must never take the canvas away: a short window (390x600), a short
// wide split pane (1100x400) and a large accessibility text scale (3x) all
// used to overflow the tab and lay the canvas out at zero height.
for (final (size, scale) in <(Size, double)>[
(const Size(390, 844), 2),
(const Size(390, 600), 2),
(const Size(1100, 400), 2),
(const Size(1100, 900), 3),
]) {
testWidgets('graph tab keeps a usable canvas at '
'${size.width.toInt()}x${size.height.toInt()} @${scale}x', (
tester,
) async {
await _pumpScreen(tester, size, scale: scale);
await _openGraphTab(tester, 1);
expect(tester.takeException(), isNull);
expect(find.text(pipelineGraphNote), findsOneWidget);
expect(find.byType(DefinitionGraphView), findsOneWidget);
final tab = tester.getSize(find.byType(PipelineGraphTab));
final note = tester.getSize(find.byKey(const Key('pipeline-graph-note')));
final canvas = tester.getSize(find.byType(DefinitionGraphView));
expect(canvas.height, greaterThan(0));
expect(
note.height,
lessThanOrEqualTo(tab.height * 0.5 + 1),
reason: 'the guidance note may never take more than half the tab',
);
expect(
canvas.height,
greaterThanOrEqualTo(tab.height * 0.5 - 1),
reason: 'the canvas keeps at least half of the tab slot',
);
expect(canvas.height, lessThan(tab.height));
});
}
testWidgets('an empty definition keeps its message in a short slot', (
tester,
) async {
final detail = PipelineDetail.fromJson(
pipelineDetail(
id: 4,
name: 'Empty definition',
version: 1,
latestVersion: 1,
graph: {'name': 'Empty definition', 'stages': <dynamic>[]},
),
);
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: Center(
child: SizedBox(
width: 390,
height: 200,
child: PipelineGraphTab(
detail: detail,
selectedStage: null,
onSelected: (_) {},
),
),
),
),
),
);
await tester.pumpAndSettle();
expect(find.text(definitionGraphEmpty), findsOneWidget);
expect(find.byType(GraphStageNode), findsNothing);
expect(tester.takeException(), isNull);
});
testWidgets('selecting a node opens its exact pinned definition', (
tester,
) async {
await _pumpScreen(tester, const Size(1100, 900));
await _openGraphTab(tester, 1);
await _tapNode(tester, 'review');
await tester.pumpAndSettle();
final stagePane = tester.widget<StageDefinitionView>(
find.byType(StageDefinitionView),
);
expect(stagePane.stageKey, 'review');
expect(stagePane.pipelineId, 1);
expect(stagePane.pipelineName, 'Alpha review');
expect(stagePane.version, 2);
expect(stagePane.graph, reviewGraph());
expect(find.text('review definition'), findsOneWidget);
expect(find.text('Alpha review · v2'), findsOneWidget);
await tester.pageBack();
await tester.pumpAndSettle();
expect(find.byType(StageDefinitionView), findsNothing);
expect(tester.widget<GraphStageNode>(_node('review')).selected, isTrue);
// The selection belongs to the panel, so an in-place tab round trip keeps
// the same node marked (the web keeps its graph selection across tabs).
await tester.tap(find.text('Summary'));
await tester.pumpAndSettle();
await tester.tap(find.text('Graph'));
await tester.pump();
await tester.pump();
expect(tester.widget<GraphStageNode>(_node('review')).selected, isTrue);
// Terminals are definition targets too: they open the same pane with the
// pinned identity, not a visit.
await _tapNode(tester, '#success');
await tester.pumpAndSettle();
final terminalPane = tester.widget<StageDefinitionView>(
find.byType(StageDefinitionView),
);
expect(terminalPane.stageKey, '#success');
expect(terminalPane.pipelineId, 1);
expect(terminalPane.version, 2);
expect(find.text('Success definition'), findsOneWidget);
await tester.pageBack();
await tester.pumpAndSettle();
expect(tester.takeException(), isNull);
// The selection belongs to the pinned definition: changing version must not
// carry a same-named node's mark into the other version.
await tester.tap(find.text('Summary'));
await tester.pumpAndSettle();
await tester.ensureVisible(find.byKey(const Key('pipeline-version-1')));
await tester.pumpAndSettle();
await tester.tap(find.byKey(const Key('pipeline-version-1')));
await tester.pumpAndSettle();
expect(find.text('Viewing v1 (latest v2).'), findsOneWidget);
await tester.tap(find.text('Graph'));
await tester.pump();
await tester.pump();
expect(tester.widget<GraphStageNode>(_node('review')).selected, isFalse);
expect(
tester
.widget<DefinitionGraphView>(find.byType(DefinitionGraphView))
.graph,
reviewGraphV1(),
);
});
testWidgets('a reconnect that replaces the detail clears the old mark', (
tester,
) async {
var latest = 2;
final fixture = PipelineFixture();
final gateway = FakeGateway(
(type, fields) => switch (type) {
'list_pipelines' => pipelineListReply(fixture.summaries),
'list_runs' => runListReply(fixture.runs),
'get_pipeline' => pipelineDetailReply(
fixture.detailFor(fields['pipeline_id'] as int, latest)!,
),
_ => errorReply('unexpected $type'),
},
);
await _pumpScreen(tester, const Size(1100, 900), gateway: gateway);
await _openGraphTab(tester, 1);
await _tapNode(tester, 'review');
await tester.pumpAndSettle();
await tester.pageBack();
await tester.pumpAndSettle();
expect(tester.widget<GraphStageNode>(_node('review')).selected, isTrue);
// A reconnect reloads the selected detail in place (it is not nulled), so
// this is the path the old tab-state guard existed for. The newer pin must
// not inherit the previous version's mark.
latest = 3;
await _pumpScreen(
tester,
const Size(1100, 900),
gateway: gateway,
syncToken: 1,
);
expect(find.byType(GraphStageNode), findsWidgets);
expect(tester.widget<GraphStageNode>(_node('review')).selected, isFalse);
expect(tester.takeException(), isNull);
});
testWidgets('a missing definition graph is stated, never drawn', (
tester,
) async {
await _pumpScreen(tester, const Size(1100, 900));
await _openGraphTab(tester, 2);
expect(find.text(pipelineGraphMissing), findsOneWidget);
expect(find.byType(DefinitionGraphView), findsNothing);
expect(find.byType(GraphStageNode), findsNothing);
});
}