Files
pipelines/app/test/features/graph/routing/routing_assertions.dart
T
alan b381290f34 feat(app): add deterministic orthogonal graph edge routing
Pure-Dart P2c slice: interval-aware ports and corridors, label-aware lane spacing, measured label placement with fallback shelf, skipped diagnostics and routing bounds. 20 focused tests plus existing suite and web build pass.
2026-10-21 16:51:38 +01:00

216 lines
7.1 KiB
Dart

import 'dart:math' as math;
import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/layout/layout_models.dart';
import 'package:pipelines_app/features/graph/routing/route_models.dart';
const double _epsilon = 1e-9;
/// Checks the routing guarantees every fixture must satisfy.
void expectValidRouting(
GraphRouting routing,
GraphLayout layout, {
Map<int, LabelExtent>? extents,
}) {
expect(routing.width.isFinite, isTrue);
expect(routing.height.isFinite, isTrue);
expect(routing.width, greaterThan(0));
expect(routing.height, greaterThan(0));
for (final route in routing.routes) {
_expectRoute(route, layout, routing.width, routing.height);
_expectNoNodeInterior(route, layout);
}
expectDistinctCorridors(routing.routes);
final byId = <int, EdgeLabelBox>{
for (final label in routing.labels) label.edgeId: label,
};
expect(byId.length, routing.labels.length, reason: 'one label per edge');
for (final route in routing.routes) {
final label = byId[route.id];
expect(label, isNotNull, reason: 'edge ${route.id} has a label');
final extent = extents?[route.id];
if (extent != null) {
expect(label!.width, extent.width);
expect(label.height, extent.height);
}
expect(label!.x, greaterThanOrEqualTo(-_epsilon));
expect(label.y, greaterThanOrEqualTo(-_epsilon));
expect(label.right, lessThanOrEqualTo(routing.width + _epsilon));
expect(label.bottom, lessThanOrEqualTo(routing.height + _epsilon));
for (final node in layout.nodes) {
expect(
_overlaps(
label.x,
label.y,
label.width,
label.height,
node.x,
node.y,
node.width,
node.height,
),
isFalse,
reason: 'label for edge ${route.id} overlaps node ${node.key}',
);
}
}
for (var first = 0; first < routing.labels.length; first += 1) {
for (var second = first + 1; second < routing.labels.length; second += 1) {
final a = routing.labels[first];
final b = routing.labels[second];
expect(
_overlaps(a.x, a.y, a.width, a.height, b.x, b.y, b.width, b.height),
isFalse,
reason: 'labels for edges ${a.edgeId} and ${b.edgeId} overlap',
);
}
}
for (final skipped in routing.skipped) {
expect(routing.routeFor(skipped.id), isNull);
expect(routing.labelFor(skipped.id), isNull);
}
}
void expectDistinctCorridors(List<EdgeRoute> routes) {
for (var first = 0; first < routes.length; first += 1) {
for (var second = first + 1; second < routes.length; second += 1) {
final a = routes[first];
final b = routes[second];
for (var ai = 1; ai < a.points.length; ai += 1) {
final a0 = a.points[ai - 1];
final a1 = a.points[ai];
for (var bi = 1; bi < b.points.length; bi += 1) {
final b0 = b.points[bi - 1];
final b1 = b.points[bi];
if (a0.x == a1.x && b0.x == b1.x && a0.x == b0.x) {
final aLo = math.min(a0.y, a1.y);
final aHi = math.max(a0.y, a1.y);
final bLo = math.min(b0.y, b1.y);
final bHi = math.max(b0.y, b1.y);
expect(
aLo < bHi - _epsilon && bLo < aHi - _epsilon,
isFalse,
reason: 'edges ${a.id} and ${b.id} share a vertical corridor',
);
}
if (a0.y == a1.y && b0.y == b1.y && a0.y == b0.y) {
final aLo = math.min(a0.x, a1.x);
final aHi = math.max(a0.x, a1.x);
final bLo = math.min(b0.x, b1.x);
final bHi = math.max(b0.x, b1.x);
expect(
aLo < bHi - _epsilon && bLo < aHi - _epsilon,
isFalse,
reason: 'edges ${a.id} and ${b.id} share a horizontal run',
);
}
}
}
}
}
}
void _expectRoute(
EdgeRoute route,
GraphLayout layout,
double width,
double height,
) {
expect(route.points.length, greaterThanOrEqualTo(2));
expect(route.points.first, route.sourcePort.point);
expect(route.points.last, route.targetPort.point);
for (var index = 0; index < route.points.length; index += 1) {
final point = route.points[index];
expect(point.x.isFinite, isTrue);
expect(point.y.isFinite, isTrue);
expect(point.x, greaterThanOrEqualTo(-_epsilon));
expect(point.y, greaterThanOrEqualTo(-_epsilon));
expect(point.x, lessThanOrEqualTo(width + _epsilon));
expect(point.y, lessThanOrEqualTo(height + _epsilon));
if (index > 0) {
final previous = route.points[index - 1];
expect(
previous.x == point.x || previous.y == point.y,
isTrue,
reason: 'edge ${route.id} segment ${index - 1} is not orthogonal',
);
expect(previous, isNot(point), reason: 'zero-length segment');
}
}
_expectPort(route.sourcePort, layout.nodeFor(route.source)!);
_expectPort(route.targetPort, layout.nodeFor(route.target)!);
}
void _expectPort(RoutePort port, GraphNodeBox box) {
switch (port.side) {
case RoutePortSide.right:
expect(port.point.x, closeTo(box.right, _epsilon));
expect(port.point.y, greaterThanOrEqualTo(box.y - _epsilon));
expect(port.point.y, lessThanOrEqualTo(box.bottom + _epsilon));
case RoutePortSide.left:
expect(port.point.x, closeTo(box.x, _epsilon));
expect(port.point.y, greaterThanOrEqualTo(box.y - _epsilon));
expect(port.point.y, lessThanOrEqualTo(box.bottom + _epsilon));
case RoutePortSide.top:
expect(port.point.y, closeTo(box.y, _epsilon));
expect(port.point.x, greaterThanOrEqualTo(box.x - _epsilon));
expect(port.point.x, lessThanOrEqualTo(box.right + _epsilon));
case RoutePortSide.bottom:
expect(port.point.y, closeTo(box.bottom, _epsilon));
expect(port.point.x, greaterThanOrEqualTo(box.x - _epsilon));
expect(port.point.x, lessThanOrEqualTo(box.right + _epsilon));
}
}
void _expectNoNodeInterior(EdgeRoute route, GraphLayout layout) {
for (var index = 1; index < route.points.length; index += 1) {
final a = route.points[index - 1];
final b = route.points[index];
for (final node in layout.nodes) {
if (a.y == b.y) {
final left = math.min(a.x, b.x);
final right = math.max(a.x, b.x);
final crosses =
a.y > node.y + _epsilon &&
a.y < node.bottom - _epsilon &&
right > node.x + _epsilon &&
left < node.right - _epsilon;
expect(
crosses,
isFalse,
reason: 'edge ${route.id} crosses node ${node.key} horizontally',
);
} else {
final top = math.min(a.y, b.y);
final bottom = math.max(a.y, b.y);
final crosses =
a.x > node.x + _epsilon &&
a.x < node.right - _epsilon &&
bottom > node.y + _epsilon &&
top < node.bottom - _epsilon;
expect(
crosses,
isFalse,
reason: 'edge ${route.id} crosses node ${node.key} vertically',
);
}
}
}
}
bool _overlaps(
double ax,
double ay,
double aw,
double ah,
double bx,
double by,
double bw,
double bh,
) {
return ax < bx + bw && ax + aw > bx && ay < by + bh && ay + ah > by;
}