feat(app): graph pan, zoom and expanded view

This commit is contained in:
2026-10-22 02:05:20 +01:00
parent d5f24b8259
commit cc7eba59b6
19 changed files with 2622 additions and 200 deletions
@@ -0,0 +1,213 @@
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/graph/viewport/graph_expanded_view.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_math.dart';
import 'package:pipelines_app/features/graph/widgets/definition_graph_view.dart';
import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart';
import '../domain/graph_fixtures.dart';
Widget _materialHost({
required JsonMap graph,
required String? selected,
required ValueChanged<String> onSelected,
}) => MaterialApp(
home: Scaffold(
body: DefinitionGraphView(
graph: graph,
selectedStage: selected,
onSelected: onSelected,
),
),
);
Finder _node(String key) => find.byWidgetPredicate(
(widget) => widget is GraphStageNode && widget.node.key == key,
);
Finder _inExpanded(Finder finder) =>
find.descendant(of: find.byType(GraphExpandedView), matching: finder);
Future<void> _settle(WidgetTester tester) async {
await tester.pump();
await tester.pump();
await tester.pump();
}
TransformationController _inlineTransform(WidgetTester tester) => tester
.widget<InteractiveViewer>(find.byType(InteractiveViewer))
.transformationController!;
void main() {
testWidgets(
'expanded fits the larger canvas and returns to the inline state',
(tester) async {
tester.view.physicalSize = const Size(900, 700);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
final picked = <String>[];
await tester.pumpWidget(
_materialHost(
graph: linearGraph(),
selected: 'build',
onSelected: picked.add,
),
);
await _settle(tester);
final inline = _inlineTransform(tester);
final inlineMatrix = Matrix4.copy(inline.value);
final inlineRect = tester.getRect(_node('build'));
await tester.tap(find.byKey(const Key('graph-expand')));
await tester.pumpAndSettle();
expect(find.byType(GraphExpandedView), findsOneWidget);
expect(find.text(definitionGraphExpandedTitle), findsOneWidget);
final expanded = _inExpanded(find.byType(InteractiveViewer));
expect(expanded, findsOneWidget);
final expandedController = tester
.widget<InteractiveViewer>(expanded)
.transformationController!;
final expandedView = tester.widget<GraphExpandedView>(
find.byType(GraphExpandedView),
);
final canvas = tester.getRect(
_inExpanded(find.byKey(const Key('graph-viewport'))),
);
// The web re-fits when its panel expands: the larger canvas fits the
// whole graph instead of keeping the small inline scale.
expect(
expandedController.value.getMaxScaleOnAxis(),
closeTo(graphFitScale(canvas.size, expandedView.contentSize), 1e-9),
);
expect(
canvas.contains(tester.getCenter(_inExpanded(_node('build')))),
isTrue,
);
expect(
tester.widget<GraphStageNode>(_inExpanded(_node('build'))).selected,
isTrue,
);
// A tap in the larger canvas follows the same transform and updates the
// presentation's own selection.
await tester.tap(_inExpanded(_node('plan')));
await tester.pump();
expect(picked, ['plan']);
expect(
tester.widget<GraphStageNode>(_inExpanded(_node('plan'))).selected,
isTrue,
);
await tester.tap(find.byKey(const Key('graph-expanded-close')));
await tester.pumpAndSettle();
expect(find.byType(GraphExpandedView), findsNothing);
// The inline canvas was never changed: same selection, same place.
expect(tester.widget<GraphStageNode>(_node('build')).selected, isTrue);
expect(tester.getRect(_node('build')), inlineRect);
expect(inline.value.storage, orderedEquals(inlineMatrix.storage));
},
);
testWidgets('a rotation re-clamps the expanded transform into the new box', (
tester,
) async {
tester.view.physicalSize = const Size(900, 700);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
await tester.pumpWidget(
_materialHost(
graph: linearGraph(),
selected: 'build',
onSelected: (_) {},
),
);
await _settle(tester);
await tester.tap(find.byKey(const Key('graph-expand')));
await tester.pumpAndSettle();
final expanded = _inExpanded(find.byType(InteractiveViewer));
final controller = tester
.widget<InteractiveViewer>(expanded)
.transformationController!;
final canvas = find.descendant(
of: find.byType(GraphExpandedView),
matching: find.byKey(const Key('graph-viewport')),
);
// Pan far enough that the wide canvas' clamp is the only limit.
await tester.drag(canvas, const Offset(500, 0));
await tester.pumpAndSettle();
final wide = tester.getRect(canvas);
final panned = controller.value.getTranslation().x;
expect(panned, lessThanOrEqualTo(wide.width - graphMinVisible + 0.5));
// Rotating to a narrow box must keep the graph inside it, not leave the
// reader's old place hanging outside until Fit is pressed.
tester.view.physicalSize = const Size(320, 700);
await tester.pumpAndSettle();
await _settle(tester);
final narrow = tester.getRect(canvas);
expect(narrow.width, lessThan(wide.width));
final clamped = controller.value.getTranslation().x;
expect(
clamped,
lessThanOrEqualTo(narrow.width - graphMinVisible + 0.5),
reason: 'a resize must re-clamp the existing transform',
);
expect(clamped, lessThan(panned));
});
testWidgets('320px at 2x opens and closes on the dark Cupertino host', (
tester,
) async {
tester.view.physicalSize = const Size(320, 700);
tester.view.devicePixelRatio = 1;
addTearDown(tester.view.reset);
final picked = <String>[];
await tester.pumpWidget(
CupertinoApp(
theme: const CupertinoThemeData(brightness: Brightness.dark),
home: CupertinoPageScaffold(
child: Builder(
builder: (context) => MediaQuery(
data: MediaQuery.of(
context,
).copyWith(textScaler: const TextScaler.linear(2)),
child: DefinitionGraphView(
graph: linearGraph(),
selectedStage: 'build',
onSelected: picked.add,
),
),
),
),
),
);
await _settle(tester);
final inline = _inlineTransform(tester);
final inlineMatrix = Matrix4.copy(inline.value);
await tester.tap(find.byKey(const Key('graph-expand')));
await tester.pumpAndSettle();
expect(find.byType(GraphExpandedView), findsOneWidget);
expect(_inExpanded(find.text(graphExpandedClose)), findsOneWidget);
expect(
tester.widget<GraphStageNode>(_inExpanded(_node('build'))).selected,
isTrue,
);
expect(tester.takeException(), isNull);
await tester.tap(find.byKey(const Key('graph-expanded-close')));
await tester.pumpAndSettle();
expect(find.byType(GraphExpandedView), findsNothing);
expect(tester.widget<GraphStageNode>(_node('build')).selected, isTrue);
expect(inline.value.storage, orderedEquals(inlineMatrix.storage));
expect(picked, isEmpty);
expect(tester.takeException(), isNull);
});
}
@@ -0,0 +1,99 @@
import 'package:flutter/rendering.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_controller.dart';
import 'graph_viewport_fixtures.dart';
void main() {
testWidgets('Fit and Expand stay labelled, activatable buttons on both hosts', (
tester,
) async {
for (final cupertino in [false, true]) {
final host = cupertino ? 'cupertino' : 'material';
final controller = GraphViewportController();
addTearDown(controller.dispose);
var expands = 0;
await tester.pumpWidget(
viewportHost(
controller: controller,
child: viewportTargets([]),
cupertino: cupertino,
onExpand: () => expands += 1,
),
);
await settleViewport(tester);
final fitted = controller.snapshot;
for (final control in viewportControls().entries) {
final node = tester.getSemantics(find.byKey(control.key));
final data = node.getSemanticsData();
expect(
data.label,
control.value,
reason: '$host ${control.key} must have the web name',
);
expect(
data.flagsCollection.isButton,
isTrue,
reason: '$host ${control.key} must be announced as a button',
);
// A labelled button with no action is unusable with VoiceOver/TalkBack;
// this is the regression the excluded-button wrapper introduced.
expect(
data.hasAction(SemanticsAction.tap),
isTrue,
reason: '$host ${control.key} must expose a tap action',
);
}
// The exposed action must run the real callback, not just be announced.
await pinchViewport(tester, const Offset(200, 150), 2);
await tester.pumpAndSettle();
expect(controller.snapshot, isNot(fitted));
performViewportTap(tester, find.byKey(const Key('graph-fit')));
await tester.pump();
expect(controller.scale, closeTo(fitted.scale, 1e-9));
performViewportTap(tester, find.byKey(const Key('graph-expand')));
await tester.pump();
expect(expands, 1, reason: '$host Expand must activate');
}
});
testWidgets('320px at 2x keeps native controls and gestures on both hosts', (
tester,
) async {
for (final cupertino in [false, true]) {
final controller = GraphViewportController();
addTearDown(controller.dispose);
await tester.pumpWidget(
viewportHost(
controller: controller,
child: viewportTargets([]),
cupertino: cupertino,
dark: cupertino,
textScale: 2,
viewport: const Size(320, 300),
onExpand: () {},
),
);
await settleViewport(tester);
expect(find.byKey(const Key('graph-fit')), findsOneWidget);
expect(find.byKey(const Key('graph-expand')), findsOneWidget);
expect(tester.takeException(), isNull);
final before = controller.offset;
await dragViewport(
tester,
find.byKey(const Key('graph-viewport')),
const Offset(-30, -10),
);
expect(controller.offset, isNot(before));
await pinchViewport(tester, const Offset(160, 150), 2);
await tester.pumpAndSettle();
expect(controller.scale, greaterThan(0.3));
expect(tester.takeException(), isNull);
}
});
}
@@ -0,0 +1,167 @@
import 'package:flutter/cupertino.dart';
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_controller.dart';
/// Shared fixture for the graph viewport widget tests.
///
/// One 1200x900 graph in a 400x300 box unless a test asks for another size.
const Size viewportContent = Size(1200, 900);
const Size defaultViewportSize = Size(400, 300);
/// Two native tap targets at known graph coordinates; a tap reports its key so
/// hit-testing can be checked against the visible transform.
Widget viewportTargets(List<String> picked) => Stack(
clipBehavior: Clip.none,
children: [
Positioned(
left: 60,
top: 60,
width: 120,
height: 60,
child: GestureDetector(
key: const Key('target-a'),
behavior: HitTestBehavior.opaque,
onTap: () => picked.add('a'),
child: const ColoredBox(color: Color(0xFF3366CC)),
),
),
Positioned(
left: 900,
top: 700,
width: 160,
height: 80,
child: GestureDetector(
key: const Key('target-b'),
behavior: HitTestBehavior.opaque,
onTap: () => picked.add('b'),
child: const ColoredBox(color: Color(0xFFCC6633)),
),
),
],
);
Widget viewportHost({
required GraphViewportController controller,
required Widget child,
VoidCallback? onExpand,
bool cupertino = false,
bool dark = false,
double textScale = 1,
Size viewport = defaultViewportSize,
}) {
final graph = MediaQuery(
data: MediaQueryData(textScaler: TextScaler.linear(textScale)),
child: SizedBox.fromSize(
size: viewport,
child: GraphViewport(
controller: controller,
contentSize: viewportContent,
onExpand: onExpand,
child: child,
),
),
);
if (cupertino) {
return CupertinoApp(
theme: CupertinoThemeData(
brightness: dark ? Brightness.dark : Brightness.light,
),
home: CupertinoPageScaffold(child: Center(child: graph)),
);
}
return MaterialApp(
theme: dark ? ThemeData.dark() : ThemeData.light(),
home: Scaffold(body: Center(child: graph)),
);
}
Future<void> settleViewport(WidgetTester tester) async {
await tester.pump();
await tester.pump();
await tester.pump();
}
/// Two-pointer pinch around [center]; [factor] > 1 zooms in.
Future<void> pinchViewport(
WidgetTester tester,
Offset center,
double factor, {
double half = 20,
}) async {
final origin = viewportGlobal(tester, center);
final left = await tester.startGesture(origin - Offset(half, 0));
final right = await tester.startGesture(origin + Offset(half, 0));
await tester.pump();
const steps = 8;
final end = half * factor;
for (var step = 1; step <= steps; step += 1) {
final spread = half + (end - half) * step / steps;
await left.moveTo(origin - Offset(spread, 0));
await right.moveTo(origin + Offset(spread, 0));
await tester.pump();
}
await left.up();
await right.up();
await tester.pump();
}
Offset viewportScreenOf(
GraphViewportController controller,
Offset graphPoint,
) => MatrixUtils.transformPoint(controller.transformation.value, graphPoint);
/// Viewport-local coordinates to the test screen, where gestures are dispatched.
Offset viewportGlobal(WidgetTester tester, Offset local) =>
tester.getTopLeft(find.byKey(const Key('graph-viewport'))) + local;
/// Starts a drag and moves past the pan slop, so the canvas owns the gesture.
///
/// The viewer only pans movement after it accepts the gesture, so tests record
/// their reference offset after this warm-up rather than at pointer down.
Future<TestGesture> startViewportDrag(
WidgetTester tester,
Finder finder, {
Offset warmUp = const Offset(-10, -10),
}) async {
final gesture = await tester.startGesture(tester.getCenter(finder));
for (var step = 0; step < 4; step += 1) {
await gesture.moveBy(warmUp);
await tester.pump();
}
return gesture;
}
Future<void> dragViewport(
WidgetTester tester,
Finder finder,
Offset delta, {
Offset warmUp = const Offset(-10, -10),
}) async {
final gesture = await startViewportDrag(tester, finder, warmUp: warmUp);
for (var step = 0; step < 4; step += 1) {
await gesture.moveBy(delta / 4);
await tester.pump();
}
await gesture.up();
await tester.pumpAndSettle();
}
/// Activates a control the way a screen reader does: through its semantics
/// action, not pointer input.
void performViewportTap(WidgetTester tester, Finder finder) {
final node = tester.getSemantics(finder);
tester.binding.renderViews.first.owner!.semanticsOwner!.performAction(
node.id,
SemanticsAction.tap,
);
}
/// The controls' accessible names, in the order they are shown.
Map<Key, String> viewportControls() => <Key, String>{
const Key('graph-fit'): graphFitLabel,
const Key('graph-expand'): graphExpandLabel,
};
@@ -0,0 +1,134 @@
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_controller.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_math.dart';
void main() {
test('fit keeps the padding and never upscales a small graph', () {
final scale = graphFitScale(
const Size(400, 300),
const Size(1000, 800),
padding: 20,
);
// 360/1000 and 260/800 both fit; the smaller axis wins.
expect(scale, closeTo(0.325, 1e-9));
expect(graphFitScale(const Size(400, 300), const Size(100, 80)), 1);
});
test('fit clamps to the graph scale bounds', () {
expect(
graphFitScale(const Size(400, 300), const Size(10000, 10000)),
graphMinScale,
);
expect(
graphFitScale(const Size(400, 300), const Size(1000, 800), minScale: 0.9),
0.9,
);
});
test('degenerate sizes never divide by zero', () {
expect(graphFitScale(Size.zero, const Size(100, 100)), 1);
expect(graphFitScale(const Size(400, 300), Size.zero), 1);
expect(
graphFitScale(const Size(400, 300), const Size(100, 100), padding: 200),
1,
);
});
test('pan clamp keeps part of the scaled graph visible', () {
const viewport = Size(400, 300);
const scaled = Size(800, 600);
expect(
graphClampOffset(const Offset(5000, 5000), scaled, viewport),
const Offset(400 - graphMinVisible, 300 - graphMinVisible),
);
expect(
graphClampOffset(const Offset(-5000, -5000), scaled, viewport),
Offset(graphMinVisible - 800, graphMinVisible - 600),
);
// Inside the bounds the offset is untouched.
expect(
graphClampOffset(const Offset(-100, -50), scaled, viewport),
const Offset(-100, -50),
);
});
test('clamp leaves degenerate content and empty ranges alone', () {
expect(
graphClampOffset(const Offset(12, 34), Size.zero, const Size(400, 300)),
const Offset(12, 34),
);
// The viewport is narrower than twice the minimum visible part: the range
// is empty, so the input survives rather than being pinned to a bad value.
expect(
graphClampOffset(
const Offset(500, 500),
const Size(1, 1),
const Size(40, 40),
),
const Offset(500, 500),
);
});
test('the transform draws graph points at offset + point * scale', () {
final matrix = graphViewportMatrix(const Offset(30, 20), 0.5);
expect(
MatrixUtils.transformPoint(matrix, const Offset(100, 80)),
const Offset(80, 60),
);
expect(matrix.getMaxScaleOnAxis(), 0.5);
});
test('controller fits, centers and round-trips a snapshot', () {
final controller = GraphViewportController();
addTearDown(controller.dispose);
controller.attach(
viewport: const Size(400, 300),
content: const Size(1000, 800),
);
final fitted = controller.snapshot;
expect(fitted.scale, closeTo(0.315, 1e-9));
expect(fitted.offset.dx, greaterThan(0));
expect(fitted.offset.dy, greaterThan(0));
expect(
fitted.offset,
graphCenteredOffset(
Size(1000 * fitted.scale, 800 * fitted.scale),
const Size(400, 300),
),
);
controller.applySnapshot(
const GraphViewportSnapshot(scale: 2, offset: Offset(-100, -80)),
);
expect(
controller.snapshot,
const GraphViewportSnapshot(scale: 2, offset: Offset(-100, -80)),
);
// A resize after the reader adjusted keeps their scale, only clamping the
// offset into the new bounds.
controller.attach(
viewport: const Size(200, 200),
content: const Size(1000, 800),
);
expect(controller.scale, 2);
});
test('controller fit clamps a graph that cannot fit at the minimum', () {
final controller = GraphViewportController();
addTearDown(controller.dispose);
controller.attach(
viewport: const Size(400, 300),
content: const Size(10000, 10000),
);
expect(controller.scale, graphMinScale);
final scaled = 10000 * graphMinScale;
expect(
controller.offset.dx,
greaterThanOrEqualTo(graphMinVisible - scaled),
);
expect(controller.offset.dx, lessThanOrEqualTo(400 - graphMinVisible));
});
}
@@ -0,0 +1,238 @@
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_controller.dart';
import 'package:pipelines_app/features/graph/viewport/graph_viewport_math.dart';
import 'graph_viewport_fixtures.dart';
void main() {
testWidgets('drag pans the canvas and the pan stays bounded', (tester) async {
final controller = GraphViewportController();
addTearDown(controller.dispose);
await tester.pumpWidget(
viewportHost(controller: controller, child: viewportTargets([])),
);
await settleViewport(tester);
expect(controller.scale, lessThan(1));
final finder = find.byKey(const Key('graph-viewport'));
final gesture = await startViewportDrag(tester, finder);
final before = controller.offset;
for (var step = 0; step < 4; step += 1) {
await gesture.moveBy(const Offset(-10, -5));
await tester.pump();
}
await gesture.up();
await tester.pumpAndSettle();
expect(controller.offset.dx, closeTo(before.dx - 40, 1));
expect(controller.offset.dy, closeTo(before.dy - 20, 1));
// A huge drag can never leave an empty canvas: at least the minimum part
// of the scaled graph stays inside the viewport.
final out = await startViewportDrag(tester, finder);
await out.moveBy(const Offset(5000, 5000));
await tester.pump();
await out.up();
await tester.pumpAndSettle();
expect(
controller.offset.dx,
lessThanOrEqualTo(defaultViewportSize.width - graphMinVisible + 0.01),
);
expect(
controller.offset.dy,
lessThanOrEqualTo(defaultViewportSize.height - graphMinVisible + 0.01),
);
final back = await startViewportDrag(tester, finder);
await back.moveBy(const Offset(-10000, -10000));
await tester.pump();
await back.up();
await tester.pumpAndSettle();
expect(
controller.offset.dx,
greaterThanOrEqualTo(
graphMinVisible - viewportContent.width * controller.scale - 0.01,
),
);
});
testWidgets('pinch zoom clamps at the graph scale bounds', (tester) async {
final controller = GraphViewportController();
addTearDown(controller.dispose);
await tester.pumpWidget(
viewportHost(controller: controller, child: viewportTargets([])),
);
await settleViewport(tester);
expect(controller.scale, lessThan(1));
await pinchViewport(tester, const Offset(200, 150), 10);
await tester.pumpAndSettle();
expect(controller.scale, graphMaxScale);
await pinchViewport(tester, const Offset(200, 150), 0.01);
await tester.pumpAndSettle();
expect(controller.scale, graphMinScale);
});
testWidgets('zoom keeps the graph point under the moving focal point', (
tester,
) async {
final controller = GraphViewportController();
addTearDown(controller.dispose);
await tester.pumpWidget(
viewportHost(controller: controller, child: viewportTargets([])),
);
await settleViewport(tester);
const focal = Offset(150, 120);
final before = controller.transformation.toScene(focal);
await pinchViewport(tester, focal, 1.6);
await tester.pumpAndSettle();
final after = controller.transformation.toScene(focal);
// A gesture is not pixel-exact: the focal point keeps its graph point
// within a few graph pixels while the transform scales.
expect(after.dx, closeTo(before.dx, 4));
expect(after.dy, closeTo(before.dy, 4));
expect(controller.scale, greaterThan(0.3));
});
testWidgets('the first painted frame is already fitted', (tester) async {
final controller = GraphViewportController();
addTearDown(controller.dispose);
// No extra pump: the fit must land during the first layout, not one frame
// later over an identity transform.
await tester.pumpWidget(
viewportHost(controller: controller, child: viewportTargets([])),
);
expect(
controller.scale,
closeTo(graphFitScale(defaultViewportSize, viewportContent), 1e-9),
);
expect(tester.takeException(), isNull);
});
testWidgets('the fit control restores the fitted scale and offset', (
tester,
) async {
final controller = GraphViewportController();
addTearDown(controller.dispose);
await tester.pumpWidget(
viewportHost(controller: controller, child: viewportTargets([])),
);
await settleViewport(tester);
final fitted = controller.snapshot;
await pinchViewport(tester, const Offset(200, 150), 2);
await dragViewport(
tester,
find.byKey(const Key('graph-viewport')),
const Offset(-30, -10),
);
expect(controller.snapshot, isNot(fitted));
await tester.tap(find.byKey(const Key('graph-fit')));
await tester.pump();
expect(controller.scale, closeTo(fitted.scale, 1e-9));
expect(controller.offset.dx, closeTo(fitted.offset.dx, 1e-9));
expect(controller.offset.dy, closeTo(fitted.offset.dy, 1e-9));
});
testWidgets('a tap selects the node visually under the pointer', (
tester,
) async {
final picked = <String>[];
final controller = GraphViewportController();
addTearDown(controller.dispose);
await tester.pumpWidget(
viewportHost(controller: controller, child: viewportTargets(picked)),
);
await settleViewport(tester);
// Bring target b to the middle, then zoom in around it. Its graph point
// stays under the focal point while the transform scales.
const targetCenter = Offset(980, 740);
final finder = find.byKey(const Key('graph-viewport'));
final gesture = await startViewportDrag(tester, finder);
final start = viewportScreenOf(controller, targetCenter);
final delta = const Offset(200, 150) - start;
for (var step = 0; step < 4; step += 1) {
await gesture.moveBy(delta / 4);
await tester.pump();
}
await gesture.up();
await tester.pumpAndSettle();
await pinchViewport(tester, const Offset(200, 150), 2.4);
await tester.pumpAndSettle();
final underPointer = viewportScreenOf(controller, targetCenter);
final viewportRect = tester.getRect(
find.byKey(const Key('graph-viewport')),
);
expect(viewportRect.contains(underPointer), isTrue);
expect(controller.scale, greaterThan(0.3));
await tester.tapAt(viewportGlobal(tester, underPointer));
await tester.pump();
expect(picked, ['b']);
});
testWidgets('an ancestor scroll view keeps scrolling outside the canvas', (
tester,
) async {
final controller = GraphViewportController();
final scroll = ScrollController();
addTearDown(controller.dispose);
addTearDown(scroll.dispose);
await tester.pumpWidget(
MaterialApp(
home: Scaffold(
body: ListView(
controller: scroll,
children: [
Container(key: const Key('scroll-header'), height: 400),
SizedBox(
height: 300,
child: GraphViewport(
controller: controller,
contentSize: viewportContent,
child: viewportTargets([]),
),
),
Container(height: 800),
],
),
),
),
);
await settleViewport(tester);
// A drag outside the canvas scrolls the ancestor and never pans the graph.
await tester.dragFrom(const Offset(400, 60), const Offset(0, -120));
await tester.pumpAndSettle();
expect(scroll.offset, greaterThan(0));
final scrolled = scroll.offset;
final graphBefore = controller.offset;
expect(controller.offset, graphBefore);
// Inside its own box the canvas consumes the drag: the graph pans and the
// list keeps its position.
await dragViewport(
tester,
find.byKey(const Key('graph-viewport')),
const Offset(-40, 0),
warmUp: const Offset(-10, 0),
);
expect(scroll.offset, scrolled);
expect(controller.offset.dx, lessThan(graphBefore.dx));
// Scrolling outside still works afterwards and leaves the graph place alone.
final panned = controller.offset;
await tester.dragFrom(const Offset(400, 60), const Offset(0, -80));
await tester.pumpAndSettle();
expect(scroll.offset, greaterThan(scrolled));
expect(controller.offset, panned);
});
}
@@ -82,6 +82,22 @@ Finder _node(String key) => find.byWidgetPredicate(
(widget) => widget is GraphStageNode && widget.node.key == key,
);
/// The graph-space extent of a placed node.
///
/// The viewport fits the measured graph into the available box, so an onstage
/// node's rectangle is its measured extent times the current scale. Dividing
/// the rectangle by that scale keeps these assertions about measurement rather
/// than about the viewport transform.
Size _measuredNodeSize(WidgetTester tester, String key) {
final scale = tester
.widget<InteractiveViewer>(find.byType(InteractiveViewer))
.transformationController!
.value
.getMaxScaleOnAxis();
final rect = _nodeRect(tester, key);
return Size(rect.width / scale, rect.height / scale);
}
Rect _nodeRect(WidgetTester tester, String key) => tester.getRect(_node(key));
Future<void> _tapNode(WidgetTester tester, String key) async {
@@ -123,11 +139,11 @@ void main() {
addTearDown(tester.view.reset);
await tester.pumpWidget(_materialHost(_longKeyGraph()));
await _settle(tester);
final wide = _nodeRect(tester, _longKey);
final wide = _measuredNodeSize(tester, _longKey);
tester.view.physicalSize = const Size(320, 700);
await tester.pump();
await _settle(tester);
final narrow = _nodeRect(tester, _longKey);
final narrow = _measuredNodeSize(tester, _longKey);
expect(narrow.width, lessThan(wide.width));
expect(narrow.width, lessThanOrEqualTo(320));
expect(narrow.height, greaterThan(wide.height));
@@ -156,6 +172,42 @@ void main() {
expect(picked, ['plan', '#success']);
});
testWidgets('a tap after zoom selects the node under the pointer', (
tester,
) async {
final picked = <String>[];
await tester.pumpWidget(
_materialHost(linearGraph(), onSelected: picked.add),
);
await _settle(tester);
final controller = tester
.widget<InteractiveViewer>(find.byType(InteractiveViewer))
.transformationController!;
final fitted = controller.value.getMaxScaleOnAxis();
// Scale about the node's own on-screen point, as a pinch there would.
final viewportRect = tester.getRect(find.byType(InteractiveViewer));
final anchor = _nodeRect(tester, 'build').center - viewportRect.topLeft;
final zoom = Matrix4.identity()
..translateByDouble(anchor.dx, anchor.dy, 0, 1)
..scaleByDouble(1.6, 1.6, 1.6, 1)
..translateByDouble(-anchor.dx, -anchor.dy, 0, 1);
controller.value = zoom * controller.value;
await tester.pump();
expect(controller.value.getMaxScaleOnAxis(), greaterThan(fitted));
// The node's on-screen rectangle already carries the transform, so this
// tap lands where the node is drawn rather than at its graph coordinate.
final build = _nodeRect(tester, 'build');
expect(
tester.getRect(find.byType(InteractiveViewer)).contains(build.center),
isTrue,
);
await tester.tapAt(build.center);
await tester.pump();
expect(picked, ['build']);
});
testWidgets('nodes use measured native sizes and never overlap', (
tester,
) async {
@@ -194,13 +246,13 @@ void main() {
final graph = linearGraph();
await tester.pumpWidget(_materialHost(graph));
await _settle(tester);
final oneX = _nodeRect(tester, 'plan');
final oneX = _measuredNodeSize(tester, 'plan');
final oneXLabel = tester.getRect(find.text('error*'));
await tester.pumpWidget(_materialHost(graph, scale: 2));
await _settle(tester);
final twoX = _nodeRect(tester, 'plan');
final twoX = _measuredNodeSize(tester, 'plan');
expect(twoX.height, greaterThan(oneX.height));
expect(twoX.width, greaterThan(oneX.width));
expect(
@@ -248,7 +300,13 @@ void main() {
);
await _settle(tester);
expect(find.byType(CupertinoButton), findsNWidgets(5));
expect(
find.descendant(
of: find.byType(GraphStageNode),
matching: find.byType(CupertinoButton),
),
findsNWidgets(5),
);
expect(find.byType(Card), findsNothing);
_expectNoOverlaps(tester);
@@ -5,6 +5,7 @@ import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/core/api_gateway.dart';
import 'package:pipelines_app/features/graph/domain/graph_protocol.dart';
import 'package:pipelines_app/features/graph/viewport/graph_expanded_view.dart';
import 'package:pipelines_app/features/graph/widgets/graph_stage_node.dart';
import 'package:pipelines_app/features/graph/widgets/run_graph_canvas.dart';
import 'package:pipelines_app/features/graph/widgets/run_graph_view.dart';
@@ -203,6 +204,24 @@ void main() {
expect(tester.takeException(), isNull);
});
testWidgets('the expanded run graph keeps the route legend', (tester) async {
await tester.pumpWidget(_materialHost(linearGraph(), _runningRun()));
await _settle(tester);
await tester.tap(find.byKey(const Key('graph-expand')));
await tester.pumpAndSettle();
final expanded = find.byType(GraphExpandedView);
expect(expanded, findsOneWidget);
for (final label in [runGraphExecuted, runGraphNotExecuted]) {
expect(
find.descendant(of: expanded, matching: find.text(label)),
findsOneWidget,
reason: 'the full-screen canvas must explain its routes: $label',
);
}
expect(tester.takeException(), isNull);
});
testWidgets('only routes the run took are executed and labelled', (
tester,
) async {
@@ -439,7 +458,13 @@ void main() {
await _settle(tester);
expect(find.byType(Card), findsNothing);
expect(find.byType(CupertinoButton), findsNWidgets(5));
expect(
find.descendant(
of: find.byType(GraphStageNode),
matching: find.byType(CupertinoButton),
),
findsNWidgets(5),
);
expect(find.text(runGraphExecuted), findsOneWidget);
expect(find.text(runGraphNotExecuted), findsOneWidget);
expect(