core: expose allowed track sections in the pathfinding api

The pathfinding api did not use any track section constraints whereas
the simulation did which means that pathfinding requests might be valid but
their corresponding simulation may not have been doable.

Signed-off-by: Martin Bourbier <mbourbier28@gmail.com>

Author: MartinBourbier

core/src/main/kotlin/fr/sncf/osrd/api/pathfinding/PathfindingBlockRequest.kt

@@ -25,6 +25,9 @@ class PathfindingBlockRequest(
 
     // One set of location by step, each step must be reached in order
     @Json(name = "path_items") val pathItems: List<PathItem>,
+
+    // Set of authorized track section ids, `null` means no restriction
+    @Json(name = "allowed_track_sections") val allowedTrackSections: Set<String>? = null,
 )
 
 val pathfindingRequestAdapter: JsonAdapter<PathfindingBlockRequest> =

core/src/main/kotlin/fr/sncf/osrd/api/pathfinding/PathfindingBlocksEndpoint.kt

@@ -15,6 +15,7 @@ import fr.sncf.osrd.graph.*
 import fr.sncf.osrd.path.interfaces.PhysicsPath
 import fr.sncf.osrd.path.interfaces.TrainPath
 import fr.sncf.osrd.pathfinding.Pathfinding
+import fr.sncf.osrd.pathfinding.constraints.TrackSectionConstraints
 import fr.sncf.osrd.pathfinding.constraints.initConstraintsFromRSProps
 import fr.sncf.osrd.reporting.exceptions.ErrorType
 import fr.sncf.osrd.reporting.exceptions.OSRDError
@@ -121,14 +122,26 @@ fun runPathfinding(infra: FullInfra, request: PathfindingBlockRequest): Pathfind
         targets.add(ExplorerStep(allStarts, canBacktrack = step.canBacktrack))
     }
     if (targets.size < 2) throw NoPathFoundException(NotEnoughPathItems())
-    val constraints =
+    val rsConstraints =
         initConstraintsFromRSProps(
             infra,
             request.rollingStockIsThermal,
             request.rollingStockLoadingGauge,
             request.rollingStockSupportedElectrifications,
             request.rollingStockSupportedSignalingSystems,
         )
+    val allowedTrackSectionIds = parseAllowedTrackSections(infra, request.allowedTrackSections)
+    val constraints =
+        if (allowedTrackSectionIds != null && allowedTrackSectionIds.isNotEmpty()) {
+            rsConstraints +
+                listOf(
+                    TrackSectionConstraints(
+                        infra.blockInfra,
+                        infra.rawInfra,
+                        allowedTrackSectionIds,
+                    )
+                )
+        } else rsConstraints
 
     // Compute the paths from the entry waypoint to the exit waypoint
     val timeout = request.timeout ?: Pathfinding.TIMEOUT
@@ -345,3 +358,11 @@ fun findStopPositionAtEndOfBlockConsideringRollingStock(
 
     return BlockLocation(waypointBlock.edge, newWaypointOffset)
 }
+
+/** Converts a set of track section id strings to a set of [TrackSectionId] */
+fun parseAllowedTrackSections(
+    infra: FullInfra,
+    trackSectionNames: Set<String>?,
+): Set<TrackSectionId>? {
+    return trackSectionNames?.mapNotNull { infra.rawInfra.getTrackSectionFromName(it) }?.toSet()
+}

core/src/test/kotlin/fr/sncf/osrd/pathfinding/PathfindingTest.kt

@@ -610,6 +610,66 @@ class PathfindingTest : ApiTest() {
     }
 }
 
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class PathfindingAllowedTrackSectionsTest {
+    // tiny_infra path: foo_b -> foo_to_bar -> bar_a
+    private val infra = Helpers.fullInfraFromFile("tiny_infra/infra.json")
+    private val waypointsStart = listOf(TrackLocation("ne.micro.foo_b", Offset(50.meters)))
+    private val waypointsEnd = listOf(TrackLocation("ne.micro.bar_a", Offset(100.meters)))
+    private val pathItems = listOf(PathItem(waypointsStart, false), PathItem(waypointsEnd, false))
+
+    private fun makeRequest(allowedTrackSections: Set<String>?) =
+        PathfindingBlockRequest(
+            rollingStockLoadingGauge = TestTrains.REALISTIC_FAST_TRAIN.loadingGaugeType,
+            rollingStockIsThermal = TestTrains.REALISTIC_FAST_TRAIN.isThermal,
+            rollingStockSupportedElectrifications =
+                TestTrains.REALISTIC_FAST_TRAIN.modeNames.filterNot { it == "thermal" },
+            rollingStockSupportedSignalingSystems =
+                TestTrains.REALISTIC_FAST_TRAIN.supportedSignalingSystems.toList(),
+            rollingStockMaximumSpeed = TestTrains.REALISTIC_FAST_TRAIN.maxSpeed,
+            rollingStockLength = TestTrains.REALISTIC_FAST_TRAIN.length,
+            timeout = null,
+            infra = "tiny_infra/infra.json",
+            expectedVersion = 1,
+            pathItems = pathItems,
+            allowedTrackSections = allowedTrackSections,
+        )
+
+    @Test
+    fun allowedTrackSectionsNullMeansNoRestriction() {
+        checkPathfindingSuccess(runPathfinding(infra, makeRequest(null)), 10250.meters)
+    }
+
+    @Test
+    fun allowedTrackSectionsEmptyMeansNoRestriction() {
+        checkPathfindingSuccess(runPathfinding(infra, makeRequest(emptySet())), 10250.meters)
+    }
+
+    @Test
+    fun allowedTrackSectionsSucceedsWithRequiredTracks() {
+        checkPathfindingSuccess(
+            runPathfinding(
+                infra,
+                makeRequest(setOf("ne.micro.foo_b", "ne.micro.foo_to_bar", "ne.micro.bar_a")),
+            ),
+            10250.meters,
+        )
+    }
+
+    @Test
+    fun allowedTrackSectionsFailsWhenRequiredTrackExcluded() {
+        // omit foo_to_bar
+        assertThatThrownBy {
+                runPathfinding(infra, makeRequest(setOf("ne.micro.foo_b", "ne.micro.bar_a")))
+            }
+            .isExactlyInstanceOf(NoPathFoundException::class.java)
+            .satisfies({ e ->
+                assertThat((e as NoPathFoundException).response)
+                    .isExactlyInstanceOf(NotFoundInBlocks::class.java)
+            })
+    }
+}
+
 class PathfindingStopsAtEndOfBlock : ApiTest() {
     fun callPathfindingEndpoint(
         rs: RollingStock,