Files
pipelines/app/test/features/graph/routing/graph_edge_routing_test.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

192 lines
7.2 KiB
Dart

import 'package:flutter_test/flutter_test.dart';
import 'package:pipelines_app/features/graph/domain/graph_definition.dart';
import 'package:pipelines_app/features/graph/domain/graph_protocol.dart';
import 'package:pipelines_app/features/graph/routing/route_models.dart';
import '../layout/layout_fixtures.dart' as layout;
import 'routing_assertions.dart';
import 'routing_fixtures.dart';
void main() {
test('chain routes keep identities and use straight forward runs', () {
final graph = chainGraphFixture();
final layoutBox = layoutFor(graph);
final edges = graphEdges(graph);
final labels = labelsFor(edges);
final routing = routeFor(graph, labels: labels);
expect(routing.skipped, isEmpty);
expect(
routing.routes.map((route) => route.id),
edges.map((edge) => edge.id),
);
for (var index = 0; index < edges.length; index += 1) {
final edge = edges[index];
final route = routing.routes[index];
expect(route.source, edge.source);
expect(route.outcome, edge.outcome);
expect(route.target, edge.target);
expect(route.label, edge.label);
expect(route.fallback, edge.fallback);
expect(route.kind, RouteKind.forward);
expect(route.straight, isTrue);
expect(route.points.length, 2);
expect(route.sourcePort.side, RoutePortSide.right);
expect(route.targetPort.side, RoutePortSide.left);
}
expectValidRouting(routing, layoutBox, extents: labels);
});
test('diamond fan-out and fan-in avoid every node interior', () {
final graph = diamondGraphFixture();
final layoutBox = layoutFor(graph);
final labels = labelsFor(graphEdges(graph));
final routing = routeFor(graph, labels: labels);
expect(routing.skipped, isEmpty);
expect(routing.routes.length, graphEdges(graph).length);
final fromA = routing.routes.where((route) => route.source == 'a');
expect(fromA.length, 3);
expect(
fromA.where((route) => route.straight).length,
greaterThanOrEqualTo(1),
);
final longForward = fromA.singleWhere(
(route) => route.target == failureEnd,
);
expect(longForward.kind, RouteKind.forward);
expect(longForward.straight, isFalse);
expect(longForward.points.length, greaterThan(4));
expectValidRouting(routing, layoutBox, extents: labels);
});
test('parallel outcomes to one target get separate corridors and labels', () {
final graph = parallelOutcomesGraph();
final layoutBox = layoutFor(graph);
final labels = labelsFor(graphEdges(graph));
final routing = routeFor(graph, labels: labels);
final parallel = routing.routes
.where((route) => route.source == 'a' && route.target == 'b')
.toList();
expect(parallel.length, 3);
final ports = <String>{
for (final route in parallel)
'${route.sourcePort.point.y}/${route.targetPort.point.y}',
};
expect(ports.length, 3, reason: 'each outcome has its own port pair');
final labelBoxes = <EdgeLabelBox>[
for (final route in parallel) routing.labelFor(route.id)!,
];
expect(labelBoxes.map((box) => box.y).toSet().length, greaterThan(1));
expectValidRouting(routing, layoutBox, extents: labels);
});
test('a same-rank cycle uses distinct lanes around both members', () {
final graph = cycleGraphFixture();
final layoutBox = layoutFor(graph);
final labels = labelsFor(graphEdges(graph));
final routing = routeFor(graph, labels: labels);
final sameRank = routing.routes
.where((route) => route.kind == RouteKind.sameRank)
.toList();
expect(sameRank.length, 2);
expect(sameRank.map((route) => route.target).toSet(), <String>{'a', 'b'});
for (final route in sameRank) {
expect(route.straight, isFalse);
expect(route.sourcePort.side, RoutePortSide.right);
expect(route.targetPort.side, RoutePortSide.right);
expect(
route.points.map((point) => point.y).toSet().length,
greaterThan(2),
);
}
expectValidRouting(routing, layoutBox, extents: labels);
});
test('a self loop expands bounds and keeps both ports on its border', () {
final graph = selfLoopOnlyGraph();
final layoutBox = layoutFor(graph);
final labels = labelsFor(graphEdges(graph));
final routing = routeFor(graph, labels: labels);
final route = routing.routes.single;
expect(route.kind, RouteKind.selfLoop);
expect(route.straight, isFalse);
expect(route.points.length, greaterThanOrEqualTo(4));
expect(route.sourcePort.side, RoutePortSide.right);
expect(route.targetPort.side, RoutePortSide.right);
expect(route.sourcePort.point.y, isNot(route.targetPort.point.y));
expect(routing.width, greaterThan(layoutBox.width));
expect(routing.height, greaterThan(layoutBox.height));
expectValidRouting(routing, layoutBox, extents: labels);
});
test('disconnected stages route only their declared edges', () {
final graph = disconnectedGraphFixture();
final layoutBox = layoutFor(graph);
final labels = labelsFor(graphEdges(graph));
final routing = routeFor(graph, labels: labels);
expect(routing.skipped, isEmpty);
expect(routing.routes.length, 2);
expect(routing.routes.map((route) => route.source).toSet(), <String>{
'a',
'b',
});
expect(layoutBox.nodeFor('c'), isNotNull);
expect(routing.routes.any((route) => route.source == 'c'), isFalse);
expectValidRouting(routing, layoutBox, extents: labels);
});
test('heterogeneous and expanded text sizes stay valid and grow bounds', () {
final graph = diamondGraphFixture();
final baseLayout = layoutFor(graph, extents: layout.heterogeneousExtents());
final expandedExtents = layout.scaledExtents(
layout.heterogeneousExtents(),
2.6,
);
final expandedLayout = layoutFor(graph, extents: expandedExtents);
final edges = graphEdges(graph);
final labels = fixedLabels(edges);
final base = routeFor(
graph,
extents: layout.heterogeneousExtents(),
labels: labels,
);
final expanded = routeFor(graph, extents: expandedExtents, labels: labels);
expectValidRouting(base, baseLayout, extents: labels);
expectValidRouting(expanded, expandedLayout, extents: labels);
expect(expanded.width, greaterThan(base.width));
expect(expanded.height, greaterThan(base.height));
});
test('unknown and missing targets are skipped with their identity', () {
final graph = incompleteGraphFixture();
final layoutBox = layoutFor(graph);
final edges = graphEdges(graph);
final labels = labelsFor(edges);
final routing = routeFor(graph, labels: labels);
expect(routing.skipped.length, 2);
final skipped = routing.skipped.toList();
expect(skipped.map((item) => item.reason), <RouteSkipReason>[
RouteSkipReason.unknownTarget,
RouteSkipReason.unknownTarget,
]);
expect(skipped.map((item) => item.id), <int>[1, 2]);
expect(skipped[0].source, 'a');
expect(skipped[0].outcome, 'blocked');
expect(skipped[0].target, '');
expect(skipped[1].target, 'ghost');
expect(routing.routes.map((route) => route.id), <int>[3, 4]);
expect(routing.routeFor(1), isNull);
expect(routing.routeFor(2), isNull);
expect(layoutBox.nodeFor('ghost'), isNull);
expectValidRouting(routing, layoutBox, extents: labels);
});
}