420 lines
15 KiB
TypeScript
420 lines
15 KiB
TypeScript
import { describe, expect, it } from "vitest";
|
|
import {
|
|
buildFairwayRoute,
|
|
buildFairwayRoutes,
|
|
buildManualRoute,
|
|
buildRoute,
|
|
haversineDistanceNm,
|
|
requiredDepthM,
|
|
type FairwayEdge,
|
|
type FairwayGraph
|
|
} from "../src/index.js";
|
|
|
|
const EMDEN_AUSSENHAFEN = { lat: 53.344167, lon: 7.186111 };
|
|
const BORKUM_REEDE = { lat: 53.563776, lon: 6.750562 };
|
|
const HAMM_INNENSTADT_MARINA = { lat: 51.6814536, lon: 7.8042615 };
|
|
|
|
const ALTERNATIVE_GRAPH: FairwayGraph = {
|
|
id: "alternative-test",
|
|
name: "Alternativen-Testnetz",
|
|
maxSnapDistanceNm: 0.2,
|
|
nodes: [
|
|
{ id: "start", coordinate: { lat: 52, lon: 7 } },
|
|
{ id: "branch-in", coordinate: { lat: 52, lon: 7.01 } },
|
|
{ id: "upper", coordinate: { lat: 52.012, lon: 7.03 } },
|
|
{ id: "lower", coordinate: { lat: 51.988, lon: 7.03 } },
|
|
{ id: "branch-out", coordinate: { lat: 52, lon: 7.05 } },
|
|
{ id: "destination", coordinate: { lat: 52, lon: 7.06 } }
|
|
],
|
|
edges: [
|
|
edge("start-access", "start", "branch-in", [{ lat: 52, lon: 7 }, { lat: 52, lon: 7.01 }]),
|
|
edge("main", "branch-in", "branch-out", [{ lat: 52, lon: 7.01 }, { lat: 52, lon: 7.05 }]),
|
|
edge("upper-in", "branch-in", "upper", [{ lat: 52, lon: 7.01 }, { lat: 52.012, lon: 7.03 }]),
|
|
edge("upper-out", "upper", "branch-out", [{ lat: 52.012, lon: 7.03 }, { lat: 52, lon: 7.05 }]),
|
|
edge("lower-in", "branch-in", "lower", [{ lat: 52, lon: 7.01 }, { lat: 51.988, lon: 7.03 }]),
|
|
edge("lower-out", "lower", "branch-out", [{ lat: 51.988, lon: 7.03 }, { lat: 52, lon: 7.05 }]),
|
|
edge("destination-access", "branch-out", "destination", [
|
|
{ lat: 52, lon: 7.05 },
|
|
{ lat: 52, lon: 7.06 }
|
|
])
|
|
]
|
|
};
|
|
|
|
const COMPONENT_AWARE_SNAP_GRAPH: FairwayGraph = {
|
|
id: "component-aware-snap-test",
|
|
name: "Komponentenbewusster Snap-Test",
|
|
maxSnapDistanceNm: 0.3,
|
|
nodes: [
|
|
{ id: "start-decoy-a", coordinate: { lat: 53.3416, lon: 7.186 } },
|
|
{ id: "start-decoy-b", coordinate: { lat: 53.342, lon: 7.187 } },
|
|
{ id: "destination-decoy-a", coordinate: { lat: 53.3282, lon: 6.9304 } },
|
|
{ id: "destination-decoy-b", coordinate: { lat: 53.3286, lon: 6.9294 } },
|
|
{ id: "shared-start", coordinate: { lat: 53.3395697, lon: 7.1848883 } },
|
|
{ id: "shared-east", coordinate: { lat: 53.3321722, lon: 7.1329034 } },
|
|
{ id: "shared-south", coordinate: { lat: 53.313849, lon: 7.0011017 } },
|
|
{ id: "shared-destination", coordinate: { lat: 53.3303531, lon: 6.9334715 } }
|
|
],
|
|
edges: [
|
|
edge("start-decoy", "start-decoy-a", "start-decoy-b", [
|
|
{ lat: 53.3416, lon: 7.186 },
|
|
{ lat: 53.342, lon: 7.187 }
|
|
], { source: "closer-but-disconnected-start" }),
|
|
edge("destination-decoy", "destination-decoy-a", "destination-decoy-b", [
|
|
{ lat: 53.3282, lon: 6.9304 },
|
|
{ lat: 53.3286, lon: 6.9294 }
|
|
], { source: "closer-but-disconnected-destination" }),
|
|
edge("shared-east", "shared-start", "shared-east", [
|
|
{ lat: 53.3395697, lon: 7.1848883 },
|
|
{ lat: 53.3321722, lon: 7.1329034 }
|
|
], { source: "shared-local-component" }),
|
|
edge("shared-south", "shared-east", "shared-south", [
|
|
{ lat: 53.3321722, lon: 7.1329034 },
|
|
{ lat: 53.313849, lon: 7.0011017 }
|
|
], { source: "shared-local-component" }),
|
|
edge("shared-west", "shared-south", "shared-destination", [
|
|
{ lat: 53.313849, lon: 7.0011017 },
|
|
{ lat: 53.3303531, lon: 6.9334715 }
|
|
], { source: "shared-local-component" })
|
|
]
|
|
};
|
|
|
|
function edge(
|
|
id: string,
|
|
from: string,
|
|
to: string,
|
|
coordinates: FairwayEdge["coordinates"],
|
|
restrictions: Partial<FairwayEdge> = {}
|
|
): FairwayEdge {
|
|
return {
|
|
id,
|
|
name: id,
|
|
from,
|
|
to,
|
|
coordinates,
|
|
minDepthM: 4,
|
|
source: "synthetic-test",
|
|
...restrictions
|
|
};
|
|
}
|
|
|
|
function singleEdgeGraph(restrictions: Partial<FairwayEdge>): FairwayGraph {
|
|
return {
|
|
id: "restriction-test",
|
|
name: "Restriktions-Testnetz",
|
|
maxSnapDistanceNm: 0.2,
|
|
nodes: [
|
|
{ id: "start", coordinate: { lat: 52, lon: 7 } },
|
|
{ id: "destination", coordinate: { lat: 52, lon: 7.04 } }
|
|
],
|
|
edges: [
|
|
edge(
|
|
"restricted",
|
|
"start",
|
|
"destination",
|
|
[{ lat: 52, lon: 7 }, { lat: 52, lon: 7.04 }],
|
|
restrictions
|
|
)
|
|
]
|
|
};
|
|
}
|
|
|
|
describe("route assessment", () => {
|
|
it("marks routes with no depth data as unknown", () => {
|
|
const result = buildManualRoute({
|
|
start: { lat: 54.18, lon: 12.08 },
|
|
destination: { lat: 54.32, lon: 12.22 },
|
|
vesselProfile: { draughtM: 1.4, safetyReserveM: 0.5 }
|
|
});
|
|
|
|
expect(result.unknownDepthRatio).toBe(1);
|
|
expect(result.warnings.some((warning) => warning.code === "DEPTH_UNKNOWN")).toBe(true);
|
|
});
|
|
|
|
it("flags known shallow samples as critical", () => {
|
|
const result = buildManualRoute({
|
|
start: { lat: 54.18, lon: 12.08 },
|
|
destination: { lat: 54.32, lon: 12.22 },
|
|
vesselProfile: { draughtM: 1.4, safetyReserveM: 0.5 },
|
|
depthSamples: [
|
|
{ coordinate: { lat: 54.2, lon: 12.1 }, depthM: 1.6 },
|
|
{ coordinate: { lat: 54.25, lon: 12.16 }, depthM: 2.4 }
|
|
]
|
|
});
|
|
|
|
expect(requiredDepthM({ draughtM: 1.4, safetyReserveM: 0.5 })).toBe(1.9);
|
|
expect(result.minKnownDepthM).toBe(1.6);
|
|
expect(result.warnings.some((warning) => warning.severity === "critical")).toBe(true);
|
|
});
|
|
|
|
it("routes Emden Außenhafen to Borkum Reede along the Ems fairway graph", () => {
|
|
const result = buildRoute({
|
|
start: EMDEN_AUSSENHAFEN,
|
|
destination: BORKUM_REEDE,
|
|
vesselProfile: { draughtM: 1.4, safetyReserveM: 0.5, cruiseSpeedKn: 12 }
|
|
});
|
|
expect(result).not.toBeNull();
|
|
if (!result) {
|
|
throw new Error("Expected fairway route");
|
|
}
|
|
const directDistanceNm = haversineDistanceNm(EMDEN_AUSSENHAFEN, BORKUM_REEDE);
|
|
const coordinates = result.geometry.coordinates;
|
|
const largestSegmentNm = coordinates.slice(1).reduce((largest, coordinate, index) => {
|
|
const previous = coordinates[index]!;
|
|
return Math.max(
|
|
largest,
|
|
haversineDistanceNm(
|
|
{ lon: previous[0], lat: previous[1] },
|
|
{ lon: coordinate[0], lat: coordinate[1] }
|
|
)
|
|
);
|
|
}, 0);
|
|
|
|
expect(result.routingMode).toBe("fairway");
|
|
expect(result.dataSources).toContain("fairway-graph:ems-borkum-seed");
|
|
expect(result.warnings.some((warning) => warning.code === "FAIRWAY_ROUTE")).toBe(true);
|
|
expect(result.warnings.some((warning) => warning.code === "MANUAL_ROUTE")).toBe(false);
|
|
expect(coordinates.length).toBeGreaterThan(20);
|
|
expect(result.distanceNm).toBeGreaterThan(directDistanceNm * 1.2);
|
|
expect(largestSegmentNm).toBeLessThan(6);
|
|
expect(coordinates.some(([lon, lat]) => lon < 6.9 && lat < 53.45)).toBe(true);
|
|
});
|
|
|
|
it("snaps nearby Emden-Borkum clicks to fairway segments instead of requiring exact graph nodes", () => {
|
|
const clickedStart = { lat: 53.3418, lon: 7.1904 };
|
|
const clickedDestination = { lat: 53.5608, lon: 6.7548 };
|
|
const result = buildRoute({
|
|
start: clickedStart,
|
|
destination: clickedDestination,
|
|
vesselProfile: { draughtM: 1.4, safetyReserveM: 0.5, cruiseSpeedKn: 12 }
|
|
});
|
|
|
|
expect(result).not.toBeNull();
|
|
if (!result) {
|
|
throw new Error("Expected fairway route for nearby clicks");
|
|
}
|
|
|
|
expect(result.routingMode).toBe("fairway");
|
|
expect(result.geometry.coordinates.length).toBeGreaterThan(20);
|
|
expect(result.geometry.coordinates[0]).toEqual([clickedStart.lon, clickedStart.lat]);
|
|
expect(result.geometry.coordinates.at(-1)).toEqual([clickedDestination.lon, clickedDestination.lat]);
|
|
expect(result.dataSources).toContain("fairway-graph:ems-borkum-seed");
|
|
});
|
|
|
|
it("uses a shared reachable component when the individually nearest edges are disconnected", () => {
|
|
const start = { lat: 53.3416, lon: 7.186 };
|
|
const destination = { lat: 53.3282, lon: 6.9304 };
|
|
const routes = buildFairwayRoutes(
|
|
{
|
|
start,
|
|
destination,
|
|
vesselProfile: { draughtM: 1, safetyReserveM: 0.3 }
|
|
},
|
|
COMPONENT_AWARE_SNAP_GRAPH
|
|
);
|
|
|
|
expect(routes).toHaveLength(1);
|
|
expect(routes[0]?.geometry.coordinates[0]).toEqual([start.lon, start.lat]);
|
|
expect(routes[0]?.geometry.coordinates.at(-1)).toEqual([destination.lon, destination.lat]);
|
|
expect(routes[0]?.dataSources).toContain("shared-local-component");
|
|
expect(routes[0]?.dataSources).not.toContain("closer-but-disconnected-start");
|
|
expect(routes[0]?.dataSources).not.toContain("closer-but-disconnected-destination");
|
|
expect(routes[0]?.distanceNm).toBeGreaterThan(9.5);
|
|
expect(routes[0]?.distanceNm).toBeLessThan(10.5);
|
|
});
|
|
|
|
it("returns no route when start and destination have no shared component inside the snap radius", () => {
|
|
const disconnectedGraph: FairwayGraph = {
|
|
...COMPONENT_AWARE_SNAP_GRAPH,
|
|
nodes: COMPONENT_AWARE_SNAP_GRAPH.nodes.slice(0, 4),
|
|
edges: COMPONENT_AWARE_SNAP_GRAPH.edges.slice(0, 2)
|
|
};
|
|
|
|
expect(
|
|
buildFairwayRoute(
|
|
{
|
|
start: { lat: 53.3416, lon: 7.186 },
|
|
destination: { lat: 53.3282, lon: 6.9304 },
|
|
vesselProfile: { draughtM: 1, safetyReserveM: 0.3 }
|
|
},
|
|
disconnectedGraph
|
|
)
|
|
).toBeNull();
|
|
});
|
|
|
|
it("tries another snap in the same component when the nearest one-way branch cannot be exited", () => {
|
|
const graph: FairwayGraph = {
|
|
id: "oneway-snap-fallback",
|
|
name: "Einbahnstraßen-Snap-Fallback",
|
|
maxSnapDistanceNm: 0.2,
|
|
nodes: [
|
|
{ id: "junction", coordinate: { lat: 52, lon: 7 } },
|
|
{ id: "destination", coordinate: { lat: 52, lon: 7.04 } },
|
|
{ id: "oneway-dead-end", coordinate: { lat: 52.001, lon: 7 } }
|
|
],
|
|
edges: [
|
|
edge(
|
|
"oneway-trap",
|
|
"junction",
|
|
"oneway-dead-end",
|
|
[{ lat: 52, lon: 7 }, { lat: 52.001, lon: 7 }],
|
|
{ oneway: true, source: "oneway-trap" }
|
|
),
|
|
edge(
|
|
"main-route",
|
|
"junction",
|
|
"destination",
|
|
[{ lat: 52, lon: 7 }, { lat: 52, lon: 7.04 }],
|
|
{ source: "routable-main-edge" }
|
|
)
|
|
]
|
|
};
|
|
const route = buildFairwayRoute(
|
|
{
|
|
start: { lat: 52.001, lon: 7 },
|
|
destination: { lat: 52, lon: 7.04 },
|
|
vesselProfile: { draughtM: 1, safetyReserveM: 0.3 }
|
|
},
|
|
graph
|
|
);
|
|
|
|
expect(route).not.toBeNull();
|
|
expect(route?.dataSources).toContain("routable-main-edge");
|
|
expect(route?.dataSources).not.toContain("oneway-trap");
|
|
});
|
|
|
|
it("does not fall back to a misleading straight line when no fairway graph matches", () => {
|
|
const result = buildRoute({
|
|
start: { lat: 54.1749, lon: 12.0731 },
|
|
destination: { lat: 54.1833, lon: 12.0928 },
|
|
vesselProfile: { draughtM: 1.4, safetyReserveM: 0.5, cruiseSpeedKn: 6 }
|
|
});
|
|
|
|
expect(result).toBeNull();
|
|
});
|
|
|
|
it("routes Emden to Hamm via the Ems, Dortmund-Ems-Kanal and Datteln-Hamm-Kanal fallback", () => {
|
|
const result = buildRoute({
|
|
start: EMDEN_AUSSENHAFEN,
|
|
destination: HAMM_INNENSTADT_MARINA,
|
|
vesselProfile: { draughtM: 1.4, safetyReserveM: 0.5, cruiseSpeedKn: 6 }
|
|
});
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result?.distanceNm).toBeGreaterThan(145);
|
|
expect(result?.distanceNm).toBeLessThan(165);
|
|
expect(result?.geometry.coordinates.length).toBeGreaterThan(350);
|
|
expect(result?.dataSources).toContain("fairway-graph:emden-hamm-inland-seed");
|
|
expect(result?.dataSources).toContain("openstreetmap-geofabrik-curated-seed");
|
|
expect(result?.dataSources).toContain("openstreetmap-nominatim-curated-seed");
|
|
expect(result?.warnings.some((warning) => warning.code === "FAIRWAY_DATA_NOT_OFFICIAL")).toBe(true);
|
|
});
|
|
|
|
it("uses the requested departure time as the basis for duration and ETA", () => {
|
|
const departureTime = "2026-07-20T04:15:00.000Z";
|
|
const result = buildFairwayRoute(
|
|
{
|
|
start: { lat: 52, lon: 7 },
|
|
destination: { lat: 52, lon: 7.04 },
|
|
departureTime,
|
|
vesselProfile: { draughtM: 1.2, safetyReserveM: 0.3, cruiseSpeedKn: 6 }
|
|
},
|
|
singleEdgeGraph({})
|
|
);
|
|
|
|
expect(result).not.toBeNull();
|
|
expect(result?.departureTime).toBe(departureTime);
|
|
expect(result?.durationMinutes).toBeGreaterThan(0);
|
|
expect(result?.eta).toBe(
|
|
new Date(Date.parse(departureTime) + (result?.durationMinutes ?? 0) * 60_000).toISOString()
|
|
);
|
|
});
|
|
|
|
it("returns a shortest route plus two genuinely different alternatives", () => {
|
|
const routes = buildFairwayRoutes(
|
|
{
|
|
start: { lat: 52, lon: 7 },
|
|
destination: { lat: 52, lon: 7.06 },
|
|
vesselProfile: { draughtM: 1.2, safetyReserveM: 0.3, cruiseSpeedKn: 6 }
|
|
},
|
|
ALTERNATIVE_GRAPH
|
|
);
|
|
|
|
expect(routes).toHaveLength(3);
|
|
expect(routes.map((route) => route.id)).toEqual([
|
|
"alternative-test-route-1",
|
|
"alternative-test-route-2",
|
|
"alternative-test-route-3"
|
|
]);
|
|
expect(routes.map((route) => route.name)).toEqual(["Hauptroute", "Alternative 1", "Alternative 2"]);
|
|
expect(routes[0]!.distanceNm).toBeLessThan(routes[1]!.distanceNm);
|
|
expect(new Set(routes.map((route) => JSON.stringify(route.geometry.coordinates))).size).toBe(3);
|
|
expect(buildFairwayRoutes(
|
|
{
|
|
start: { lat: 52, lon: 7 },
|
|
destination: { lat: 52, lon: 7.06 },
|
|
vesselProfile: { draughtM: 1.2, safetyReserveM: 0.3 }
|
|
},
|
|
ALTERNATIVE_GRAPH,
|
|
1
|
|
)).toHaveLength(1);
|
|
});
|
|
|
|
it("filters edges that violate air-draft, beam, or maximum-draught restrictions", () => {
|
|
const baseRequest = {
|
|
start: { lat: 52, lon: 7 },
|
|
destination: { lat: 52, lon: 7.04 },
|
|
vesselProfile: {
|
|
draughtM: 1.4,
|
|
safetyReserveM: 0.3,
|
|
airDraftM: 3,
|
|
beamM: 3
|
|
}
|
|
};
|
|
|
|
expect(buildFairwayRoute(baseRequest, singleEdgeGraph({ maxAirDraftM: 2.5 }))).toBeNull();
|
|
expect(buildFairwayRoute(baseRequest, singleEdgeGraph({ maxBeamM: 2.5 }))).toBeNull();
|
|
expect(buildFairwayRoute(baseRequest, singleEdgeGraph({ maxDraughtM: 1.2 }))).toBeNull();
|
|
expect(
|
|
buildFairwayRoute(baseRequest, singleEdgeGraph({ maxAirDraftM: 3, maxBeamM: 3, maxDraughtM: 1.4 }))
|
|
).not.toBeNull();
|
|
});
|
|
|
|
it("uses an unrestricted detour when the shorter edge is too low for the vessel", () => {
|
|
const graph: FairwayGraph = {
|
|
...ALTERNATIVE_GRAPH,
|
|
edges: ALTERNATIVE_GRAPH.edges.map((candidate) =>
|
|
candidate.id === "main" ? { ...candidate, maxAirDraftM: 2 } : candidate
|
|
)
|
|
};
|
|
const route = buildFairwayRoute(
|
|
{
|
|
start: { lat: 52, lon: 7 },
|
|
destination: { lat: 52, lon: 7.06 },
|
|
vesselProfile: { draughtM: 1.2, safetyReserveM: 0.3, airDraftM: 2.5 }
|
|
},
|
|
graph
|
|
);
|
|
|
|
expect(route).not.toBeNull();
|
|
expect(route?.geometry.coordinates.some(([, lat]) => lat !== 52)).toBe(true);
|
|
});
|
|
|
|
it("honours one-way fairway edges for direct and reverse travel", () => {
|
|
const graph = singleEdgeGraph({ oneway: true });
|
|
const profile = { draughtM: 1.2, safetyReserveM: 0.3 };
|
|
|
|
expect(
|
|
buildFairwayRoute(
|
|
{ start: { lat: 52, lon: 7 }, destination: { lat: 52, lon: 7.04 }, vesselProfile: profile },
|
|
graph
|
|
)
|
|
).not.toBeNull();
|
|
expect(
|
|
buildFairwayRoute(
|
|
{ start: { lat: 52, lon: 7.04 }, destination: { lat: 52, lon: 7 }, vesselProfile: profile },
|
|
graph
|
|
)
|
|
).toBeNull();
|
|
});
|
|
});
|