feat(app): graph pan, zoom and expanded view
This commit is contained in:
@@ -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(
|
||||
|
||||
Reference in New Issue
Block a user