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? 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 = { 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 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; }