Files
pipelines/app/test/features/graph/painting/graph_edge_layer_test.dart
T
alan 835f16c0bf feat(app): add passive routed graph edge layer
Paint the landed orthogonal EdgeRoutes on a caller-sized canvas: one polyline
per route, a filled arrow at the target port in the route's real arrival
direction, clipping, and value-based repaint. The layer is pointer transparent
so node widgets below it keep their gestures. Includes focused geometry,
painter and hit-test regressions, an isolated web probe with rendered evidence,
and a note recording the slice and its limits.
2026-10-21 18:31:38 +01:00

191 lines
5.6 KiB
Dart

import 'dart:ui' as ui;
import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/painting/graph_edge_layer.dart';
import 'package:pipelines_app/features/graph/routing/route_models.dart';
import 'edge_layer_fixtures.dart';
void main() {
const color = Colors.black87;
final straight = edgeRoute(
points: const [RoutePoint(10, 20), RoutePoint(90, 20)],
);
final wrapping = edgeRoute(
points: const [
RoutePoint(10, 20),
RoutePoint(40, 20),
RoutePoint(40, 60),
RoutePoint(80, 60),
RoutePoint(80, 50),
],
);
test('draws one stroke and one filled arrow per route, clipped', () {
final canvas = TestRecordingCanvas();
GraphEdgePainter(
routes: [straight, wrapping],
color: color,
strokeWidth: 2,
).paint(canvas, const Size(120, 80));
final calls = canvas.invocations
.where((call) => call.invocation.memberName == #drawPath)
.toList();
expect(calls.length, 4);
final paints = [
for (final call in calls)
call.invocation.positionalArguments.last as Paint,
];
expect(paints[0].style, PaintingStyle.stroke);
expect(paints[1].style, PaintingStyle.stroke);
expect(paints[2].style, PaintingStyle.fill);
expect(paints[3].style, PaintingStyle.fill);
expect(
paints.every((paint) => paint.color.toARGB32() == color.toARGB32()),
isTrue,
);
final clip = canvas.invocations.singleWhere(
(call) => call.invocation.memberName == #clipRect,
);
expect(
clip.invocation.positionalArguments.first,
const Rect.fromLTWH(0, 0, 120, 80),
);
});
test('paints nothing for an empty route list', () {
final canvas = TestRecordingCanvas();
GraphEdgePainter(
routes: const [],
color: color,
strokeWidth: 2,
).paint(canvas, const Size(120, 80));
expect(canvas.invocations, isEmpty);
});
test('reports every canvas point as a miss', () {
final painter = GraphEdgePainter(
routes: [straight],
color: color,
strokeWidth: 2,
);
expect(painter.hitTest(const Offset(50, 20)), isFalse);
expect(painter.hitTest(const Offset(500, 500)), isFalse);
});
testWidgets('clips painted geometry to the canvas bounds', (tester) async {
final recorder = ui.PictureRecorder();
GraphEdgePainter(
routes: [
edgeRoute(points: const [RoutePoint(-30, 10), RoutePoint(60, 10)]),
],
color: Colors.black,
strokeWidth: 6,
).paint(Canvas(recorder), const Size(20, 20));
final data = await tester.runAsync(() async {
final image = await recorder.endRecording().toImage(80, 40);
final bytes = await image.toByteData(format: ui.ImageByteFormat.rawRgba);
image.dispose();
return bytes;
});
expect(data, isNotNull);
final bytes = data!.buffer.asUint8List();
int alphaAt(int x, int y) => bytes[(y * 80 + x) * 4 + 3];
expect(alphaAt(10, 10), 255, reason: 'inside the clip is painted');
expect(alphaAt(40, 10), 0, reason: 'the route continues past the clip');
expect(alphaAt(10, 35), 0, reason: 'below the canvas stays empty');
});
testWidgets('lets taps through to a sibling below the canvas', (
tester,
) async {
var taps = 0;
Widget harness(List<EdgeRoute> routes) => MaterialApp(
home: Center(
child: SizedBox(
width: 200,
height: 100,
child: Stack(
children: [
Positioned.fill(
child: GestureDetector(
behavior: HitTestBehavior.opaque,
onTap: () => taps += 1,
),
),
GraphEdgeLayer(
routes: routes,
canvasSize: const Size(200, 100),
color: color,
strokeWidth: 2,
),
],
),
),
),
);
for (final routes in <List<EdgeRoute>>[
const <EdgeRoute>[],
[straight],
]) {
await tester.pumpWidget(harness(routes));
final origin = tester.getTopLeft(find.byType(GraphEdgeLayer));
final before = taps;
await tester.tapAt(origin + const Offset(50, 20));
await tester.tapAt(origin + const Offset(150, 80));
expect(taps, before + 2, reason: 'routes=$routes');
}
});
test('repaints on route, color or stroke changes only', () {
final painter = GraphEdgePainter(
routes: [straight],
color: color,
strokeWidth: 2,
);
GraphEdgePainter copy({
List<EdgeRoute>? routes,
Color? color,
double? strokeWidth,
}) => GraphEdgePainter(
routes: routes ?? [straight],
color: color ?? Colors.black87,
strokeWidth: strokeWidth ?? 2,
);
expect(painter.shouldRepaint(copy()), isFalse);
expect(painter.shouldRepaint(copy(color: Colors.red)), isTrue);
expect(painter.shouldRepaint(copy(strokeWidth: 3)), isTrue);
expect(
painter.shouldRepaint(
copy(
routes: [
edgeRoute(points: const [RoutePoint(10, 20), RoutePoint(90, 30)]),
],
),
),
isTrue,
);
});
testWidgets('lays out at the supplied canvas size', (tester) async {
await tester.pumpWidget(
MaterialApp(
home: Center(
child: GraphEdgeLayer(
routes: [wrapping],
canvasSize: const Size(120, 80),
color: color,
strokeWidth: 2,
),
),
),
);
expect(tester.getSize(find.byType(GraphEdgeLayer)), const Size(120, 80));
expect(tester.takeException(), isNull);
});
}