diff --git a/application/src/ext-test/java/org/opentripplanner/ext/trias/service/OjpServiceTest.java b/application/src/ext-test/java/org/opentripplanner/ext/trias/service/OjpServiceTest.java index 81e072e6ea2..0053d7a5a2d 100644 --- a/application/src/ext-test/java/org/opentripplanner/ext/trias/service/OjpServiceTest.java +++ b/application/src/ext-test/java/org/opentripplanner/ext/trias/service/OjpServiceTest.java @@ -6,8 +6,6 @@ import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; import java.time.Duration; -import java.time.Instant; -import java.time.LocalTime; import java.util.List; import java.util.Set; import org.junit.jupiter.api.Test; @@ -21,21 +19,24 @@ import org.opentripplanner.routing.graphfinder.PlaceAtDistance; import org.opentripplanner.routing.graphfinder.PlaceType; import org.opentripplanner.street.search.state.TestStateBuilder; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.basic.TransitMode; import org.opentripplanner.transit.model.framework.EntityNotFoundException; import org.opentripplanner.transit.model.framework.FeedScopedId; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.service.ArrivalDeparture; import org.opentripplanner.transit.service.TransitService; -import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.utils.time.TimeUtils; -class OjpServiceTest implements RealtimeTestConstants { +class OjpServiceTest { - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(); + + private static final String STOP_A_ID = "A"; + private static final String STOP_B_ID = "B"; + private static final String STOP_C_ID = "C"; + private static final String STATION_OMEGA_ID = "OMEGA"; private final RegularStop STOP_A = envBuilder.stopAtStation(STOP_A_ID, STATION_OMEGA_ID); private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); @@ -44,14 +45,11 @@ class OjpServiceTest implements RealtimeTestConstants { private final TripInput TRIP_INPUT = TripInput.of("t1") .addStop(STOP_A, "12:00", "12:01") .addStop(STOP_B, "12:10", "12:11") - .addStop(STOP_C, "12:20", "12:21") - .build(); - - public static final OjpService.StopEventRequestParams PARAMS = params(100); + .addStop(STOP_C, "12:20", "12:21"); - private static OjpService.StopEventRequestParams params(int departures) { + private OjpService.StopEventRequestParams params(TransitTestEnvironment env, int departures) { return new OjpService.StopEventRequestParams( - instant("12:00"), + env.localTimeParser().instant("12:00"), ArrivalDeparture.BOTH, Duration.ofHours(2), 1000, @@ -73,8 +71,8 @@ public static List stopPointRefCases() { @MethodSource("stopPointRefCases") void stopPointRef(FeedScopedId ref) { var env = envBuilder.addTrip(TRIP_INPUT).build(); - var service = new OjpService(env.getTransitService(), new DirectGraphFinder(e -> List.of())); - var result = service.findCallsAtStop(ref, PARAMS); + var service = new OjpService(env.transitService(), new DirectGraphFinder(e -> List.of())); + var result = service.findCallsAtStop(ref, params(env, 100)); assertThat(result).hasSize(1); var stopId = result.getFirst().tripTimeOnDate().getStop().getId(); assertEquals(STOP_A.getId(), stopId); @@ -83,9 +81,9 @@ void stopPointRef(FeedScopedId ref) { @Test void notFound() { var env = envBuilder.addTrip(TRIP_INPUT).build(); - var service = new OjpService(env.getTransitService(), new DirectGraphFinder(e -> List.of())); + var service = new OjpService(env.transitService(), new DirectGraphFinder(e -> List.of())); assertThrows(EntityNotFoundException.class, () -> - service.findCallsAtStop(id("unknown"), PARAMS) + service.findCallsAtStop(id("unknown"), params(env, 100)) ); } @@ -118,8 +116,8 @@ public List findClosestPlaces( } }; var env = envBuilder.addTrip(TRIP_INPUT).build(); - var service = new OjpService(env.getTransitService(), finder); - var result = service.findCallsAtStop(WgsCoordinate.GREENWICH, PARAMS); + var service = new OjpService(env.transitService(), finder); + var result = service.findCallsAtStop(WgsCoordinate.GREENWICH, params(env, 100)); assertThat(result).hasSize(1); var stopId = result.getFirst().tripTimeOnDate().getStop().getId(); assertEquals(STOP_A.getId(), stopId); @@ -128,14 +126,9 @@ public List findClosestPlaces( @Test void tooManyDepartures() { var env = envBuilder.addTrip(TRIP_INPUT).build(); - var service = new OjpService(env.getTransitService(), new DirectGraphFinder(e -> List.of())); + var service = new OjpService(env.transitService(), new DirectGraphFinder(e -> List.of())); assertThrows(IllegalArgumentException.class, () -> - service.findCallsAtStop(STOP_A.getId(), params(101)) + service.findCallsAtStop(STOP_A.getId(), params(env, 101)) ); } - - private static Instant instant(String time) { - var localTime = LocalTime.ofSecondOfDay(TimeUtils.time(time)); - return localTime.atDate(SERVICE_DATE).atZone(TIME_ZONE).toInstant(); - } } diff --git a/application/src/test/java/org/opentripplanner/DateTimeHelper.java b/application/src/test/java/org/opentripplanner/LocalTimeParser.java similarity index 51% rename from application/src/test/java/org/opentripplanner/DateTimeHelper.java rename to application/src/test/java/org/opentripplanner/LocalTimeParser.java index 2751af48daf..6843c9d369e 100644 --- a/application/src/test/java/org/opentripplanner/DateTimeHelper.java +++ b/application/src/test/java/org/opentripplanner/LocalTimeParser.java @@ -1,16 +1,23 @@ package org.opentripplanner; +import java.time.Instant; import java.time.LocalDate; +import java.time.LocalTime; import java.time.ZoneId; import java.time.ZonedDateTime; import org.opentripplanner.utils.time.DateUtils; +import org.opentripplanner.utils.time.TimeUtils; -public class DateTimeHelper { +/** + * A helper class used in tests for parsing local time strings into absolute times given a date and + * a timezone. + */ +public class LocalTimeParser { private final ZoneId zone; private final LocalDate defaultDate; - public DateTimeHelper(ZoneId zone, LocalDate defaultDate) { + public LocalTimeParser(ZoneId zone, LocalDate defaultDate) { this.zone = zone; this.defaultDate = defaultDate; } @@ -27,4 +34,13 @@ public ZonedDateTime zonedDateTime(String timeString) { } return defaultDate.atTime(time).atZone(zone); } + + /** + * Takes local time on different formats like "12:34:00" or "12:34" and returns the corresponding + * instant at the given date on the specific timezone. + */ + public Instant instant(String timeString) { + var localTime = LocalTime.ofSecondOfDay(TimeUtils.time(timeString)); + return localTime.atDate(defaultDate).atZone(zone).toInstant(); + } } diff --git a/application/src/test/java/org/opentripplanner/apis/gtfs/datafetchers/StopCallImplTest.java b/application/src/test/java/org/opentripplanner/apis/gtfs/datafetchers/StopCallImplTest.java index cd4ac4357f3..fec0d749152 100644 --- a/application/src/test/java/org/opentripplanner/apis/gtfs/datafetchers/StopCallImplTest.java +++ b/application/src/test/java/org/opentripplanner/apis/gtfs/datafetchers/StopCallImplTest.java @@ -3,7 +3,9 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import java.time.Instant; +import java.time.LocalDate; import java.time.OffsetDateTime; +import java.time.ZoneId; import java.util.Map; import org.junit.jupiter.api.Test; import org.opentripplanner.apis.gtfs.model.CallSchedule; @@ -11,46 +13,48 @@ import org.opentripplanner.apis.gtfs.model.CallScheduledTime.TimeWindow; import org.opentripplanner.framework.application.OTPFeature; import org.opentripplanner.model.TripTimeOnDate; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.AreaStop; import org.opentripplanner.transit.model.site.RegularStop; -import org.opentripplanner.updater.trip.FlexTripInput; -import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; import org.opentripplanner.utils.time.ServiceDateUtils; -class StopCallImplTest implements RealtimeTestConstants { +class StopCallImplTest { + private static final LocalDate SERVICE_DATE = LocalDate.of(2023, 6, 3); + private static final ZoneId TIME_ZONE = ZoneId.of("Europe/Paris"); private static final Instant MIDNIGHT = ServiceDateUtils.asStartOfService( SERVICE_DATE, TIME_ZONE ).toInstant(); - private static final OffsetDateTime NOON = OffsetDateTime.parse("2024-05-08T12:00+02:00"); + private static final String TRIP_ID = "Trip1"; + private static final String FLEX_TRIP_ID = "FlexTrip1"; + + private static final OffsetDateTime NOON = OffsetDateTime.parse("2023-06-03T12:00+02:00"); private static final OffsetDateTime TEN_AM = NOON.minusHours(2); - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); - private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); - private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); - private final RegularStop STOP_C = envBuilder.stop(STOP_C_ID); - private final AreaStop STOP_D = envBuilder.areaStop(STOP_D_ID); - private final AreaStop STOP_E = envBuilder.areaStop(STOP_E_ID); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(SERVICE_DATE); + private final RegularStop STOP_A = envBuilder.stop("A"); + private final RegularStop STOP_B = envBuilder.stop("B"); + private final RegularStop STOP_C = envBuilder.stop("C"); + private final AreaStop STOP_D = envBuilder.areaStop("D"); + private final AreaStop STOP_E = envBuilder.areaStop("E"); - private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) + private final TripInput TRIP_INPUT = TripInput.of(TRIP_ID) .addStop(STOP_A, "12:00:00", "12:00:00") .addStop(STOP_B, "12:30:00", "12:30:00") - .addStop(STOP_C, "13:00:00", "13:00:00") - .build(); + .addStop(STOP_C, "13:00:00", "13:00:00"); - private final FlexTripInput FLEX_TRIP_INPUT = FlexTripInput.of(TRIP_1_ID) + private final TripInput FLEX_TRIP_INPUT = TripInput.flex(FLEX_TRIP_ID) .addStop(STOP_D, "10:00", "10:30") - .addStop(STOP_E, "11:00", "11:30") - .build(); + .addStop(STOP_E, "11:00", "11:30"); @Test void fixedTrip() throws Exception { var realtimeEnv = envBuilder.addTrip(TRIP_INPUT).build(); - var tripTimes = realtimeEnv.getTripTimesForTrip(TRIP_1_ID); - var pattern = realtimeEnv.getPatternForTrip(TRIP_1_ID); + var tripData = realtimeEnv.tripData(TRIP_ID); + var tripTimes = tripData.tripTimes(); + var pattern = tripData.tripPattern(); var call = new TripTimeOnDate(tripTimes, 0, pattern, SERVICE_DATE, MIDNIGHT); @@ -58,7 +62,7 @@ void fixedTrip() throws Exception { var env = DataFetchingSupport.dataFetchingEnvironment( call, Map.of(), - realtimeEnv.getTransitService() + realtimeEnv.transitService() ); var schedule = impl.schedule().get(env); @@ -68,9 +72,10 @@ void fixedTrip() throws Exception { @Test void flexTrip() { OTPFeature.FlexRouting.testOn(() -> { - var realtimeEnv = envBuilder.addFlexTrip(FLEX_TRIP_INPUT).build(); - var tripTimes = realtimeEnv.getTripTimesForTrip(TRIP_1_ID); - var pattern = realtimeEnv.getPatternForTrip(TRIP_1_ID); + var realtimeEnv = envBuilder.addTrip(FLEX_TRIP_INPUT).build(); + var tripData = realtimeEnv.tripData(FLEX_TRIP_ID); + var tripTimes = tripData.tripTimes(); + var pattern = tripData.tripPattern(); var call = new TripTimeOnDate(tripTimes, 0, pattern, SERVICE_DATE, MIDNIGHT); @@ -78,7 +83,7 @@ void flexTrip() { var env = DataFetchingSupport.dataFetchingEnvironment( call, Map.of(), - realtimeEnv.getTransitService() + realtimeEnv.transitService() ); // using try-catch is not very nice here - ideally we would just add it to the method signature. diff --git a/application/src/test/java/org/opentripplanner/apis/gtfs/service/ApiTransitServiceTest.java b/application/src/test/java/org/opentripplanner/apis/gtfs/service/ApiTransitServiceTest.java index fbcfa6ff12f..95c53ec0ca1 100644 --- a/application/src/test/java/org/opentripplanner/apis/gtfs/service/ApiTransitServiceTest.java +++ b/application/src/test/java/org/opentripplanner/apis/gtfs/service/ApiTransitServiceTest.java @@ -1,7 +1,6 @@ package org.opentripplanner.apis.gtfs.service; import static com.google.common.truth.Truth.assertThat; -import static com.google.transit.realtime.GtfsRealtime.TripDescriptor.ScheduleRelationship.SCHEDULED; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; @@ -10,7 +9,9 @@ import com.google.transit.realtime.GtfsRealtime; import java.time.Duration; import java.time.Instant; +import java.time.LocalDate; import java.time.LocalTime; +import java.time.ZoneId; import java.time.ZonedDateTime; import java.util.List; import org.junit.jupiter.api.Test; @@ -18,12 +19,12 @@ import org.opentripplanner.model.plan.leg.ScheduledTransitLegBuilder; import org.opentripplanner.model.plan.leg.StreetLeg; import org.opentripplanner.street.search.TraverseMode; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.service.ArrivalDeparture; -import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.TripUpdateBuilder; /** @@ -34,25 +35,28 @@ *

* The core problem is that OTP doesn't have a clear internal API for applying real-time updates. */ -class ApiTransitServiceTest implements RealtimeTestConstants { +class ApiTransitServiceTest { + private static final LocalDate SERVICE_DATE = LocalDate.of(2024, 5, 8); + private static final ZoneId TIME_ZONE = ZoneId.of("Europe/Paris"); private static final ZonedDateTime ANY_TIME = ZonedDateTime.parse("2022-01-01T12:00:00+00:00"); - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); - private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); - private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); - private final RegularStop STOP_C = envBuilder.stop(STOP_C_ID); + private static final String TRIP_1_ID = "TestTrip1"; + private static final String TRIP_2_ID = "TestTrip2"; + + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(SERVICE_DATE); + private final RegularStop STOP_A = envBuilder.stop("A"); + private final RegularStop STOP_B = envBuilder.stop("B"); + private final RegularStop STOP_C = envBuilder.stop("C"); private final TripInput TRIP1_INPUT = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "12:00:00", "12:00:00") .addStop(STOP_B, "12:30:00", "12:30:00") - .addStop(STOP_C, "13:00:00", "13:00:00") - .build(); + .addStop(STOP_C, "13:00:00", "13:00:00"); private final TripInput TRIP2_INPUT = TripInput.of(TRIP_2_ID) .addStop(STOP_A, "12:10:00", "12:10:00") .addStop(STOP_B, "12:40:00", "12:40:00") - .addStop(STOP_C, "13:10:00", "13:10:00") - .build(); + .addStop(STOP_C, "13:10:00", "13:10:00"); public final Instant T11_59 = SERVICE_DATE.atTime(LocalTime.NOON.minusMinutes(1)) .atZone(TIME_ZONE) @@ -61,9 +65,9 @@ class ApiTransitServiceTest implements RealtimeTestConstants { @Test void justScheduledTrips() { var env = envBuilder.addTrip(TRIP1_INPUT).addTrip(TRIP2_INPUT).build(); - var service = new ApiTransitService(env.getTransitService()); + var service = new ApiTransitService(env.transitService()); - var pattern = env.getPatternForTrip(TRIP_1_ID); + var pattern = env.tripData(TRIP_1_ID).tripPattern(); var calls = service.getTripTimeOnDatesForPatternAtStopIncludingTripsWithSkippedStops( STOP_A, pattern, @@ -86,16 +90,21 @@ void justScheduledTrips() { @Test void skipStopInMultipleTripsInPattern() { var env = envBuilder.addTrip(TRIP1_INPUT).addTrip(TRIP2_INPUT).build(); - var res = env.applyTripUpdates( - List.of(skipSecondStop(TRIP_1_ID), skipSecondStop(TRIP_2_ID)), + var rt = GtfsRtTestHelper.of(env); + + var res = rt.applyTripUpdates( + List.of( + skipSecondStop(rt.tripUpdateScheduled(TRIP_1_ID)), + skipSecondStop(rt.tripUpdateScheduled(TRIP_2_ID)) + ), FULL_DATASET ); assertSuccess(res); - var transitService = env.getTransitService(); + var transitService = env.transitService(); var service = new ApiTransitService(transitService); var trip = transitService.getTrip(id(TRIP_1_ID)); - var scheduledPattern = env.getTransitService().findPattern(trip); + var scheduledPattern = env.transitService().findPattern(trip); var calls = service.getTripTimeOnDatesForPatternAtStopIncludingTripsWithSkippedStops( STOP_A, scheduledPattern, @@ -112,10 +121,11 @@ void skipStopInMultipleTripsInPattern() { @Test void transitLegCalls() { var env = envBuilder.addTrip(TRIP1_INPUT).build(); - var service = new ApiTransitService(env.getTransitService()); + var service = new ApiTransitService(env.transitService()); - var tripTimes = env.getTripTimesForTrip(TRIP_1_ID); - var pattern = env.getPatternForTrip(TRIP_1_ID); + var tripData = env.tripData(TRIP_1_ID); + var tripTimes = tripData.tripTimes(); + var pattern = tripData.tripPattern(); var leg = new ScheduledTransitLegBuilder() .withTripPattern(pattern) @@ -123,7 +133,7 @@ void transitLegCalls() { .withStartTime(ANY_TIME) .withEndTime(ANY_TIME) .withServiceDate(SERVICE_DATE) - .withZoneId(TIME_ZONE) + .withZoneId(env.timeZone()) .withDistanceMeters(1000) .withBoardStopIndexInPattern(0) .withAlightStopIndexInPattern(2) @@ -131,9 +141,9 @@ void transitLegCalls() { var calls = service.findStopCalls(leg); assertEquals( "[" + - "TripTimeOnDate{trip: Trip{F:TestTrip1 Rroute-1}, stopPosition: 0, arrival: 12:00, departure: 12:00, serviceDate: 2024-05-08}, " + - "TripTimeOnDate{trip: Trip{F:TestTrip1 Rroute-1}, stopPosition: 1, arrival: 12:30, departure: 12:30, serviceDate: 2024-05-08}, " + - "TripTimeOnDate{trip: Trip{F:TestTrip1 Rroute-1}, stopPosition: 2, arrival: 13:00, departure: 13:00, serviceDate: 2024-05-08}" + + "TripTimeOnDate{trip: Trip{F:TestTrip1 RRoute1}, stopPosition: 0, arrival: 12:00, departure: 12:00, serviceDate: 2024-05-08}, " + + "TripTimeOnDate{trip: Trip{F:TestTrip1 RRoute1}, stopPosition: 1, arrival: 12:30, departure: 12:30, serviceDate: 2024-05-08}, " + + "TripTimeOnDate{trip: Trip{F:TestTrip1 RRoute1}, stopPosition: 2, arrival: 13:00, departure: 13:00, serviceDate: 2024-05-08}" + "]", calls.toString() ); @@ -142,7 +152,7 @@ void transitLegCalls() { @Test void streetLegCalls() { var env = envBuilder.addTrip(TRIP1_INPUT).build(); - var service = new ApiTransitService(env.getTransitService()); + var service = new ApiTransitService(env.transitService()); var leg = StreetLeg.of() .withMode(TraverseMode.WALK) @@ -154,9 +164,7 @@ void streetLegCalls() { assertThat(calls).isEmpty(); } - private static GtfsRealtime.TripUpdate skipSecondStop(String tripId) { - return new TripUpdateBuilder(tripId, SERVICE_DATE, SCHEDULED, TIME_ZONE) - .addSkippedStop(1) - .build(); + private static GtfsRealtime.TripUpdate skipSecondStop(TripUpdateBuilder builder) { + return builder.addSkippedStop(1).build(); } } diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/FeedScopedIdForTestFactory.java b/application/src/test/java/org/opentripplanner/transit/model/_data/FeedScopedIdForTestFactory.java new file mode 100644 index 00000000000..cebb993844c --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/FeedScopedIdForTestFactory.java @@ -0,0 +1,12 @@ +package org.opentripplanner.transit.model._data; + +import org.opentripplanner.transit.model.framework.FeedScopedId; + +public class FeedScopedIdForTestFactory { + + public static final String FEED_ID = "F"; + + public static FeedScopedId id(String id) { + return new FeedScopedId(FEED_ID, id); + } +} diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/SiteRepositoryTestBuilder.java b/application/src/test/java/org/opentripplanner/transit/model/_data/SiteRepositoryTestBuilder.java new file mode 100644 index 00000000000..511a4451dc0 --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/SiteRepositoryTestBuilder.java @@ -0,0 +1,104 @@ +package org.opentripplanner.transit.model._data; + +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; + +import java.util.Optional; +import java.util.function.Consumer; +import org.locationtech.jts.geom.Coordinate; +import org.locationtech.jts.geom.Polygon; +import org.opentripplanner._support.geometry.Coordinates; +import org.opentripplanner.framework.geometry.GeometryUtils; +import org.opentripplanner.framework.geometry.WgsCoordinate; +import org.opentripplanner.framework.i18n.NonLocalizedString; +import org.opentripplanner.transit.model.site.AreaStop; +import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.transit.model.site.RegularStopBuilder; +import org.opentripplanner.transit.model.site.Station; +import org.opentripplanner.transit.model.site.StationBuilder; +import org.opentripplanner.transit.model.site.StopTransferPriority; +import org.opentripplanner.transit.service.SiteRepository; +import org.opentripplanner.transit.service.SiteRepositoryBuilder; + +/** + * Test helper for buliding site repository entities with default values + */ +public class SiteRepositoryTestBuilder { + + private final SiteRepositoryBuilder siteRepositoryBuilder; + + private static final WgsCoordinate ANY_COORDINATE = new WgsCoordinate(60.0, 10.0); + private static final Polygon ANY_POLYGON = GeometryUtils.getGeometryFactory() + .createPolygon( + new Coordinate[] { + Coordinates.of(61.0, 10.0), + Coordinates.of(61.0, 12.0), + Coordinates.of(60.0, 11.0), + Coordinates.of(61.0, 10.0), + } + ); + + public SiteRepositoryTestBuilder(SiteRepositoryBuilder siteRepositoryBuilder) { + this.siteRepositoryBuilder = siteRepositoryBuilder; + } + + public SiteRepository build() { + return siteRepositoryBuilder.build(); + } + + public RegularStop stop(String id) { + return stop(id, b -> {}); + } + + public RegularStop stop(String id, Consumer stopCustomizer) { + var builder = siteRepositoryBuilder + .regularStop(id(id)) + .withName(new NonLocalizedString(id)) + .withCode(id) + .withCoordinate(ANY_COORDINATE); + stopCustomizer.accept(builder); + var stop = builder.build(); + siteRepositoryBuilder.withRegularStop(stop); + return stop; + } + + /** + * Add a stop at a station. The station will be created if it does not already exist. + */ + public RegularStop stopAtStation(String stopId, String stationId) { + // Get or create station + final var station = Optional.ofNullable( + siteRepositoryBuilder.stationById().get(id(stationId)) + ).orElseGet(() -> station(stationId)); + + return stop(stopId, b -> b.withParentStation(station)); + } + + public AreaStop areaStop(String id) { + var stop = siteRepositoryBuilder + .areaStop(id(id)) + .withName(new NonLocalizedString(id)) + .withGeometry(ANY_POLYGON) + .build(); + siteRepositoryBuilder.withAreaStop(stop); + return stop; + } + + public Station station(String stationId) { + return station(stationId, b -> {}); + } + + public Station station(String stationId, Consumer customizer) { + var builder = Station.of(id(stationId)) + .withName(new NonLocalizedString(stationId)) + .withCode(stationId) + .withCoordinate(ANY_COORDINATE) + .withDescription(new NonLocalizedString("Station " + stationId)) + .withPriority(StopTransferPriority.ALLOWED); + if (customizer != null) { + customizer.accept(builder); + } + var station = builder.build(); + siteRepositoryBuilder.withStation(station); + return station; + } +} diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryForTest.java b/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryForTest.java index 15d96917052..1945de04f23 100644 --- a/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryForTest.java +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryForTest.java @@ -50,7 +50,10 @@ * withing the context of a SiteRepository, mixing more than one model in a test is sharing * state between tests. For now, it is just the stop index - but we want to * use this to encapsulate the SiteRepository completely. + * + * @deprecated This has been deprecated in favour of {@link TransitTestEnvironment} */ +@Deprecated public class TimetableRepositoryForTest { public static final String FEED_ID = "F"; diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryTestBuilder.java b/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryTestBuilder.java new file mode 100644 index 00000000000..0ef7aab67f5 --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/TimetableRepositoryTestBuilder.java @@ -0,0 +1,297 @@ +package org.opentripplanner.transit.model._data; + +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; + +import java.time.LocalDate; +import java.time.ZoneId; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import java.util.function.Consumer; +import java.util.stream.Collectors; +import org.opentripplanner.ext.flex.trip.UnscheduledTrip; +import org.opentripplanner.graph_builder.issue.api.DataImportIssueStore; +import org.opentripplanner.model.PickDrop; +import org.opentripplanner.model.calendar.CalendarServiceData; +import org.opentripplanner.transit.model.basic.TransitMode; +import org.opentripplanner.transit.model.framework.Deduplicator; +import org.opentripplanner.transit.model.framework.FeedScopedId; +import org.opentripplanner.transit.model.network.Route; +import org.opentripplanner.transit.model.network.RouteBuilder; +import org.opentripplanner.transit.model.network.StopPattern; +import org.opentripplanner.transit.model.network.TripPattern; +import org.opentripplanner.transit.model.organization.Agency; +import org.opentripplanner.transit.model.organization.AgencyBuilder; +import org.opentripplanner.transit.model.organization.Operator; +import org.opentripplanner.transit.model.organization.OperatorBuilder; +import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.transit.model.site.StopLocation; +import org.opentripplanner.transit.model.timetable.Trip; +import org.opentripplanner.transit.model.timetable.TripBuilder; +import org.opentripplanner.transit.model.timetable.TripOnServiceDate; +import org.opentripplanner.transit.model.timetable.TripTimes; +import org.opentripplanner.transit.model.timetable.TripTimesFactory; +import org.opentripplanner.transit.service.SiteRepository; +import org.opentripplanner.transit.service.TimetableRepository; + +/** + * A builder for timetable repository to simplify setting up timetable entities for tests + */ +public class TimetableRepositoryTestBuilder { + + private final List agencies = new ArrayList<>(); + private final List operators = new ArrayList<>(); + + private final List tripOnServiceDates = new ArrayList<>(); + private final List flexTrips = new ArrayList<>(); + + private final Map tripPatterns = new HashMap<>(); + private final Map serviceCodes = new HashMap<>(); + + private final Map scheduledStopPointMapping = new HashMap<>(); + + private final LocalDate defaultServiceDate; + private final ZoneId timeZone; + + private final Agency defaultAgency; + private final Route defaultRoute; + + TimetableRepositoryTestBuilder(ZoneId timeZone, LocalDate defaultServiceDate) { + this.timeZone = timeZone; + this.defaultServiceDate = defaultServiceDate; + + defaultAgency = agency("Agency1"); + defaultRoute = route("Route1"); + } + + public TimetableRepository build(SiteRepository siteRepository) { + var timetableRepository = new TimetableRepository(siteRepository, new Deduplicator()); + timetableRepository.initTimeZone(timeZone); + + for (var agency : agencies) { + timetableRepository.addAgency(agency); + } + + timetableRepository.addOperators(operators); + + for (TripPattern tripPattern : tripPatterns.values()) { + timetableRepository.addTripPattern(tripPattern.getId(), tripPattern); + } + + for (var flexTrip : flexTrips) { + timetableRepository.addFlexTrip(flexTrip.getId(), flexTrip); + } + + for (TripOnServiceDate tripOnServiceDate : tripOnServiceDates) { + timetableRepository.addTripOnServiceDate(tripOnServiceDate); + } + + var calendarServiceData = new CalendarServiceData(); + int serviceCodeCounter = 0; + for (var serviceCode : serviceCodes.values()) { + calendarServiceData.putServiceDatesForServiceId(serviceCode.id(), serviceCode.serviceDates()); + timetableRepository.getServiceCodes().put(serviceCode.id(), serviceCodeCounter); + serviceCodeCounter += 1; + } + timetableRepository.updateCalendarServiceData( + true, + calendarServiceData, + DataImportIssueStore.NOOP + ); + + timetableRepository + .getAllTripPatterns() + .forEach(pattern -> { + pattern.getScheduledTimetable().setServiceCodes(timetableRepository.getServiceCodes()); + }); + + timetableRepository + .getAllTripPatterns() + .forEach(pattern -> { + pattern.getScheduledTimetable().setServiceCodes(timetableRepository.getServiceCodes()); + }); + + timetableRepository.addScheduledStopPointMapping(scheduledStopPointMapping); + + timetableRepository.index(); + return timetableRepository; + } + + public Agency agency(String id) { + return agency(id, b -> {}); + } + + public Agency agency(String id, Consumer customizer) { + var builder = Agency.of(id(id)) + .withName("Agency Test") + .withTimezone(timeZone.getId()) + .withUrl("https://www." + id + ".com"); + if (customizer != null) { + customizer.accept(builder); + } + var agency = builder.build(); + agencies.add(agency); + return agency; + } + + public Route route(String id) { + return route(id, b -> {}); + } + + public Route route(String id, Consumer customizer) { + var builder = Route.of(id(id)) + .withAgency(defaultAgency) + .withShortName("R" + id) + .withMode(TransitMode.BUS); + if (customizer != null) { + customizer.accept(builder); + } + // Routes aren't stored explicitly in the timetable repository so we don't have a collection for these + return builder.build(); + } + + public Route route(String id, Operator operator) { + return route(id, builder -> builder.withOperator(operator)); + } + + public Operator operator(String operatorId) { + var operator = Operator.of(id(operatorId)).withName(operatorId + " name").build(); + operators.add(operator); + return operator; + } + + public Operator operator(String operatorId, Consumer customizer) { + var builder = Operator.of(id(operatorId)).withName(operatorId + " name"); + if (customizer != null) { + customizer.accept(builder); + } + var operator = builder.build(); + operators.add(operator); + return operator; + } + + public Trip trip(TripInput tripInput) { + return trip(tripInput, null); + } + + public Trip trip(TripInput tripInput, Consumer customizer) { + var serviceDates = Optional.ofNullable(tripInput.serviceDates()).orElse( + List.of(defaultServiceDate) + ); + + var serviceId = getOrCreateServiceId(serviceDates); + + var route = Optional.ofNullable(tripInput.route()).orElse(defaultRoute); + + var tripBuilder = Trip.of(id(tripInput.id())) + .withRoute(route) + .withHeadsign(tripInput.headsign()) + .withServiceId(serviceId); + if (customizer != null) { + customizer.accept(tripBuilder); + } + var trip = tripBuilder.build(); + + var stopPattern = stopPattern(tripInput.stopLocations()); + var tripPattern = getOrCreateTripPattern(stopPattern, route); + + var stopTimes = tripInput.stopTimes(trip); + var tripTimes = TripTimesFactory.tripTimes(trip, stopTimes, null); + + addTripTimesToPattern(tripPattern, tripTimes); + + if (tripInput.tripOnServiceDateId() != null) { + if (serviceDates.size() != 1) { + throw new IllegalArgumentException( + "Multiple service dates can't be used with TripOnServiceDate" + ); + } + addTripOnServiceDate(trip, serviceDates.getFirst(), tripInput.tripOnServiceDateId()); + } + + if (tripInput.isFlex()) { + var flexTrip = UnscheduledTrip.of(trip.getId()) + .withTrip(trip) + .withStopTimes(stopTimes) + .build(); + flexTrips.add(flexTrip); + } + + return trip; + } + + public TimetableRepositoryTestBuilder addScheduledStopPointMapping( + FeedScopedId scheduledStopPointId, + RegularStop stop + ) { + scheduledStopPointMapping.putAll(Map.of(scheduledStopPointId, stop)); + return this; + } + + private void addTripTimesToPattern(TripPattern tripPattern, TripTimes tripTimes) { + var newPattern = tripPattern + .copy() + .withScheduledTimeTableBuilder(b -> b.addTripTimes(tripTimes)) + .build(); + tripPatterns.put(TripPatternKey.of(newPattern), newPattern); + } + + private TripPattern getOrCreateTripPattern(StopPattern stopPattern, Route route) { + var key = new TripPatternKey(stopPattern, route); + var pattern = tripPatterns.get(key); + if (pattern != null) { + return pattern; + } + + var id = "Pattern" + (tripPatterns.size() + 1); + var newPattern = TripPattern.of(id(id)).withRoute(route).withStopPattern(stopPattern).build(); + tripPatterns.put(key, newPattern); + return newPattern; + } + + private FeedScopedId getOrCreateServiceId(List serviceDates) { + var key = serviceDates + .stream() + .map(LocalDate::toString) + .sorted() + .collect(Collectors.joining("|")); + var serviceCode = serviceCodes.get(key); + if (serviceCode != null) { + return serviceCode.id(); + } + + var newServiceCode = new ServiceCode(serviceDates, id(key)); + serviceCodes.put(key, newServiceCode); + return newServiceCode.id(); + } + + private void addTripOnServiceDate(Trip trip, LocalDate serviceDate, String id) { + var tripOnServiceDate = TripOnServiceDate.of(id(id)) + .withTrip(trip) + .withServiceDate(serviceDate) + .build(); + tripOnServiceDates.add(tripOnServiceDate); + } + + private static StopPattern stopPattern(List stops) { + var builder = StopPattern.create(stops.size()); + for (int i = 0; i < stops.size(); i++) { + builder.stops.with(i, stops.get(i)); + builder.pickups.with(i, PickDrop.SCHEDULED); + builder.dropoffs.with(i, PickDrop.SCHEDULED); + } + return builder.build(); + } + + // We use route and stopPattern as key for tripPattern. This isn't enough in general so we + // can extend it to more attributes from the trip pattern as needed. + private record TripPatternKey(StopPattern stopPattern, Route route) { + public static TripPatternKey of(TripPattern tripPattern) { + return new TripPatternKey(tripPattern.getStopPattern(), tripPattern.getRoute()); + } + } + + private record ServiceCode(List serviceDates, FeedScopedId id) {} +} diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/TransitTestEnvironment.java b/application/src/test/java/org/opentripplanner/transit/model/_data/TransitTestEnvironment.java new file mode 100644 index 00000000000..be2b3af3c6e --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/TransitTestEnvironment.java @@ -0,0 +1,110 @@ +package org.opentripplanner.transit.model._data; + +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; + +import java.time.LocalDate; +import java.time.ZoneId; +import org.opentripplanner.LocalTimeParser; +import org.opentripplanner.model.TimetableSnapshot; +import org.opentripplanner.transit.service.DefaultTransitService; +import org.opentripplanner.transit.service.TimetableRepository; +import org.opentripplanner.transit.service.TransitService; +import org.opentripplanner.updater.TimetableSnapshotParameters; +import org.opentripplanner.updater.trip.TimetableSnapshotManager; + +/** + * A helper class for setting up and interacting with transit data for tests. + *

+ * The builder is used to create a SiteRepository and a TimetableRepository that can then be queried + * by a TransitService. + */ +public final class TransitTestEnvironment { + + private final TimetableRepository timetableRepository; + private final TimetableSnapshotManager snapshotManager; + private final LocalDate defaultServiceDate; + + public static TransitTestEnvironmentBuilder of() { + return new TransitTestEnvironmentBuilder(ZoneId.of("Europe/Paris"), LocalDate.of(2024, 5, 7)); + } + + public static TransitTestEnvironmentBuilder of(LocalDate serviceDate) { + return new TransitTestEnvironmentBuilder(ZoneId.of("Europe/Paris"), serviceDate); + } + + public static TransitTestEnvironmentBuilder of(LocalDate serviceDate, ZoneId timeZone) { + return new TransitTestEnvironmentBuilder(timeZone, serviceDate); + } + + TransitTestEnvironment(TimetableRepository timetableRepository, LocalDate defaultServiceDate) { + this.timetableRepository = timetableRepository; + + this.timetableRepository.index(); + this.snapshotManager = new TimetableSnapshotManager( + null, + TimetableSnapshotParameters.PUBLISH_IMMEDIATELY, + () -> defaultServiceDate + ); + this.defaultServiceDate = defaultServiceDate; + } + + /** + * The default service date is the same as the date used by the builder when creating trips when + * no explicit date is specified. + */ + public LocalDate defaultServiceDate() { + return defaultServiceDate; + } + + /** + * Get the timezone of the timetable repository + */ + public ZoneId timeZone() { + return timetableRepository.getTimeZone(); + } + + /** + * Returns a new fresh TransitService + */ + public TransitService transitService() { + return new DefaultTransitService(timetableRepository, snapshotManager.getTimetableSnapshot()); + } + + public String feedId() { + return FeedScopedIdForTestFactory.FEED_ID; + } + + public TimetableRepository timetableRepository() { + return timetableRepository; + } + + public TimetableSnapshotManager timetableSnapshotManager() { + return snapshotManager; + } + + public TimetableSnapshot timetableSnapshot() { + return snapshotManager.getTimetableSnapshot(); + } + + /** + * A parser for converting local times into absolute times on the default service date in the + * TransitService timezone. + */ + public LocalTimeParser localTimeParser() { + return new LocalTimeParser(timetableRepository.getTimeZone(), defaultServiceDate); + } + + /** + * Get a data fetcher for the given trip id on the default ServiceDate + */ + public TripOnDateDataFetcher tripData(String tripId) { + return new TripOnDateDataFetcher(transitService(), id(tripId), defaultServiceDate); + } + + /** + * Get a data fetcher for the given trip id on the default ServiceDate + */ + public TripOnDateDataFetcher tripData(String tripId, LocalDate serviceDate) { + return new TripOnDateDataFetcher(transitService(), id(tripId), serviceDate); + } +} diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/TransitTestEnvironmentBuilder.java b/application/src/test/java/org/opentripplanner/transit/model/_data/TransitTestEnvironmentBuilder.java new file mode 100644 index 00000000000..8b15f8fe85b --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/TransitTestEnvironmentBuilder.java @@ -0,0 +1,124 @@ +package org.opentripplanner.transit.model._data; + +import java.time.LocalDate; +import java.time.ZoneId; +import java.util.Arrays; +import java.util.function.Consumer; +import org.opentripplanner.transit.model.framework.FeedScopedId; +import org.opentripplanner.transit.model.network.Route; +import org.opentripplanner.transit.model.network.RouteBuilder; +import org.opentripplanner.transit.model.organization.Operator; +import org.opentripplanner.transit.model.organization.OperatorBuilder; +import org.opentripplanner.transit.model.site.AreaStop; +import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.transit.model.site.RegularStopBuilder; +import org.opentripplanner.transit.model.site.Station; +import org.opentripplanner.transit.model.site.StationBuilder; +import org.opentripplanner.transit.model.timetable.TripBuilder; +import org.opentripplanner.transit.service.SiteRepository; + +public class TransitTestEnvironmentBuilder { + + private final SiteRepositoryTestBuilder site; + private final TimetableRepositoryTestBuilder timetable; + + private final LocalDate defaultServiceDate; + + TransitTestEnvironmentBuilder(ZoneId timeZone, LocalDate defaultServiceDate) { + this.defaultServiceDate = defaultServiceDate; + + site = new SiteRepositoryTestBuilder(SiteRepository.of()); + timetable = new TimetableRepositoryTestBuilder(timeZone, defaultServiceDate); + } + + public TransitTestEnvironment build() { + var siteRepository = site.build(); + var timetableRepository = timetable.build(siteRepository); + return new TransitTestEnvironment(timetableRepository, defaultServiceDate); + } + + /** + * The default service date is used when creating trips without an explicit service date + */ + public LocalDate defaultServiceDate() { + return defaultServiceDate; + } + + /* SITE ENTITIES */ + + public RegularStop stop(String id) { + return site.stop(id); + } + + public RegularStop stop(String id, Consumer customizer) { + return site.stop(id, customizer); + } + + public TransitTestEnvironmentBuilder addStops(String... stopIds) { + Arrays.stream(stopIds).forEach(site::stop); + return this; + } + + /** + * Add a stop at a station. The station will be created if it does not already exist. + */ + public RegularStop stopAtStation(String stopId, String stationId) { + return site.stopAtStation(stopId, stationId); + } + + public AreaStop areaStop(String id) { + return site.areaStop(id); + } + + public Station station(String id) { + return site.station(id); + } + + public Station station(String id, Consumer customizer) { + return site.station(id, customizer); + } + + /* TIMETABLE ENTITIES */ + + public TimetableRepositoryTestBuilder timetable() { + return timetable; + } + + public Route route(String routeId) { + return timetable.route(routeId); + } + + public Route route(String routeId, Operator operator) { + return timetable.route(routeId, operator); + } + + public Route route(String routeId, Consumer customizer) { + return timetable.route(routeId, customizer); + } + + public Operator operator(String operatorId) { + return timetable.operator(operatorId); + } + + public Operator operator(String operatorId, Consumer customizer) { + return timetable.operator(operatorId, customizer); + } + + public TransitTestEnvironmentBuilder addTrip(TripInput trip) { + timetable.trip(trip); + return this; + } + + public TransitTestEnvironmentBuilder addTrip(TripInput trip, Consumer consumer) { + timetable.trip(trip, consumer); + return this; + } + + public TransitTestEnvironmentBuilder addScheduledStopPointMapping( + FeedScopedId scheduledStopPointId, + RegularStop stop + ) { + timetable().addScheduledStopPointMapping(scheduledStopPointId, stop); + return this; + } +} diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/TripInput.java b/application/src/test/java/org/opentripplanner/transit/model/_data/TripInput.java new file mode 100644 index 00000000000..c3a29ddaf87 --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/TripInput.java @@ -0,0 +1,169 @@ +package org.opentripplanner.transit.model._data; + +import java.time.LocalDate; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.IntStream; +import javax.annotation.Nullable; +import org.opentripplanner.framework.i18n.I18NString; +import org.opentripplanner.model.StopTime; +import org.opentripplanner.transit.model.network.Route; +import org.opentripplanner.transit.model.site.AreaStop; +import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.transit.model.site.StopLocation; +import org.opentripplanner.transit.model.timetable.Trip; +import org.opentripplanner.utils.collection.ListUtils; +import org.opentripplanner.utils.time.TimeUtils; + +/** + * A simple data structure that is used by the {@link TransitTestEnvironment} to create + * trips, trips on date and patterns. + */ +public class TripInput { + + private final String id; + private final List stops = new ArrayList<>(); + + // Null means use the default route + @Nullable + private Route route; + + // Null means use default service date + @Nullable + private List serviceDates = null; + + @Nullable + private I18NString headsign; + + @Nullable + private String tripOnServiceDateId; + + private final boolean isFlex; + + private TripInput(String id, boolean isFlex) { + this.id = id; + this.isFlex = isFlex; + } + + public static TripInput of(String id) { + return new TripInput(id, false); + } + + public static TripInput flex(String id) { + return new TripInput(id, true); + } + + public String id() { + return id; + } + + public List stopTimes(Trip trip) { + return IntStream.range(0, stops.size()) + .mapToObj(i -> stops.get(i).toStopTime(trip, i)) + .toList(); + } + + public List stopLocations() { + return stops.stream().map(StopCallInput::stopLocation).toList(); + } + + @Nullable + public I18NString headsign() { + return headsign; + } + + @Nullable + public List serviceDates() { + return serviceDates; + } + + @Nullable + public Route route() { + return route; + } + + @Nullable + public String tripOnServiceDateId() { + return tripOnServiceDateId; + } + + public boolean isFlex() { + return isFlex; + } + + public TripInput addStop(RegularStop stop, String arrivalTime, String departureTime) { + stops.add( + new RegularStopCallInput(stop, TimeUtils.time(arrivalTime), TimeUtils.time(departureTime)) + ); + return this; + } + + public TripInput addStop(RegularStop stopId, String arrivalAndDeparture) { + return addStop(stopId, arrivalAndDeparture, arrivalAndDeparture); + } + + public TripInput addStop(AreaStop stop, String windowStart, String windowEnd) { + stops.add(new FlexStopCallInput(stop, TimeUtils.time(windowStart), TimeUtils.time(windowEnd))); + return this; + } + + public TripInput withRoute(Route route) { + this.route = route; + return this; + } + + public TripInput withHeadsign(I18NString headsign) { + this.headsign = headsign; + return this; + } + + public TripInput withServiceDates(LocalDate... serviceDates) { + var list = Arrays.stream(serviceDates).toList(); + ListUtils.requireAtLeastNElements(list, 1); + this.serviceDates = list; + return this; + } + + public TripInput withWithTripOnServiceDate(String tripOnServiceDateId) { + this.tripOnServiceDateId = tripOnServiceDateId; + return this; + } + + private interface StopCallInput { + StopTime toStopTime(Trip trip, int stopSequence); + StopLocation stopLocation(); + } + + private record RegularStopCallInput(RegularStop stop, int arrivalTime, int departureTime) + implements StopCallInput { + public StopTime toStopTime(Trip trip, int stopSequence) { + var st = new StopTime(); + st.setTrip(trip); + st.setStopSequence(stopSequence); + st.setStop(stop); + st.setArrivalTime(arrivalTime); + st.setDepartureTime(departureTime); + return st; + } + public StopLocation stopLocation() { + return stop; + } + } + + private record FlexStopCallInput(AreaStop stop, int windowStart, int windowEnd) + implements StopCallInput { + public StopTime toStopTime(Trip trip, int stopSequence) { + var st = new StopTime(); + st.setTrip(trip); + st.setStopSequence(stopSequence); + st.setStop(stop); + st.setFlexWindowStart(windowStart); + st.setFlexWindowEnd(windowEnd); + return st; + } + public StopLocation stopLocation() { + return stop; + } + } +} diff --git a/application/src/test/java/org/opentripplanner/transit/model/_data/TripOnDateDataFetcher.java b/application/src/test/java/org/opentripplanner/transit/model/_data/TripOnDateDataFetcher.java new file mode 100644 index 00000000000..5e165d49190 --- /dev/null +++ b/application/src/test/java/org/opentripplanner/transit/model/_data/TripOnDateDataFetcher.java @@ -0,0 +1,91 @@ +package org.opentripplanner.transit.model._data; + +import java.time.LocalDate; +import org.opentripplanner.transit.model.framework.FeedScopedId; +import org.opentripplanner.transit.model.network.TripPattern; +import org.opentripplanner.transit.model.timetable.RealTimeState; +import org.opentripplanner.transit.model.timetable.Trip; +import org.opentripplanner.transit.model.timetable.TripTimes; +import org.opentripplanner.transit.model.timetable.TripTimesStringBuilder; +import org.opentripplanner.transit.service.TransitService; + +/** + * A convenience class for fetching data for a trip on a specific service date. It acts as a thin + * layer on top of the TransitService. + */ +public class TripOnDateDataFetcher { + + private final FeedScopedId tripId; + private final TransitService transitService; + private final LocalDate serviceDate; + + // The trip is lazily initialized when needed + private Trip trip; + + public TripOnDateDataFetcher( + TransitService transitService, + FeedScopedId tripId, + LocalDate serviceDate + ) { + this.tripId = tripId; + this.transitService = transitService; + this.serviceDate = serviceDate; + } + + public Trip trip() { + if (trip != null) { + return trip; + } + trip = transitService.getTrip(tripId); + return trip; + } + + /** + * Get the TripPattern for the given trip on date. Returns the realtime updated pattern if it + * exists and otherwise the scheduled. + */ + public TripPattern tripPattern() { + return transitService.findPattern(trip(), serviceDate); + } + + /** + * Get the scheduled tripPattern for the given trip + */ + public TripPattern scheduledTripPattern() { + return transitService.findPattern(trip()); + } + + /** + * Get realtime TripTimes for the trip on the date + */ + public TripTimes tripTimes() { + var timetable = transitService.findTimetable(tripPattern(), serviceDate); + return timetable.getTripTimes(trip()); + } + + /** + * Get scheduled TripTimes for the trip + */ + public TripTimes scheduledTripTimes() { + var timetable = scheduledTripPattern().getScheduledTimetable(); + return timetable.getTripTimes(trip()); + } + + public RealTimeState realTimeState() { + return tripTimes().getRealTimeState(); + } + + /** + * Get a string representation of the realtime tripTimes + */ + public String showTimetable() { + return TripTimesStringBuilder.encodeTripTimes(tripTimes(), tripPattern()); + } + + /** + * Get a string representation of the scheduled tripTimes + */ + public String showScheduledTimetable() { + return TripTimesStringBuilder.encodeTripTimes(scheduledTripTimes(), scheduledTripPattern()); + } +} diff --git a/application/src/test/java/org/opentripplanner/transit/service/TripTimesOnDateTest.java b/application/src/test/java/org/opentripplanner/transit/service/TripTimesOnDateTest.java index 05a00c0ae21..3cdb3bf2a46 100644 --- a/application/src/test/java/org/opentripplanner/transit/service/TripTimesOnDateTest.java +++ b/application/src/test/java/org/opentripplanner/transit/service/TripTimesOnDateTest.java @@ -4,54 +4,50 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import java.time.Duration; -import java.time.Instant; -import java.time.LocalTime; +import java.time.LocalDate; import java.util.List; import org.junit.jupiter.api.Test; import org.opentripplanner.transit.api.request.TripTimeOnDateRequest; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; -import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.utils.time.TimeUtils; -public class TripTimesOnDateTest implements RealtimeTestConstants { +public class TripTimesOnDateTest { - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); + private static final LocalDate SERVICE_DATE = LocalDate.of(2025, 3, 3); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(SERVICE_DATE); - private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); - private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); - private final RegularStop STOP_C = envBuilder.stop(STOP_C_ID); - private final RegularStop STOP_D = envBuilder.stop(STOP_D_ID); - private final RegularStop STOP_E = envBuilder.stop(STOP_E_ID); - private final RegularStop STOP_F = envBuilder.stop(STOP_F_ID); + private final RegularStop STOP_A = envBuilder.stop("A"); + private final RegularStop STOP_B = envBuilder.stop("B"); + private final RegularStop STOP_C = envBuilder.stop("C"); + private final RegularStop STOP_D = envBuilder.stop("D"); + private final RegularStop STOP_E = envBuilder.stop("E"); + private final RegularStop STOP_F = envBuilder.stop("F"); private final TripInput TRIP_INPUT1 = TripInput.of("t1") .withServiceDates(SERVICE_DATE, SERVICE_DATE.plusDays(1)) .addStop(STOP_A, "12:00", "12:01") .addStop(STOP_B, "12:10", "12:11") - .addStop(STOP_C, "12:20", "12:21") - .build(); + .addStop(STOP_C, "12:20", "12:21"); private final TripInput TRIP_INPUT2 = TripInput.of("t2") .withServiceDates(SERVICE_DATE, SERVICE_DATE.plusDays(1)) .addStop(STOP_D, "12:00", "12:01") .addStop(STOP_E, "12:10", "12:11") - .addStop(STOP_F, "12:20", "12:21") - .build(); + .addStop(STOP_F, "12:20", "12:21"); private final TripInput TRIP_INPUT3 = TripInput.of("t3") .withServiceDates(SERVICE_DATE, SERVICE_DATE.plusDays(1)) .addStop(STOP_F, "12:15", "12:15") - .addStop(STOP_E, "12:20", "12:20") - .build(); + .addStop(STOP_E, "12:20", "12:20"); @Test void onFirstStop() { var env = envBuilder.addTrip(TRIP_INPUT1).addTrip(TRIP_INPUT2).build(); - var transitService = env.getTransitService(); + var transitService = env.transitService(); + var dt = env.localTimeParser(); - var instant = instant("12:00"); + var instant = dt.instant("12:00"); { var result = transitService.findTripTimesOnDate( TripTimeOnDateRequest.of(List.of(STOP_A)).withTime(instant).build() @@ -59,7 +55,7 @@ void onFirstStop() { assertThat(result).hasSize(1); var tt = result.getFirst(); - assertEquals(instant("12:01"), tt.scheduledDeparture()); + assertEquals(dt.instant("12:01"), tt.scheduledDeparture()); } { var result = transitService.findTripTimesOnDate( @@ -67,30 +63,33 @@ void onFirstStop() { ); assertThat(result).hasSize(1); var tt = result.getFirst(); - assertEquals(instant("12:11"), tt.scheduledDeparture()); + assertEquals(dt.instant("12:11"), tt.scheduledDeparture()); } } @Test void nextDay() { var env = envBuilder.addTrip(TRIP_INPUT1).addTrip(TRIP_INPUT2).build(); - var transitService = env.getTransitService(); + var transitService = env.transitService(); + var dt = env.localTimeParser(); - var instant = instant("12:00").plus(Duration.ofDays(1)); + var instant = dt.instant("12:00").plus(Duration.ofDays(1)); var result = transitService.findTripTimesOnDate( TripTimeOnDateRequest.of(List.of(STOP_A)).withTime(instant).build() ); assertThat(result).hasSize(1); var tt = result.getFirst(); - assertEquals(instant("12:01").plus(Duration.ofDays(1)), tt.scheduledDeparture()); + assertEquals(dt.instant("12:01").plus(Duration.ofDays(1)), tt.scheduledDeparture()); } @Test void tooLate() { - var transitService = envBuilder.addTrip(TRIP_INPUT1).build().getTransitService(); + var env = envBuilder.addTrip(TRIP_INPUT1).build(); + var transitService = env.transitService(); + var dt = env.localTimeParser(); - var instant = instant("18:00"); + var instant = dt.instant("18:00"); var result = transitService.findTripTimesOnDate( TripTimeOnDateRequest.of(List.of(STOP_A)).withTime(instant).build() ); @@ -99,9 +98,11 @@ void tooLate() { @Test void shortWindow() { - var transitService = envBuilder.addTrip(TRIP_INPUT1).build().getTransitService(); + var env = envBuilder.addTrip(TRIP_INPUT1).build(); + var transitService = env.transitService(); + var dt = env.localTimeParser(); - var instant = instant("11:00"); + var instant = dt.instant("11:00"); var result = transitService.findTripTimesOnDate( TripTimeOnDateRequest.of(List.of(STOP_A)) .withTime(instant) @@ -113,9 +114,11 @@ void shortWindow() { @Test void longerWindow() { - var transitService = envBuilder.addTrip(TRIP_INPUT1).build().getTransitService(); + var env = envBuilder.addTrip(TRIP_INPUT1).build(); + var transitService = env.transitService(); + var dt = env.localTimeParser(); - var instant = instant("11:00"); + var instant = dt.instant("11:00"); var result = transitService.findTripTimesOnDate( TripTimeOnDateRequest.of(List.of(STOP_A)) .withTime(instant) @@ -127,13 +130,11 @@ void longerWindow() { @Test void several() { - var transitService = envBuilder - .addTrip(TRIP_INPUT2) - .addTrip(TRIP_INPUT3) - .build() - .getTransitService(); + var env = envBuilder.addTrip(TRIP_INPUT2).addTrip(TRIP_INPUT3).build(); + var transitService = env.transitService(); + var dt = env.localTimeParser(); - var instant = instant("12:10"); + var instant = dt.instant("12:10"); var result = transitService.findTripTimesOnDate( TripTimeOnDateRequest.of(List.of(STOP_F)) .withTime(instant) @@ -142,9 +143,4 @@ void several() { ); assertThat(result).hasSize(2); } - - private static Instant instant(String time) { - var localTime = LocalTime.ofSecondOfDay(TimeUtils.time(time)); - return localTime.atDate(SERVICE_DATE).atZone(TIME_ZONE).toInstant(); - } } diff --git a/application/src/test/java/org/opentripplanner/updater/GtfsRealtimeFuzzyTripMatcherTest.java b/application/src/test/java/org/opentripplanner/updater/GtfsRealtimeFuzzyTripMatcherTest.java index 0d820805254..0fe87c9c150 100644 --- a/application/src/test/java/org/opentripplanner/updater/GtfsRealtimeFuzzyTripMatcherTest.java +++ b/application/src/test/java/org/opentripplanner/updater/GtfsRealtimeFuzzyTripMatcherTest.java @@ -2,80 +2,38 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; import com.google.transit.realtime.GtfsRealtime.TripDescriptor; import java.time.LocalDate; -import java.util.List; -import org.junit.jupiter.api.BeforeAll; import org.junit.jupiter.api.Nested; import org.junit.jupiter.api.Test; -import org.opentripplanner.graph_builder.issue.api.DataImportIssueStore; -import org.opentripplanner.model.calendar.CalendarServiceData; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; -import org.opentripplanner.transit.model.framework.Deduplicator; -import org.opentripplanner.transit.model.framework.FeedScopedId; +import org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.network.Route; -import org.opentripplanner.transit.model.network.TripPattern; import org.opentripplanner.transit.model.site.RegularStop; -import org.opentripplanner.transit.model.timetable.Trip; -import org.opentripplanner.transit.model.timetable.TripTimes; -import org.opentripplanner.transit.model.timetable.TripTimesFactory; -import org.opentripplanner.transit.service.DefaultTransitService; -import org.opentripplanner.transit.service.SiteRepository; -import org.opentripplanner.transit.service.SiteRepositoryBuilder; -import org.opentripplanner.transit.service.TimetableRepository; import org.opentripplanner.updater.trip.gtfs.GtfsRealtimeFuzzyTripMatcher; public class GtfsRealtimeFuzzyTripMatcherTest { private static final String ROUTE_ID = "r1"; - private static final String FEED_ID = TimetableRepositoryForTest.FEED_ID; + private static final String FEED_ID = FeedScopedIdForTestFactory.FEED_ID; private static final LocalDate SERVICE_DATE = LocalDate.of(2024, 11, 13); private static final String GTFS_SERVICE_DATE = SERVICE_DATE.toString().replaceAll("-", ""); - private static final int SERVICE_CODE = 555; - private static final SiteRepositoryBuilder siteRepositoryBuilder = SiteRepository.of(); - private static final TimetableRepositoryForTest TEST_MODEL = new TimetableRepositoryForTest( - siteRepositoryBuilder - ); - private static final RegularStop STOP_1 = TEST_MODEL.stop("s1").build(); - private static final RegularStop STOP_2 = TEST_MODEL.stop("s2").build(); - private static final TimetableRepository TIMETABLE_REPOSITORY = new TimetableRepository( - siteRepositoryBuilder.build(), - new Deduplicator() - ); - private static final Route ROUTE = TimetableRepositoryForTest.route(id(ROUTE_ID)).build(); private static final String TRIP_ID = "t1"; - private static final Trip TRIP = TimetableRepositoryForTest.trip(TRIP_ID).build(); - - private static final FeedScopedId SERVICE_ID = TimetableRepositoryForTest.id("sid1"); private static final String START_TIME = "07:30:00"; - private static final TripTimes TRIP_TIMES = TripTimesFactory.tripTimes( - TRIP, - TEST_MODEL.stopTimesEvery5Minutes(5, TRIP, START_TIME), - new Deduplicator() - ).withServiceCode(SERVICE_CODE); - private static final TripPattern TRIP_PATTERN = TimetableRepositoryForTest.tripPattern( - "tp1", - ROUTE - ) - .withStopPattern(TimetableRepositoryForTest.stopPattern(STOP_1, STOP_2)) - .withScheduledTimeTableBuilder(builder -> builder.addTripTimes(TRIP_TIMES)) - .build(); - @BeforeAll - static void setup() { - CalendarServiceData calendarServiceData = new CalendarServiceData(); - calendarServiceData.putServiceDatesForServiceId(SERVICE_ID, List.of(SERVICE_DATE)); - TIMETABLE_REPOSITORY.addTripPattern(TRIP_PATTERN.getId(), TRIP_PATTERN); - TIMETABLE_REPOSITORY.getServiceCodes().put(SERVICE_ID, SERVICE_CODE); - TIMETABLE_REPOSITORY.updateCalendarServiceData( - true, - calendarServiceData, - DataImportIssueStore.NOOP - ); - TIMETABLE_REPOSITORY.index(); - } + private final TransitTestEnvironmentBuilder builder = TransitTestEnvironment.of(SERVICE_DATE); + private final RegularStop STOP_1 = builder.stop("s1"); + private final RegularStop STOP_2 = builder.stop("s2"); + private final Route ROUTE_A = builder.route(ROUTE_ID); + + private final TransitTestEnvironment env = builder + .addTrip( + TripInput.of(TRIP_ID).withRoute(ROUTE_A).addStop(STOP_1, START_TIME).addStop(STOP_2, "08:00") + ) + .build(); @Test void noTripId() { @@ -167,8 +125,8 @@ void noStartTime() { } } - private static GtfsRealtimeFuzzyTripMatcher matcher() { - return new GtfsRealtimeFuzzyTripMatcher(new DefaultTransitService(TIMETABLE_REPOSITORY)); + private GtfsRealtimeFuzzyTripMatcher matcher() { + return new GtfsRealtimeFuzzyTripMatcher(env.transitService()); } private static TripDescriptor.Builder matchingTripUpdate() { diff --git a/application/src/test/java/org/opentripplanner/updater/trip/FlexTripInput.java b/application/src/test/java/org/opentripplanner/updater/trip/FlexTripInput.java deleted file mode 100644 index ff714d4db7b..00000000000 --- a/application/src/test/java/org/opentripplanner/updater/trip/FlexTripInput.java +++ /dev/null @@ -1,41 +0,0 @@ -package org.opentripplanner.updater.trip; - -import java.util.ArrayList; -import java.util.List; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; -import org.opentripplanner.transit.model.network.Route; -import org.opentripplanner.transit.model.site.StopLocation; -import org.opentripplanner.utils.time.TimeUtils; - -public record FlexTripInput(String id, List stops) { - public record FlexStop(StopLocation stop, int windowStart, int windowEnd) { - public FlexStop(StopLocation stop, String windowStart, String windowEnd) { - this(stop, TimeUtils.time(windowStart), TimeUtils.time(windowEnd)); - } - } - public Route route() { - return TimetableRepositoryForTest.route("route-1").build(); - } - - public static FlexTripInputBuilder of(String id) { - return new FlexTripInputBuilder(id); - } - public static class FlexTripInputBuilder { - - private final String id; - private final List stops = new ArrayList<>(); - - FlexTripInputBuilder(String id) { - this.id = id; - } - - public FlexTripInputBuilder addStop(StopLocation stop, String windowStart, String windowEnd) { - this.stops.add(new FlexStop(stop, TimeUtils.time(windowStart), TimeUtils.time(windowEnd))); - return this; - } - - public FlexTripInput build() { - return new FlexTripInput(id, stops); - } - } -} diff --git a/application/src/test/java/org/opentripplanner/updater/trip/GtfsRtTestHelper.java b/application/src/test/java/org/opentripplanner/updater/trip/GtfsRtTestHelper.java new file mode 100644 index 00000000000..d1c4e5899a9 --- /dev/null +++ b/application/src/test/java/org/opentripplanner/updater/trip/GtfsRtTestHelper.java @@ -0,0 +1,77 @@ +package org.opentripplanner.updater.trip; + +import static org.opentripplanner.updater.trip.UpdateIncrementality.FULL_DATASET; + +import com.google.transit.realtime.GtfsRealtime; +import java.util.List; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.updater.spi.UpdateResult; +import org.opentripplanner.updater.trip.gtfs.BackwardsDelayPropagationType; +import org.opentripplanner.updater.trip.gtfs.ForwardsDelayPropagationType; +import org.opentripplanner.updater.trip.gtfs.GtfsRealTimeTripUpdateAdapter; + +public class GtfsRtTestHelper { + + private final TransitTestEnvironment transitTestEnvironment; + private final GtfsRealTimeTripUpdateAdapter gtfsAdapter; + + GtfsRtTestHelper(TransitTestEnvironment transitTestEnvironment) { + this.transitTestEnvironment = transitTestEnvironment; + this.gtfsAdapter = new GtfsRealTimeTripUpdateAdapter( + transitTestEnvironment.timetableRepository(), + transitTestEnvironment.timetableSnapshotManager(), + () -> transitTestEnvironment.defaultServiceDate() + ); + } + + public static GtfsRtTestHelper of(TransitTestEnvironment transitTestEnvironment) { + return new GtfsRtTestHelper(transitTestEnvironment); + } + + public TripUpdateBuilder tripUpdateScheduled(String tripId) { + return tripUpdate(tripId, GtfsRealtime.TripDescriptor.ScheduleRelationship.SCHEDULED); + } + + public TripUpdateBuilder tripUpdate( + String tripId, + GtfsRealtime.TripDescriptor.ScheduleRelationship scheduleRelationship + ) { + return new TripUpdateBuilder( + tripId, + transitTestEnvironment.defaultServiceDate(), + scheduleRelationship, + transitTestEnvironment.timeZone() + ); + } + + public UpdateResult applyTripUpdate(GtfsRealtime.TripUpdate update) { + return applyTripUpdates(List.of(update), FULL_DATASET); + } + + public UpdateResult applyTripUpdate( + GtfsRealtime.TripUpdate update, + UpdateIncrementality incrementality + ) { + return applyTripUpdates(List.of(update), incrementality); + } + + public UpdateResult applyTripUpdates( + List updates, + UpdateIncrementality incrementality + ) { + UpdateResult updateResult = gtfsAdapter.applyTripUpdates( + null, + ForwardsDelayPropagationType.DEFAULT, + BackwardsDelayPropagationType.REQUIRED_NO_DATA, + incrementality, + updates, + transitTestEnvironment.feedId() + ); + commitTimetableSnapshot(); + return updateResult; + } + + private void commitTimetableSnapshot() { + transitTestEnvironment.timetableSnapshotManager().purgeAndCommit(); + } +} diff --git a/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestConstants.java b/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestConstants.java index 6fab8813900..7e0a1868d10 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestConstants.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestConstants.java @@ -1,13 +1,6 @@ package org.opentripplanner.updater.trip; -import java.time.LocalDate; -import java.time.ZoneId; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; - public interface RealtimeTestConstants { - LocalDate SERVICE_DATE = LocalDate.of(2024, 5, 8); - ZoneId TIME_ZONE = ZoneId.of(TimetableRepositoryForTest.TIME_ZONE_ID); - String TRIP_1_ID = "TestTrip1"; String TRIP_2_ID = "TestTrip2"; String ADDED_TRIP_ID = "AddedTrip"; @@ -17,6 +10,4 @@ public interface RealtimeTestConstants { String STOP_B_ID = "B"; String STOP_C_ID = "C"; String STOP_D_ID = "D"; - String STOP_E_ID = "E"; - String STOP_F_ID = "F"; } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestEnvironment.java b/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestEnvironment.java deleted file mode 100644 index 76e14d9ef92..00000000000 --- a/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestEnvironment.java +++ /dev/null @@ -1,215 +0,0 @@ -package org.opentripplanner.updater.trip; - -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; -import static org.opentripplanner.updater.trip.UpdateIncrementality.DIFFERENTIAL; -import static org.opentripplanner.updater.trip.UpdateIncrementality.FULL_DATASET; - -import com.google.transit.realtime.GtfsRealtime; -import java.time.LocalDate; -import java.time.ZoneId; -import java.util.List; -import java.util.Objects; -import org.opentripplanner.DateTimeHelper; -import org.opentripplanner.model.TimetableSnapshot; -import org.opentripplanner.routing.graph.Graph; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; -import org.opentripplanner.transit.model.framework.FeedScopedId; -import org.opentripplanner.transit.model.network.TripPattern; -import org.opentripplanner.transit.model.site.RegularStop; -import org.opentripplanner.transit.model.timetable.TripTimes; -import org.opentripplanner.transit.model.timetable.TripTimesStringBuilder; -import org.opentripplanner.transit.service.DefaultTransitService; -import org.opentripplanner.transit.service.TimetableRepository; -import org.opentripplanner.transit.service.TransitService; -import org.opentripplanner.updater.DefaultRealTimeUpdateContext; -import org.opentripplanner.updater.TimetableSnapshotParameters; -import org.opentripplanner.updater.spi.UpdateResult; -import org.opentripplanner.updater.trip.gtfs.BackwardsDelayPropagationType; -import org.opentripplanner.updater.trip.gtfs.ForwardsDelayPropagationType; -import org.opentripplanner.updater.trip.gtfs.GtfsRealTimeTripUpdateAdapter; -import org.opentripplanner.updater.trip.siri.SiriRealTimeTripUpdateAdapter; -import org.opentripplanner.updater.trip.siri.updater.EstimatedTimetableHandler; -import uk.org.siri.siri21.EstimatedTimetableDeliveryStructure; - -/** - * This class exists so that you can share the data building logic for GTFS and Siri tests. - */ -public final class RealtimeTestEnvironment { - - private final TimetableRepository timetableRepository; - private final TimetableSnapshotManager snapshotManager; - private final SiriRealTimeTripUpdateAdapter siriAdapter; - private final GtfsRealTimeTripUpdateAdapter gtfsAdapter; - private final DateTimeHelper dateTimeHelper; - private final LocalDate serviceDate; - - public static RealtimeTestEnvironmentBuilder of() { - return new RealtimeTestEnvironmentBuilder(); - } - - RealtimeTestEnvironment( - TimetableRepository timetableRepository, - LocalDate defaultServiceDate, - ZoneId zoneId - ) { - this.timetableRepository = timetableRepository; - - this.timetableRepository.index(); - this.snapshotManager = new TimetableSnapshotManager( - null, - TimetableSnapshotParameters.PUBLISH_IMMEDIATELY, - () -> defaultServiceDate - ); - siriAdapter = new SiriRealTimeTripUpdateAdapter(timetableRepository, snapshotManager); - gtfsAdapter = new GtfsRealTimeTripUpdateAdapter(timetableRepository, snapshotManager, () -> - defaultServiceDate - ); - dateTimeHelper = new DateTimeHelper(zoneId, defaultServiceDate); - this.serviceDate = defaultServiceDate; - } - - /** - * Returns a new fresh TransitService - */ - public TransitService getTransitService() { - return new DefaultTransitService(timetableRepository, snapshotManager.getTimetableSnapshot()); - } - - /** - * Find the current TripTimes for a trip id on a serviceDate - */ - public TripTimes getTripTimesForTrip(FeedScopedId tripId, LocalDate serviceDate) { - var transitService = getTransitService(); - var trip = transitService.getTripOnServiceDate(tripId).getTrip(); - var pattern = transitService.findPattern(trip, serviceDate); - var timetable = transitService.findTimetable(pattern, serviceDate); - return timetable.getTripTimes(trip); - } - - public String getFeedId() { - return TimetableRepositoryForTest.FEED_ID; - } - - public RegularStop getStop(String id) { - return Objects.requireNonNull(timetableRepository.getSiteRepository().getRegularStop(id(id))); - } - - private EstimatedTimetableHandler getEstimatedTimetableHandler(boolean fuzzyMatching) { - return new EstimatedTimetableHandler(siriAdapter, fuzzyMatching, getFeedId()); - } - - public TripPattern getPatternForTrip(FeedScopedId tripId) { - return getPatternForTrip(tripId, serviceDate); - } - - public TripPattern getPatternForTrip(String id) { - return getPatternForTrip(id(id)); - } - - public TripPattern getPatternForTrip(FeedScopedId tripId, LocalDate serviceDate) { - var transitService = getTransitService(); - var trip = transitService.getTripOnServiceDate(tripId); - return transitService.findPattern(trip.getTrip(), serviceDate); - } - - /** - * Find the current TripTimes for a trip id on the default serviceDate - */ - public TripTimes getTripTimesForTrip(String id) { - return getTripTimesForTrip(id(id), serviceDate); - } - - public DateTimeHelper getDateTimeHelper() { - return dateTimeHelper; - } - - public TimetableSnapshot getTimetableSnapshot() { - return snapshotManager.getTimetableSnapshot(); - } - - public String getRealtimeTimetable(String tripId) { - return getRealtimeTimetable(id(tripId), serviceDate); - } - - public String getRealtimeTimetable(FeedScopedId tripId, LocalDate serviceDate) { - var tt = getTripTimesForTrip(tripId, serviceDate); - var pattern = getPatternForTrip(tripId); - - return TripTimesStringBuilder.encodeTripTimes(tt, pattern); - } - - public String getScheduledTimetable(String tripId) { - return getScheduledTimetable(id(tripId)); - } - - public String getScheduledTimetable(FeedScopedId tripId) { - var pattern = getPatternForTrip(tripId); - var tt = pattern.getScheduledTimetable().getTripTimes(tripId); - - return TripTimesStringBuilder.encodeTripTimes(tt, pattern); - } - - // SIRI updates - - public UpdateResult applyEstimatedTimetableWithFuzzyMatcher( - List updates - ) { - return applyEstimatedTimetable(updates, true); - } - - public UpdateResult applyEstimatedTimetable(List updates) { - return applyEstimatedTimetable(updates, false); - } - - // GTFS-RT updates - - public UpdateResult applyTripUpdate(GtfsRealtime.TripUpdate update) { - return applyTripUpdates(List.of(update), FULL_DATASET); - } - - public UpdateResult applyTripUpdate( - GtfsRealtime.TripUpdate update, - UpdateIncrementality incrementality - ) { - return applyTripUpdates(List.of(update), incrementality); - } - - public UpdateResult applyTripUpdates( - List updates, - UpdateIncrementality incrementality - ) { - UpdateResult updateResult = gtfsAdapter.applyTripUpdates( - null, - ForwardsDelayPropagationType.DEFAULT, - BackwardsDelayPropagationType.REQUIRED_NO_DATA, - incrementality, - updates, - getFeedId() - ); - commitTimetableSnapshot(); - return updateResult; - } - - // private methods - - private UpdateResult applyEstimatedTimetable( - List updates, - boolean fuzzyMatching - ) { - UpdateResult updateResult = getEstimatedTimetableHandler(fuzzyMatching).applyUpdate( - updates, - DIFFERENTIAL, - new DefaultRealTimeUpdateContext( - new Graph(), - timetableRepository, - snapshotManager.getTimetableSnapshotBuffer() - ) - ); - commitTimetableSnapshot(); - return updateResult; - } - - private void commitTimetableSnapshot() { - snapshotManager.purgeAndCommit(); - } -} diff --git a/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestEnvironmentBuilder.java b/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestEnvironmentBuilder.java deleted file mode 100644 index a851ce70432..00000000000 --- a/application/src/test/java/org/opentripplanner/updater/trip/RealtimeTestEnvironmentBuilder.java +++ /dev/null @@ -1,291 +0,0 @@ -package org.opentripplanner.updater.trip; - -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; -import static org.opentripplanner.updater.trip.RealtimeTestConstants.SERVICE_DATE; -import static org.opentripplanner.updater.trip.RealtimeTestConstants.TIME_ZONE; - -import java.time.LocalDate; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.HashMap; -import java.util.List; -import java.util.Map; -import java.util.concurrent.atomic.AtomicInteger; -import java.util.stream.Collectors; -import java.util.stream.IntStream; -import org.opentripplanner.ext.flex.trip.UnscheduledTrip; -import org.opentripplanner.framework.i18n.I18NString; -import org.opentripplanner.graph_builder.issue.api.DataImportIssueStore; -import org.opentripplanner.model.StopTime; -import org.opentripplanner.model.calendar.CalendarServiceData; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; -import org.opentripplanner.transit.model.framework.Deduplicator; -import org.opentripplanner.transit.model.framework.FeedScopedId; -import org.opentripplanner.transit.model.network.Route; -import org.opentripplanner.transit.model.network.StopPattern; -import org.opentripplanner.transit.model.site.AreaStop; -import org.opentripplanner.transit.model.site.RegularStop; -import org.opentripplanner.transit.model.site.Station; -import org.opentripplanner.transit.model.site.StopLocation; -import org.opentripplanner.transit.model.timetable.Trip; -import org.opentripplanner.transit.model.timetable.TripOnServiceDate; -import org.opentripplanner.transit.model.timetable.TripTimes; -import org.opentripplanner.transit.model.timetable.TripTimesFactory; -import org.opentripplanner.transit.service.TimetableRepository; -import org.opentripplanner.updater.trip.FlexTripInput.FlexStop; - -public class RealtimeTestEnvironmentBuilder { - - private final TimetableRepositoryForTest testModel = TimetableRepositoryForTest.of(); - private final List stops = new ArrayList<>(); - private final HashMap stations = new HashMap<>(); - private final List tripInputs = new ArrayList<>(); - private final List flexTripInputs = new ArrayList<>(); - private final Map scheduledStopPointMapping = new HashMap<>(); - private final AtomicInteger serviceCodeCounter = new AtomicInteger(); - - RealtimeTestEnvironmentBuilder() {} - - public RealtimeTestEnvironmentBuilder addTrip(TripInput trip) { - this.tripInputs.add(trip); - return this; - } - - public RealtimeTestEnvironment build() { - for (var stop : stops) { - switch (stop) { - case RegularStop rs -> testModel.siteRepositoryBuilder().withRegularStop(rs); - case AreaStop as -> testModel.siteRepositoryBuilder().withAreaStop(as); - default -> throw new IllegalStateException("Unexpected value: " + stop); - } - } - for (var station : stations.values()) { - testModel.siteRepositoryBuilder().withStation(station); - } - var timetableRepository = new TimetableRepository( - testModel.siteRepositoryBuilder().build(), - new Deduplicator() - ); - - CalendarServiceData calendarServiceData = new CalendarServiceData(); - for (TripInput tripInput : tripInputs) { - var t = createTrip(tripInput, timetableRepository); - calendarServiceData.putServiceDatesForServiceId(t.getServiceId(), tripInput.serviceDates()); - } - for (FlexTripInput tripInput : flexTripInputs) { - createFlexTrip(tripInput, timetableRepository); - } - - timetableRepository.initTimeZone(TIME_ZONE); - timetableRepository.addAgency(TimetableRepositoryForTest.AGENCY); - - timetableRepository.updateCalendarServiceData( - true, - calendarServiceData, - DataImportIssueStore.NOOP - ); - timetableRepository - .getAllTripPatterns() - .forEach(pattern -> { - pattern.getScheduledTimetable().setServiceCodes(timetableRepository.getServiceCodes()); - }); - - timetableRepository - .getAllTripPatterns() - .forEach(pattern -> { - pattern.getScheduledTimetable().setServiceCodes(timetableRepository.getServiceCodes()); - }); - - timetableRepository.addScheduledStopPointMapping(scheduledStopPointMapping); - - timetableRepository.index(); - return new RealtimeTestEnvironment(timetableRepository, SERVICE_DATE, TIME_ZONE); - } - - public RealtimeTestEnvironmentBuilder withStops(String... stopIds) { - this.stops.addAll(Arrays.stream(stopIds).map(id -> testModel.stop(id).build()).toList()); - return this; - } - - public RegularStop stop(String id) { - var stop = testModel.stop(id).build(); - stops.add(stop); - return stop; - } - - public RegularStop stopAtStation(String stopId, String stationId) { - var dflt = testModel.station(stationId).build(); - var station = stations.getOrDefault(stationId, dflt); - var stop = testModel.stop(stopId).withParentStation(station).build(); - - stops.add(stop); - stations.put(stationId, station); - return stop; - } - - public AreaStop areaStop(String id) { - var stop = testModel.areaStop(id).build(); - stops.add(stop); - return stop; - } - - public RealtimeTestEnvironmentBuilder addFlexTrip(FlexTripInput tripInput) { - flexTripInputs.add(tripInput); - return this; - } - - public RealtimeTestEnvironmentBuilder addScheduledStopPointMapping( - Map mapping - ) { - scheduledStopPointMapping.putAll(mapping); - return this; - } - - private Trip createTrip(TripInput tripInput, TimetableRepository timetableRepository) { - var serviceId = generateServiceId(timetableRepository, tripInput.serviceDates()); - var trip = Trip.of(id(tripInput.id())) - .withRoute(tripInput.route()) - .withHeadsign(tripInput.headsign() == null ? null : tripInput.headsign()) - .withServiceId(serviceId) - .build(); - - addTripOnServiceDate(timetableRepository, trip); - - if (tripInput.route().getOperator() != null) { - timetableRepository.addOperators(List.of(tripInput.route().getOperator())); - } - - var stopTimes = IntStream.range(0, tripInput.stops().size()) - .mapToObj(i -> { - var stop = tripInput.stops().get(i); - return fixedStopTime(trip, i, stop.stop(), stop.arrivalTime(), stop.departureTime()); - }) - .toList(); - - TripTimes tripTimes = TripTimesFactory.tripTimes(trip, stopTimes, null); - - var stopPattern = TimetableRepositoryForTest.stopPattern( - tripInput.stops().stream().map(TripInput.StopCall::stop).toList() - ); - - var existingPatterns = timetableRepository - .getAllTripPatterns() - .stream() - .filter(p -> p.getStopPattern().equals(stopPattern)) - .toList(); - - if (existingPatterns.size() > 1) { - throw new RuntimeException( - "Multiple patterns found for stop pattern %s. This indicates an error during test setup.".formatted( - stopPattern - ) - ); - } else if (existingPatterns.size() == 1) { - var pattern = existingPatterns.getFirst(); - var newPattern = pattern - .copy() - .withScheduledTimeTableBuilder(b -> b.addTripTimes(tripTimes)) - .build(); - timetableRepository.addTripPattern(pattern.getId(), newPattern); - } else { - addNewPattern(tripInput.id(), tripInput.route(), stopPattern, tripTimes, timetableRepository); - } - - return trip; - } - - private FeedScopedId generateServiceId( - TimetableRepository timetableRepository, - List localDates - ) { - var serviceId = id( - localDates.stream().map(LocalDate::toString).collect(Collectors.joining("|")) - ); - timetableRepository.getServiceCodes().put(serviceId, serviceCodeCounter.getAndIncrement()); - return serviceId; - } - - private Trip createFlexTrip(FlexTripInput tripInput, TimetableRepository timetableRepository) { - var serviceId = generateServiceId(timetableRepository, List.of(SERVICE_DATE)); - final var trip = Trip.of(TimetableRepositoryForTest.id(tripInput.id())) - .withRoute(tripInput.route()) - .withHeadsign(I18NString.of("Headsign of %s".formatted(tripInput.id()))) - .withServiceId(serviceId) - .build(); - addTripOnServiceDate(timetableRepository, trip); - - var stopTimes = IntStream.range(0, tripInput.stops().size()) - .mapToObj(i -> { - var stop = tripInput.stops().get(i); - return flexStopTime(trip, i, stop.stop(), stop.windowStart(), stop.windowEnd()); - }) - .toList(); - - TripTimes tripTimes = TripTimesFactory.tripTimes(trip, stopTimes, null); - - var stopPattern = TimetableRepositoryForTest.stopPattern( - tripInput.stops().stream().map(FlexStop::stop).toList() - ); - - addNewPattern(tripInput.id(), tripInput.route(), stopPattern, tripTimes, timetableRepository); - var flexTrip = UnscheduledTrip.of(trip.getId()).withTrip(trip).withStopTimes(stopTimes).build(); - timetableRepository.addFlexTrip(flexTrip.getId(), flexTrip); - return trip; - } - - private static void addNewPattern( - String tripInput, - Route tripInput1, - StopPattern stopPattern, - TripTimes tripTimes, - TimetableRepository timetableRepository - ) { - var pattern = TimetableRepositoryForTest.tripPattern(tripInput + "Pattern", tripInput1) - .withStopPattern(stopPattern) - .withScheduledTimeTableBuilder(builder -> builder.addTripTimes(tripTimes)) - .build(); - - timetableRepository.addTripPattern(pattern.getId(), pattern); - } - - private static void addTripOnServiceDate(TimetableRepository timetableRepository, Trip trip) { - var tripOnServiceDate = TripOnServiceDate.of(trip.getId()) - .withTrip(trip) - .withServiceDate(SERVICE_DATE) - .build(); - - timetableRepository.addTripOnServiceDate(tripOnServiceDate); - } - - private static StopTime fixedStopTime( - Trip trip, - int stopSequence, - StopLocation stop, - int arrivalTime, - int departureTime - ) { - var st = new StopTime(); - st.setTrip(trip); - st.setStopSequence(stopSequence); - st.setStop(stop); - st.setArrivalTime(arrivalTime); - st.setDepartureTime(departureTime); - return st; - } - - private static StopTime flexStopTime( - Trip trip, - int stopSequence, - StopLocation stop, - int windowStart, - int windowEnd - ) { - var st = new StopTime(); - st.setTrip(trip); - st.setStopSequence(stopSequence); - st.setStop(stop); - st.setFlexWindowStart(windowStart); - st.setFlexWindowEnd(windowEnd); - return st; - } -} diff --git a/application/src/test/java/org/opentripplanner/updater/trip/SiriTestHelper.java b/application/src/test/java/org/opentripplanner/updater/trip/SiriTestHelper.java new file mode 100644 index 00000000000..6bd5b74d872 --- /dev/null +++ b/application/src/test/java/org/opentripplanner/updater/trip/SiriTestHelper.java @@ -0,0 +1,78 @@ +package org.opentripplanner.updater.trip; + +import static org.opentripplanner.updater.trip.UpdateIncrementality.DIFFERENTIAL; + +import java.util.List; +import org.opentripplanner.routing.graph.Graph; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.updater.DefaultRealTimeUpdateContext; +import org.opentripplanner.updater.spi.UpdateResult; +import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.siri.SiriRealTimeTripUpdateAdapter; +import org.opentripplanner.updater.trip.siri.updater.EstimatedTimetableHandler; +import uk.org.siri.siri21.EstimatedTimetableDeliveryStructure; + +public class SiriTestHelper { + + private final TransitTestEnvironment transitTestEnvironment; + private final SiriRealTimeTripUpdateAdapter siriAdapter; + + SiriTestHelper(TransitTestEnvironment transitTestEnvironment) { + this.transitTestEnvironment = transitTestEnvironment; + this.siriAdapter = new SiriRealTimeTripUpdateAdapter( + transitTestEnvironment.timetableRepository(), + transitTestEnvironment.timetableSnapshotManager() + ); + } + + public static SiriTestHelper of(TransitTestEnvironment transitTestEnvironment) { + return new SiriTestHelper(transitTestEnvironment); + } + + public SiriEtBuilder etBuilder() { + return new SiriEtBuilder(transitTestEnvironment.localTimeParser()); + } + + public UpdateResult applyEstimatedTimetableWithFuzzyMatcher( + List updates + ) { + return applyEstimatedTimetable(updates, true); + } + + public UpdateResult applyEstimatedTimetable(List updates) { + return applyEstimatedTimetable(updates, false); + } + + public TransitTestEnvironment realtimeTestEnvironment() { + return transitTestEnvironment; + } + + private UpdateResult applyEstimatedTimetable( + List updates, + boolean fuzzyMatching + ) { + UpdateResult updateResult = getEstimatedTimetableHandler(fuzzyMatching).applyUpdate( + updates, + DIFFERENTIAL, + new DefaultRealTimeUpdateContext( + new Graph(), + transitTestEnvironment.timetableRepository(), + transitTestEnvironment.timetableSnapshotManager().getTimetableSnapshotBuffer() + ) + ); + commitTimetableSnapshot(); + return updateResult; + } + + private EstimatedTimetableHandler getEstimatedTimetableHandler(boolean fuzzyMatching) { + return new EstimatedTimetableHandler( + siriAdapter, + fuzzyMatching, + transitTestEnvironment.feedId() + ); + } + + private void commitTimetableSnapshot() { + transitTestEnvironment.timetableSnapshotManager().purgeAndCommit(); + } +} diff --git a/application/src/test/java/org/opentripplanner/updater/trip/TripInput.java b/application/src/test/java/org/opentripplanner/updater/trip/TripInput.java deleted file mode 100644 index bb35be9eef9..00000000000 --- a/application/src/test/java/org/opentripplanner/updater/trip/TripInput.java +++ /dev/null @@ -1,102 +0,0 @@ -package org.opentripplanner.updater.trip; - -import static org.opentripplanner.updater.trip.RealtimeTestConstants.SERVICE_DATE; - -import java.time.LocalDate; -import java.util.ArrayList; -import java.util.Arrays; -import java.util.List; -import javax.annotation.Nullable; -import org.opentripplanner.framework.i18n.I18NString; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; -import org.opentripplanner.transit.model.network.Route; -import org.opentripplanner.transit.model.organization.Operator; -import org.opentripplanner.transit.model.site.RegularStop; -import org.opentripplanner.transit.model.site.StopLocation; -import org.opentripplanner.utils.collection.ListUtils; -import org.opentripplanner.utils.time.TimeUtils; - -/** - * A simple data structure that is used by the {@link RealtimeTestEnvironment} to create - * trips, trips on date and patterns. - */ -public record TripInput( - String id, - Route route, - List stops, - List serviceDates, - @Nullable I18NString headsign -) { - public static TripInputBuilder of(String id) { - return new TripInputBuilder(id); - } - - /** - * The ID of the route without the feed ID prefix. - */ - public String routeId() { - return route.getId().getId(); - } - - /** - * The ID of the operator without the feed ID prefix. - */ - public String operatorId() { - return route.getOperator().getId().getId(); - } - - public static class TripInputBuilder { - - private final String id; - private final List stops = new ArrayList<>(); - // can be made configurable if needed - private Route route = TimetableRepositoryForTest.route("route-1") - .withOperator( - Operator.of(TimetableRepositoryForTest.id("operator-1")).withName("Operator 1").build() - ) - .build(); - - private List serviceDates = List.of(SERVICE_DATE); - - @Nullable - private I18NString headsign; - - TripInputBuilder(String id) { - this.id = id; - } - - public TripInputBuilder addStop(RegularStop stopId, String arrivalTime, String departureTime) { - this.stops.add( - new StopCall(stopId, TimeUtils.time(arrivalTime), TimeUtils.time(departureTime)) - ); - return this; - } - - public TripInputBuilder addStop(RegularStop stopId, String arrivalAndDeparture) { - return addStop(stopId, arrivalAndDeparture, arrivalAndDeparture); - } - - public TripInput build() { - return new TripInput(id, route, stops, serviceDates, headsign); - } - - public TripInputBuilder withRoute(Route route) { - this.route = route; - return this; - } - - public TripInputBuilder withHeadsign(I18NString headsign) { - this.headsign = headsign; - return this; - } - - public TripInputBuilder withServiceDates(LocalDate... serviceDates) { - var list = Arrays.stream(serviceDates).toList(); - ListUtils.requireAtLeastNElements(list, 1); - this.serviceDates = list; - return this; - } - } - - record StopCall(StopLocation stop, int arrivalTime, int departureTime) {} -} diff --git a/application/src/test/java/org/opentripplanner/updater/trip/TripUpdateBuilder.java b/application/src/test/java/org/opentripplanner/updater/trip/TripUpdateBuilder.java index 71c4d58608a..7d996f2ef31 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/TripUpdateBuilder.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/TripUpdateBuilder.java @@ -39,23 +39,6 @@ public TripUpdateBuilder( this.midnight = ServiceDateUtils.asStartOfService(serviceDate, zoneId); } - public TripUpdateBuilder( - String tripId, - LocalDate serviceDate, - GtfsRealtime.TripDescriptor.ScheduleRelationship scheduleRelationship, - ZoneId zoneId, - String tripHeadsign, - String tripShortName - ) { - this(tripId, serviceDate, scheduleRelationship, zoneId); - tripUpdateBuilder.setTripProperties( - GtfsRealtime.TripUpdate.TripProperties.newBuilder() - .setTripHeadsign(tripHeadsign) - .setTripShortName(tripShortName) - .build() - ); - } - public TripUpdateBuilder addStopTime(String stopId, String time) { return addStopTime( stopId, @@ -355,4 +338,14 @@ public TripUpdateBuilder addTripExtension() { return this; } + + public TripUpdateBuilder withTripProperties(String tripHeadsign, String tripShortName) { + tripUpdateBuilder.setTripProperties( + GtfsRealtime.TripUpdate.TripProperties.newBuilder() + .setTripHeadsign(tripHeadsign) + .setTripShortName(tripShortName) + .build() + ); + return this; + } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedOnServiceDateTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedOnServiceDateTest.java index d4e88fd6bd3..3d219c3ec4f 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedOnServiceDateTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedOnServiceDateTest.java @@ -3,7 +3,6 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.transit.realtime.GtfsRealtime.TripDescriptor.ScheduleRelationship.NEW; import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; import static org.opentripplanner.updater.spi.UpdateError.UpdateErrorType.OUTSIDE_SERVICE_PERIOD; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; @@ -12,25 +11,26 @@ import java.util.List; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; import org.opentripplanner.updater.trip.TripUpdateBuilder; class AddedOnServiceDateTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(); private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); private final RegularStop STOP_C = envBuilder.stop(STOP_C_ID); - private static final LocalDate START_DATE = SERVICE_DATE; + private static final LocalDate START_DATE = LocalDate.of(2025, 7, 1); private static final LocalDate ADDED_DATE = START_DATE.plusDays(1); private static final LocalDate END_DATE = START_DATE.plusDays(2); - private final RealtimeTestEnvironment env = envBuilder + private final TransitTestEnvironment env = envBuilder .addTrip( TripInput.of(TRIP_1_ID) // on either side of added date, but not on it @@ -38,9 +38,9 @@ class AddedOnServiceDateTest implements RealtimeTestConstants { .addStop(STOP_A, "12:00") .addStop(STOP_B, "12:10") .addStop(STOP_C, "12:20") - .build() ) .build(); + private final GtfsRtTestHelper rt = GtfsRtTestHelper.of(env); private static List serviceDates() { return List.of(START_DATE, ADDED_DATE, END_DATE); @@ -49,18 +49,19 @@ private static List serviceDates() { @ParameterizedTest @MethodSource("serviceDates") void addedTrip(LocalDate date) { - var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, date, NEW, TIME_ZONE) + var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, date, NEW, env.timeZone()) .addStopTime(STOP_A_ID, "10:30") .addStopTime(STOP_B_ID, "10:40") .addStopTime(STOP_C_ID, "10:55") .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); - assertNotNull(env.getPatternForTrip(id(ADDED_TRIP_ID), date)); + assertSuccess(rt.applyTripUpdate(tripUpdate)); + var tripFetcher = env.tripData(ADDED_TRIP_ID, date); + assertNotNull(tripFetcher.tripPattern()); - var trip = env.getTripTimesForTrip(id(ADDED_TRIP_ID), date).getTrip(); + var trip = tripFetcher.trip(); var dates = env - .getTransitService() + .transitService() .getCalendarService() .getServiceDatesForServiceId(trip.getServiceId()); assertThat(dates).containsExactly(date); @@ -73,12 +74,12 @@ private static List outsidePeriod() { @ParameterizedTest @MethodSource("outsidePeriod") void rejectOutsideSchedulePeriod(LocalDate date) { - var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, date, NEW, TIME_ZONE) + var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, date, NEW, env.timeZone()) .addStopTime(STOP_A_ID, "10:30") .addStopTime(STOP_B_ID, "10:40") .addStopTime(STOP_C_ID, "10:55") .build(); - assertFailure(OUTSIDE_SERVICE_PERIOD, env.applyTripUpdate(tripUpdate)); + assertFailure(OUTSIDE_SERVICE_PERIOD, rt.applyTripUpdate(tripUpdate)); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedTest.java index 8ba2f2a29b3..77b8310f7f2 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/AddedTest.java @@ -5,11 +5,10 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertSame; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import de.mfdz.MfdzRealtimeExtensions.StopTimePropertiesExtension.DropOffPickupType; @@ -18,63 +17,67 @@ import org.junit.jupiter.api.Test; import org.opentripplanner.framework.i18n.I18NString; import org.opentripplanner.model.PickDrop; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.basic.TransitMode; import org.opentripplanner.transit.model.network.TripPattern; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.timetable.RealTimeState; -import org.opentripplanner.transit.model.timetable.Trip; import org.opentripplanner.transit.service.TransitService; import org.opentripplanner.updater.spi.UpdateSuccess; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; import org.opentripplanner.updater.trip.TripUpdateBuilder; import org.opentripplanner.utils.time.TimeUtils; class AddedTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(); private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); private final RegularStop STOP_C = envBuilder.stop(STOP_C_ID); - private final RealtimeTestEnvironment env = envBuilder + private final TransitTestEnvironment env = envBuilder .addTrip( TripInput.of(TRIP_1_ID) // just to set the schedule period - .withServiceDates(SERVICE_DATE.minusDays(1), SERVICE_DATE.plusDays(1)) + .withServiceDates( + envBuilder.defaultServiceDate().minusDays(1), + envBuilder.defaultServiceDate().plusDays(1) + ) .addStop(STOP_A, "12:00", "12:00") .addStop(STOP_B, "12:10", "12:10") .addStop(STOP_C, "12:20", "12:20") - .build() ) - .withStops(STOP_A_ID, STOP_B_ID, STOP_C_ID, STOP_D_ID) + .addStops(STOP_A_ID, STOP_B_ID, STOP_C_ID, STOP_D_ID) .build(); + private final GtfsRtTestHelper gtfsRt = GtfsRtTestHelper.of(env); @Test void addedTrip() { - var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, SERVICE_DATE, ADDED, TIME_ZONE) + var tripUpdate = gtfsRt + .tripUpdate(ADDED_TRIP_ID, ADDED) .addStopTime(STOP_A_ID, "00:30") .addStopTime(STOP_B_ID, "00:40") .addStopTime(STOP_C_ID, "00:55") .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); + assertSuccess(gtfsRt.applyTripUpdate(tripUpdate)); assertAddedTrip(ADDED_TRIP_ID, env); } @Test void addedTripWithNewRoute() { - var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, SERVICE_DATE, ADDED, TIME_ZONE) + var tripUpdate = gtfsRt + .tripUpdate(ADDED_TRIP_ID, ADDED) .addTripExtension() .addStopTime(STOP_A_ID, "00:30", DropOffPickupType.PHONE_AGENCY) .addStopTime(STOP_B_ID, "00:40", COORDINATE_WITH_DRIVER) .addStopTime(STOP_B_ID, "00:55", DropOffPickupType.NONE) .build(); - var result = env.applyTripUpdate(tripUpdate); + var result = gtfsRt.applyTripUpdate(tripUpdate); assertSuccess(result); assertTrue(result.warnings().isEmpty()); @@ -85,7 +88,7 @@ void addedTripWithNewRoute() { assertEquals(TripUpdateBuilder.ROUTE_NAME, route.getName()); assertEquals(TransitMode.RAIL, route.getMode()); - TransitService transitService = env.getTransitService(); + TransitService transitService = env.transitService(); var fromTimetableRepository = transitService.getRoute(route.getId()); assertEquals(fromTimetableRepository, route); var patternsForRoute = transitService.findPatterns(route); @@ -101,7 +104,8 @@ void addedTripWithNewRoute() { @Test void addedWithUnknownStop() { - var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, SERVICE_DATE, ADDED, TIME_ZONE) + var tripUpdate = gtfsRt + .tripUpdate(ADDED_TRIP_ID, ADDED) // add extension to set route name, url, mode .addTripExtension() .addStopTime(STOP_A_ID, "00:30", DropOffPickupType.PHONE_AGENCY) @@ -109,7 +113,7 @@ void addedWithUnknownStop() { .addStopTime(STOP_C_ID, "00:55", DropOffPickupType.NONE) .build(); - var result = env.applyTripUpdate(tripUpdate); + var result = gtfsRt.applyTripUpdate(tripUpdate); assertSuccess(result); assertEquals( @@ -124,7 +128,8 @@ void addedWithUnknownStop() { @Test void repeatedlyAddedTripWithNewRoute() { - var tripUpdate = new TripUpdateBuilder(ADDED_TRIP_ID, SERVICE_DATE, ADDED, TIME_ZONE) + var tripUpdate = gtfsRt + .tripUpdate(ADDED_TRIP_ID, ADDED) // add extension to set route name, url, mode .addTripExtension() .addStopTime(STOP_A_ID, "00:30", DropOffPickupType.PHONE_AGENCY) @@ -132,38 +137,32 @@ void repeatedlyAddedTripWithNewRoute() { .addStopTime(STOP_C_ID, "00:55", DropOffPickupType.NONE) .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); + assertSuccess(gtfsRt.applyTripUpdate(tripUpdate)); var pattern = assertAddedTrip(ADDED_TRIP_ID, env); var firstRoute = pattern.getRoute(); // apply the update a second time to check that no new route instance is created but the old one is reused - env.applyTripUpdate(tripUpdate); + gtfsRt.applyTripUpdate(tripUpdate); var secondPattern = assertAddedTrip(ADDED_TRIP_ID, env); var secondRoute = secondPattern.getRoute(); assertSame(firstRoute, secondRoute); - assertNotNull(env.getTransitService().getRoute(firstRoute.getId())); + assertNotNull(env.transitService().getRoute(firstRoute.getId())); } @Test public void addedTripWithSkippedStop() { - var builder = new TripUpdateBuilder( - ADDED_TRIP_ID, - SERVICE_DATE, - ADDED, - TIME_ZONE, - "A loop", - "SW1234" - ); - builder + var tripUpdate = gtfsRt + .tripUpdate(ADDED_TRIP_ID, ADDED) + .withTripProperties("A loop", "SW1234") .addStopTime(STOP_A_ID, "00:30", DropOffPickupType.PHONE_AGENCY) .addSkippedStop(STOP_B_ID, "00:40", DropOffPickupType.COORDINATE_WITH_DRIVER) .addSkippedStop(STOP_C_ID, "00:48") .addStopTime(STOP_D_ID, "00:55", "A (non-stop)") - .addStopTime(STOP_A_ID, "01:00"); - var tripUpdate = builder.build(); + .addStopTime(STOP_A_ID, "01:00") + .build(); - env.applyTripUpdate(tripUpdate); + gtfsRt.applyTripUpdate(tripUpdate); // THEN final TripPattern tripPattern = assertAddedTrip(ADDED_TRIP_ID, env); @@ -173,10 +172,8 @@ public void addedTripWithSkippedStop() { assertEquals(PickDrop.CANCELLED, tripPattern.getAlightType(2)); assertEquals(PickDrop.CANCELLED, tripPattern.getBoardType(2)); assertEquals(PickDrop.SCHEDULED, tripPattern.getAlightType(3)); - var snapshot = env.getTimetableSnapshot(); - var forToday = snapshot.resolve(tripPattern, SERVICE_DATE); - var tripTimes = forToday.getTripTimes(id(ADDED_TRIP_ID)); - var trip = env.getTransitService().getTrip(TimetableRepositoryForTest.id(ADDED_TRIP_ID)); + var tripTimes = env.tripData(ADDED_TRIP_ID).tripTimes(); + var trip = env.transitService().getTrip(id(ADDED_TRIP_ID)); assertEquals(I18NString.of("A loop"), Objects.requireNonNull(trip).getHeadsign()); assertEquals(I18NString.of("A loop"), tripTimes.getHeadsign(0)); assertFalse(tripTimes.isCancelledStop(0)); @@ -188,7 +185,7 @@ public void addedTripWithSkippedStop() { @Test public void addedTripWithDelay() { - var builder = new TripUpdateBuilder(ADDED_TRIP_ID, SERVICE_DATE, ADDED, TIME_ZONE); + var builder = gtfsRt.tripUpdate(ADDED_TRIP_ID, ADDED); builder .addStopTime(STOP_A_ID, "08:00") @@ -196,13 +193,11 @@ public void addedTripWithDelay() { .addStopTimeWithScheduled(STOP_C_ID, "09:10", "09:00"); var tripUpdate = builder.build(); - env.applyTripUpdate(tripUpdate); + gtfsRt.applyTripUpdate(tripUpdate); // THEN - var tripPattern = assertAddedTrip(ADDED_TRIP_ID, env); - var snapshot = env.getTimetableSnapshot(); - var forToday = snapshot.resolve(tripPattern, SERVICE_DATE); - var tripTimes = forToday.getTripTimes(id(ADDED_TRIP_ID)); + assertAddedTrip(ADDED_TRIP_ID, env); + var tripTimes = env.tripData(ADDED_TRIP_ID).tripTimes(); assertEquals(0, tripTimes.getDepartureDelay(0)); assertEquals(TimeUtils.time("08:00"), tripTimes.getDepartureTime(0)); assertEquals(300, tripTimes.getArrivalDelay(1)); @@ -211,42 +206,39 @@ public void addedTripWithDelay() { assertEquals(TimeUtils.time("09:10"), tripTimes.getArrivalTime(2)); } - private static TripPattern assertAddedTrip(String tripId, RealtimeTestEnvironment env) { - return assertAddedTrip(tripId, env, RealTimeState.ADDED); + private TripPattern assertAddedTrip(String tripId, TransitTestEnvironment env) { + return assertAddedTrip(tripId, env, RealTimeState.ADDED, STOP_A); } static TripPattern assertAddedTrip( String tripId, - RealtimeTestEnvironment env, - RealTimeState realTimeState + TransitTestEnvironment env, + RealTimeState realTimeState, + RegularStop stop ) { - var snapshot = env.getTimetableSnapshot(); + var tripFetcher = env.tripData(tripId); - TransitService transitService = env.getTransitService(); - Trip trip = transitService.getTrip(id(tripId)); - assertNotNull(trip); - assertNotNull(transitService.findPattern(trip)); + TransitService transitService = env.transitService(); + assertNotNull(tripFetcher.trip()); + assertNotNull(tripFetcher.tripPattern()); assertNotNull(transitService.getTripOnServiceDate(id(tripId))); - var stopA = env.getStop(STOP_A_ID); - // Get the trip pattern of the added trip which goes through stopA - var patternsAtA = env.getTimetableSnapshot().getPatternsForStop(stopA); - - assertNotNull(patternsAtA, "Added trip pattern should be found"); - assertEquals(1, patternsAtA.size()); - var tripPattern = patternsAtA.stream().findFirst().get(); - - var forToday = snapshot.resolve(tripPattern, SERVICE_DATE); - var schedule = snapshot.resolve(tripPattern, null); + assertNull( + tripFetcher.scheduledTripTimes(), + "Added trip should not be found in scheduled time table" + ); + assertNotNull( + tripFetcher.tripTimes(), + "Added trip should be found in time table for service date" + ); - assertNotSame(forToday, schedule); + assertEquals(realTimeState, tripFetcher.realTimeState()); - var tripTimes = forToday.getTripTimes(id(tripId)); - assertNotNull(tripTimes, "Added trip should be found in time table for service date"); - assertEquals(realTimeState, tripTimes.getRealTimeState()); + // Assert that the tripPattern exists at the given stop + assertTrue( + env.timetableSnapshot().getPatternsForStop(stop).contains(tripFetcher.tripPattern()) + ); - var scheduledTripTimes = schedule.getTripTimes(id(tripId)); - assertNull(scheduledTripTimes, "Added trip should not be found in scheduled time table"); - return tripPattern; + return tripFetcher.tripPattern(); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/ReplacementTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/ReplacementTest.java index 649631be063..b296a8e5673 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/ReplacementTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/ReplacementTest.java @@ -7,54 +7,49 @@ import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.opentripplanner.routing.algorithm.raptoradapter.transit.request.TestTransitCaseData.STOP_A; -import static org.opentripplanner.routing.algorithm.raptoradapter.transit.request.TestTransitCaseData.STOP_B; -import static org.opentripplanner.updater.trip.gtfs.moduletests.addition.AddedTest.assertAddedTrip; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import org.junit.jupiter.api.Test; import org.opentripplanner.framework.i18n.I18NString; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.timetable.RealTimeState; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; public class ReplacementTest implements RealtimeTestConstants { @Test void replacementTrip() { + var builder = TransitTestEnvironment.of(); + var STOP_A = builder.stop(STOP_A_ID); + var STOP_B = builder.stop(STOP_B_ID); + var STOP_C = builder.stop(STOP_C_ID); var TRIP_INPUT = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "8:30:00", "8:30:00") .addStop(STOP_B, "8:40:00", "8:40:00") - .withHeadsign(I18NString.of("Original Headsign")) - .build(); - var env = RealtimeTestEnvironment.of() - .withStops(STOP_A_ID, STOP_B_ID, STOP_C_ID, STOP_D_ID) - .addTrip(TRIP_INPUT) - .build(); - var builder = new TripUpdateBuilder( - TRIP_1_ID, - SERVICE_DATE, - REPLACEMENT, - TIME_ZONE, - "New Headsign", - "SW1234" // we can't change trip short name at real-time yet - ); - builder + .withHeadsign(I18NString.of("Original Headsign")); + var env = builder.addTrip(TRIP_INPUT).build(); + var rt = GtfsRtTestHelper.of(env); + + var tripUpdate = rt + .tripUpdate(TRIP_1_ID, REPLACEMENT) + .withTripProperties( + "New Headsign", + "SW1234" // we can't change trip short name at real-time yet + ) .addStopTime(STOP_A_ID, "00:30") .addStopTime(STOP_B_ID, "00:45", "Changed Headsign") - .addStopTime(STOP_C_ID, "01:00"); - - var tripUpdate = builder.build(); + .addStopTime(STOP_C_ID, "01:00") + .build(); - env.applyTripUpdate(tripUpdate); + rt.applyTripUpdate(tripUpdate); // THEN - var snapshot = env.getTimetableSnapshot(); - var tripId = TimetableRepositoryForTest.id(TRIP_1_ID); + var snapshot = env.timetableSnapshot(); + var tripId = id(TRIP_1_ID); - var transitService = env.getTransitService(); + var transitService = env.transitService(); // Original trip pattern { @@ -62,7 +57,10 @@ void replacementTrip() { assertNotNull(trip); var originalTripPattern = transitService.findPattern(trip); - var originalTimetableForToday = snapshot.resolve(originalTripPattern, SERVICE_DATE); + var originalTimetableForToday = snapshot.resolve( + originalTripPattern, + env.defaultServiceDate() + ); var originalTimetableScheduled = snapshot.resolve(originalTripPattern, null); assertNotSame(originalTimetableForToday, originalTimetableScheduled); @@ -102,16 +100,15 @@ void replacementTrip() { // New trip pattern { - assertAddedTrip(TRIP_1_ID, env, RealTimeState.MODIFIED); - var newTripPattern = snapshot.getNewTripPatternForModifiedTrip(tripId, SERVICE_DATE); - assertNotNull(newTripPattern, "New trip pattern should be found"); + var tripFetcher = env.tripData(TRIP_1_ID); + assertEquals(RealTimeState.MODIFIED, tripFetcher.realTimeState()); - var newTimetableForToday = snapshot.resolve(newTripPattern, SERVICE_DATE); - var newTimetableScheduled = snapshot.resolve(newTripPattern, null); + var newTripPattern = tripFetcher.tripPattern(); + assertNotNull(newTripPattern, "New trip pattern should be found"); - assertNotSame(newTimetableForToday, newTimetableScheduled); + var tripTimes = tripFetcher.tripTimes(); + var newTimetableScheduled = transitService.findTimetable(newTripPattern, null); - var tripTimes = newTimetableForToday.getTripTimes(tripId); assertNotNull(tripTimes, "New trip should be found in time table for service date"); assertEquals(RealTimeState.MODIFIED, tripTimes.getRealTimeState()); diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/TripAlreadyExistsTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/TripAlreadyExistsTest.java index 3a6b4fe009f..94e69b410c9 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/TripAlreadyExistsTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/addition/TripAlreadyExistsTest.java @@ -5,30 +5,32 @@ import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; class TripAlreadyExistsTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(); private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); - private final RealtimeTestEnvironment env = envBuilder - .addTrip(TripInput.of(TRIP_1_ID).addStop(STOP_A, "12:00").addStop(STOP_B, "13:00").build()) + private final TransitTestEnvironment env = envBuilder + .addTrip(TripInput.of(TRIP_1_ID).addStop(STOP_A, "12:00").addStop(STOP_B, "13:00")) .build(); + private final GtfsRtTestHelper rt = GtfsRtTestHelper.of(env); @Test void scheduledTripAlreadyExists() { - var tripUpdate = new TripUpdateBuilder(TRIP_1_ID, SERVICE_DATE, NEW, TIME_ZONE) + var tripUpdate = rt + .tripUpdate(TRIP_1_ID, NEW) .addStopTime(STOP_A_ID, "10:30") .addStopTime(STOP_B_ID, "10:40") .build(); - assertFailure(TRIP_ALREADY_EXISTS, env.applyTripUpdate(tripUpdate)); + assertFailure(TRIP_ALREADY_EXISTS, rt.applyTripUpdate(tripUpdate)); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CanceledTripTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CanceledTripTest.java index e7f560a7872..0d47bae9ee4 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CanceledTripTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CanceledTripTest.java @@ -3,20 +3,20 @@ import static com.google.common.truth.Truth.assertThat; import static com.google.transit.realtime.GtfsRealtime.TripDescriptor.ScheduleRelationship.CANCELED; import static org.junit.jupiter.api.Assertions.assertEquals; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; public class CanceledTripTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); @@ -26,18 +26,18 @@ void listCanceledTrips() { TripInput.of(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") .addStop(STOP_B, "0:00:20", "0:00:21") - .build() ).build(); + var rt = GtfsRtTestHelper.of(env); - assertThat(env.getTransitService().listCanceledTrips()).isEmpty(); + assertThat(env.transitService().listCanceledTrips()).isEmpty(); - var update = new TripUpdateBuilder(TRIP_1_ID, SERVICE_DATE, CANCELED, TIME_ZONE).build(); - assertSuccess(env.applyTripUpdate(update)); + var update = rt.tripUpdate(TRIP_1_ID, CANCELED).build(); + assertSuccess(rt.applyTripUpdate(update)); - var canceled = env.getTransitService().listCanceledTrips(); + var canceled = env.transitService().listCanceledTrips(); assertThat(canceled).hasSize(1); var trip = canceled.getFirst(); assertEquals(id(TRIP_1_ID), trip.getTrip().getId()); - assertEquals(SERVICE_DATE, trip.getServiceDate()); + assertEquals(env.defaultServiceDate(), trip.getServiceDate()); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CancellationDeletionTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CancellationDeletionTest.java index 8c9558ef523..004545dc76d 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CancellationDeletionTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/cancellation/CancellationDeletionTest.java @@ -5,7 +5,7 @@ import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import static org.opentripplanner.updater.trip.UpdateIncrementality.DIFFERENTIAL; @@ -14,13 +14,13 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.timetable.RealTimeState; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; /** * Cancellations and deletions should end up in the internal data model and make trips unavailable @@ -28,7 +28,7 @@ */ class CancellationDeletionTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder envBuilder = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder envBuilder = TransitTestEnvironment.of(); private final RegularStop STOP_A = envBuilder.stop(STOP_A_ID); private final RegularStop STOP_B = envBuilder.stop(STOP_B_ID); @@ -47,24 +47,19 @@ void cancelledTrip(ScheduleRelationship relationship, RealTimeState state) { TripInput.of(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") .addStop(STOP_B, "0:00:20", "0:00:21") - .build() ) .build(); - var pattern1 = env.getPatternForTrip(TRIP_1_ID); + var rt = GtfsRtTestHelper.of(env); - var update = new TripUpdateBuilder(TRIP_1_ID, SERVICE_DATE, relationship, TIME_ZONE).build(); - assertSuccess(env.applyTripUpdate(update)); + var update = rt.tripUpdate(TRIP_1_ID, relationship).build(); + assertSuccess(rt.applyTripUpdate(update)); - var snapshot = env.getTimetableSnapshot(); - var forToday = snapshot.resolve(pattern1, SERVICE_DATE); - var schedule = snapshot.resolve(pattern1, null); + var forToday = env.tripData(TRIP_1_ID).tripTimes(); + var schedule = env.tripData(TRIP_1_ID).scheduledTripTimes(); assertNotSame(forToday, schedule); - assertNotSame(forToday.getTripTimes(id(TRIP_1_ID)), schedule.getTripTimes(id(TRIP_1_ID))); - var tripTimes = forToday.getTripTimes(id(TRIP_1_ID)); - - assertEquals(state, tripTimes.getRealTimeState()); - assertTrue(tripTimes.isCanceledOrDeleted()); + assertEquals(state, forToday.getRealTimeState()); + assertTrue(forToday.isCanceledOrDeleted()); } /** @@ -80,43 +75,40 @@ void cancelledTrip(ScheduleRelationship relationship, RealTimeState state) { @ParameterizedTest @MethodSource("cases") void cancelingAddedTrip(ScheduleRelationship relationship, RealTimeState state) { + // just to set the scheduling period var env = envBuilder .addTrip( TripInput.of(TRIP_1_ID) // just to set the scheduling period - .withServiceDates(SERVICE_DATE) + .withServiceDates(envBuilder.defaultServiceDate()) .addStop(STOP_A, "0:00:10", "0:00:11") .addStop(STOP_B, "0:00:20", "0:00:21") - .build() ) .build(); + var rt = GtfsRtTestHelper.of(env); var addedTripId = "added-trip"; // First add ADDED trip - var update = new TripUpdateBuilder( - addedTripId, - SERVICE_DATE, - ScheduleRelationship.ADDED, - TIME_ZONE - ) + var update = rt + .tripUpdate(addedTripId, ScheduleRelationship.ADDED) .addStopTime(STOP_A_ID, "00:30") .addStopTime(STOP_B_ID, "00:40") .addStopTime(STOP_C_ID, "00:55") .build(); - assertSuccess(env.applyTripUpdate(update, DIFFERENTIAL)); + assertSuccess(rt.applyTripUpdate(update, DIFFERENTIAL)); // Cancel or delete the added trip - update = new TripUpdateBuilder(addedTripId, SERVICE_DATE, relationship, TIME_ZONE).build(); - assertSuccess(env.applyTripUpdate(update, DIFFERENTIAL)); + update = rt.tripUpdate(addedTripId, relationship).build(); + assertSuccess(rt.applyTripUpdate(update, DIFFERENTIAL)); - var snapshot = env.getTimetableSnapshot(); + var snapshot = env.timetableSnapshot(); // Get the trip pattern of the added trip which goes through stopA var patternsAtA = snapshot.getPatternsForStop(STOP_A); assertNotNull(patternsAtA, "Added trip pattern should be found"); var tripPattern = patternsAtA.stream().findFirst().get(); - var forToday = snapshot.resolve(tripPattern, SERVICE_DATE); + var forToday = snapshot.resolve(tripPattern, env.defaultServiceDate()); var schedule = snapshot.resolve(tripPattern, null); assertNotSame(forToday, schedule); diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/DelayedTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/DelayedTest.java index 989b1b7b550..68e073c49bb 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/DelayedTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/DelayedTest.java @@ -1,73 +1,68 @@ package org.opentripplanner.updater.trip.gtfs.moduletests.delay; -import static com.google.transit.realtime.GtfsRealtime.TripDescriptor.ScheduleRelationship.SCHEDULED; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotSame; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import org.junit.jupiter.api.Test; -import org.opentripplanner.transit.model.framework.FeedScopedId; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.timetable.RealTimeState; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; /** * Delays should be applied to the first trip but should leave the second trip untouched. */ class DelayedTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final RegularStop STOP_C = ENV_BUILDER.stop(STOP_C_ID); private static final int DELAY = 1; private static final int STOP_SEQUENCE = 1; - private static final FeedScopedId TRIP_ID = id(TRIP_1_ID); @Test void singleStopDelay() { var tripInput = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); var env = ENV_BUILDER.addTrip(tripInput).build(); + var rt = GtfsRtTestHelper.of(env); - var tripUpdate = new TripUpdateBuilder(TRIP_1_ID, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var tripUpdate = rt + .tripUpdateScheduled(TRIP_1_ID) .addDelayedStopTime(STOP_SEQUENCE, DELAY) .build(); - var result = env.applyTripUpdate(tripUpdate); + var result = rt.applyTripUpdate(tripUpdate); assertEquals(1, result.successful()); - var pattern1 = env.getPatternForTrip(TRIP_1_ID); + var tripData = env.tripData(TRIP_1_ID); - var snapshot = env.getTimetableSnapshot(); - var trip1Realtime = snapshot.resolve(pattern1, SERVICE_DATE); - var trip1Scheduled = snapshot.resolve(pattern1, null); + var trip1Realtime = tripData.tripTimes(); + var trip1Scheduled = tripData.scheduledTripTimes(); assertNotSame(trip1Realtime, trip1Scheduled); - assertNotSame(trip1Realtime.getTripTimes(TRIP_ID), trip1Scheduled.getTripTimes(TRIP_ID)); - assertEquals(DELAY, trip1Realtime.getTripTimes(TRIP_ID).getArrivalDelay(STOP_SEQUENCE)); - assertEquals(DELAY, trip1Realtime.getTripTimes(TRIP_ID).getDepartureDelay(STOP_SEQUENCE)); + assertEquals(DELAY, trip1Realtime.getArrivalDelay(STOP_SEQUENCE)); + assertEquals(DELAY, trip1Realtime.getDepartureDelay(STOP_SEQUENCE)); - assertEquals(RealTimeState.SCHEDULED, trip1Scheduled.getTripTimes(TRIP_ID).getRealTimeState()); + assertEquals(RealTimeState.SCHEDULED, trip1Scheduled.getRealTimeState()); assertEquals( "SCHEDULED | A 0:00:10 0:00:11 | B 0:00:20 0:00:21", - env.getScheduledTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showScheduledTimetable() ); assertEquals( "UPDATED | A [ND] 0:00:10 0:00:11 | B 0:00:21 0:00:22", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } @@ -79,46 +74,44 @@ void complexDelay() { var tripInput = TripInput.of(TRIP_2_ID) .addStop(STOP_A, "0:01:00", "0:01:01") .addStop(STOP_B, "0:01:10", "0:01:11") - .addStop(STOP_C, "0:01:20", "0:01:21") - .build(); + .addStop(STOP_C, "0:01:20", "0:01:21"); var env = ENV_BUILDER.addTrip(tripInput).build(); + var rt = GtfsRtTestHelper.of(env); - var tripUpdate = new TripUpdateBuilder(TRIP_2_ID, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var tripUpdate = rt + .tripUpdateScheduled(TRIP_2_ID) .addDelayedStopTime(0, 0) .addDelayedStopTime(1, 60, 80) .addDelayedStopTime(2, 90, 90) .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); - - var snapshot = env.getTimetableSnapshot(); + assertSuccess(rt.applyTripUpdate(tripUpdate)); - var trip2 = env.getTransitService().getTrip(id(TRIP_2_ID)); - var originalTripPattern = env.getTransitService().findPattern(trip2); + var tripData = env.tripData(TRIP_2_ID); + var realtimeTripTimes = tripData.tripTimes(); + var scheduledTripTimes = tripData.scheduledTripTimes(); - var originalTimetableForToday = snapshot.resolve(originalTripPattern, SERVICE_DATE); - var originalTimetableScheduled = snapshot.resolve(originalTripPattern, null); + assertNotSame(realtimeTripTimes, scheduledTripTimes); - assertNotSame(originalTimetableForToday, originalTimetableScheduled); - - var tripTimes = originalTimetableScheduled.getTripTimes(id(TRIP_2_ID)); - assertNotNull(tripTimes, "Original trip should be found in scheduled time table"); + assertNotNull(scheduledTripTimes, "Original trip should be found in scheduled time table"); assertFalse( - tripTimes.isCanceledOrDeleted(), + scheduledTripTimes.isCanceledOrDeleted(), "Original trip times should not be canceled in scheduled time table" ); - assertEquals(RealTimeState.SCHEDULED, tripTimes.getRealTimeState()); + assertEquals(RealTimeState.SCHEDULED, scheduledTripTimes.getRealTimeState()); - var realtimeTt = originalTimetableForToday.getTripTimes(id(TRIP_2_ID)); - assertNotNull(realtimeTt, "Original trip should be found in time table for service date"); + assertNotNull( + realtimeTripTimes, + "Original trip should be found in time table for service date" + ); assertEquals( "SCHEDULED | A 0:01 0:01:01 | B 0:01:10 0:01:11 | C 0:01:20 0:01:21", - env.getScheduledTimetable(TRIP_2_ID) + tripData.showScheduledTimetable() ); assertEquals( "UPDATED | A 0:01 0:01:01 | B 0:02:10 0:02:31 | C 0:02:50 0:02:51", - env.getRealtimeTimetable(TRIP_2_ID) + tripData.showTimetable() ); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedTest.java index bea132482f3..6e9607a6e09 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedTest.java @@ -1,32 +1,31 @@ package org.opentripplanner.updater.trip.gtfs.moduletests.delay; -import static com.google.transit.realtime.GtfsRealtime.TripDescriptor.ScheduleRelationship.SCHEDULED; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertFalse; import static org.junit.jupiter.api.Assertions.assertNotNull; import static org.junit.jupiter.api.Assertions.assertNotSame; import static org.junit.jupiter.api.Assertions.assertNull; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import static org.opentripplanner.updater.trip.UpdateIncrementality.DIFFERENTIAL; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.timetable.RealTimeState; import org.opentripplanner.transit.model.timetable.TripTimesStringBuilder; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; /** * A mixture of delayed and skipped stops should result in both delayed and cancelled stops. */ class SkippedTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final RegularStop STOP_C = ENV_BUILDER.stop(STOP_C_ID); @@ -34,20 +33,21 @@ class SkippedTest implements RealtimeTestConstants { private final TripInput TRIP_INPUT = TripInput.of(TRIP_2_ID) .addStop(STOP_A, "0:01:00", "0:01:01") .addStop(STOP_B, "0:01:10", "0:01:11") - .addStop(STOP_C, "0:01:20", "0:01:21") - .build(); + .addStop(STOP_C, "0:01:20", "0:01:21"); @Test void scheduledTripWithSkippedAndScheduled() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var rt = GtfsRtTestHelper.of(env); - var tripUpdate = new TripUpdateBuilder(TRIP_2_ID, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var tripUpdate = rt + .tripUpdateScheduled(TRIP_2_ID) .addDelayedStopTime(0, 0) .addSkippedStop(1) .addDelayedStopTime(2, 90) .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); + assertSuccess(rt.applyTripUpdate(tripUpdate)); assertOriginalTripPatternIsDeleted(env, TRIP_2_ID); @@ -55,7 +55,7 @@ void scheduledTripWithSkippedAndScheduled() { assertEquals( "UPDATED | A 0:01 0:01:01 | B [C] 0:01:52 0:01:58 | C 0:02:50 0:02:51", - env.getRealtimeTimetable(TRIP_2_ID) + env.tripData(TRIP_2_ID).showTimetable() ); } @@ -71,17 +71,20 @@ void scheduledTripWithSkippedAndScheduled() { @Test void scheduledTripWithPreviouslySkipped() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var rt = GtfsRtTestHelper.of(env); - var tripUpdate = new TripUpdateBuilder(TRIP_2_ID, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var tripUpdate = rt + .tripUpdateScheduled(TRIP_2_ID) .addDelayedStopTime(0, 0) .addSkippedStop(1) .addDelayedStopTime(2, 90) .build(); - assertSuccess(env.applyTripUpdate(tripUpdate, DIFFERENTIAL)); + assertSuccess(rt.applyTripUpdate(tripUpdate, DIFFERENTIAL)); // Create update to the same trip but now the skipped stop is no longer skipped - var scheduledBuilder = new TripUpdateBuilder(TRIP_2_ID, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var scheduledBuilder = rt + .tripUpdateScheduled(TRIP_2_ID) .addDelayedStopTime(0, 0) .addDelayedStopTime(1, 50) .addDelayedStopTime(2, 90); @@ -89,23 +92,23 @@ void scheduledTripWithPreviouslySkipped() { tripUpdate = scheduledBuilder.build(); // apply the update with the previously skipped stop now scheduled - assertSuccess(env.applyTripUpdate(tripUpdate, DIFFERENTIAL)); + assertSuccess(rt.applyTripUpdate(tripUpdate, DIFFERENTIAL)); // Check that the there is no longer a realtime added trip pattern for the trip and that the // stoptime updates have gone through - var snapshot = env.getTimetableSnapshot(); + var snapshot = env.timetableSnapshot(); - assertNull(snapshot.getNewTripPatternForModifiedTrip(id(TRIP_2_ID), SERVICE_DATE)); + assertNull(snapshot.getNewTripPatternForModifiedTrip(id(TRIP_2_ID), env.defaultServiceDate())); assertNewTripTimesIsUpdated(env, TRIP_2_ID); assertEquals( "SCHEDULED | A 0:01 0:01:01 | B 0:01:10 0:01:11 | C 0:01:20 0:01:21", - env.getScheduledTimetable(TRIP_2_ID) + env.tripData(TRIP_2_ID).showScheduledTimetable() ); assertEquals( "UPDATED | A 0:01 0:01:01 | B 0:02 0:02:01 | C 0:02:50 0:02:51", - env.getRealtimeTimetable(id(TRIP_2_ID), SERVICE_DATE) + env.tripData(TRIP_2_ID).showTimetable() ); } @@ -115,16 +118,18 @@ void scheduledTripWithPreviouslySkipped() { @Test void skippedNoData() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var rt = GtfsRtTestHelper.of(env); String tripId = TRIP_2_ID; - var tripUpdate = new TripUpdateBuilder(tripId, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var tripUpdate = rt + .tripUpdateScheduled(tripId) .addNoDataStop(0) .addSkippedStop(1) .addNoDataStop(2) .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); + assertSuccess(rt.applyTripUpdate(tripUpdate)); assertOriginalTripPatternIsDeleted(env, tripId); @@ -132,18 +137,18 @@ void skippedNoData() { assertEquals( "UPDATED | A [ND] 0:01 0:01:01 | B [C] 0:01:10 0:01:11 | C [ND] 0:01:20 0:01:21", - env.getRealtimeTimetable(tripId) + env.tripData(tripId).showTimetable() ); } private static void assertOriginalTripPatternIsDeleted( - RealtimeTestEnvironment env, + TransitTestEnvironment env, String tripId ) { - var trip = env.getTransitService().getTrip(id(tripId)); - var originalTripPattern = env.getTransitService().findPattern(trip); - var snapshot = env.getTimetableSnapshot(); - var originalTimetableForToday = snapshot.resolve(originalTripPattern, SERVICE_DATE); + var trip = env.transitService().getTrip(id(tripId)); + var originalTripPattern = env.transitService().findPattern(trip); + var snapshot = env.timetableSnapshot(); + var originalTimetableForToday = snapshot.resolve(originalTripPattern, env.defaultServiceDate()); var originalTimetableScheduled = snapshot.resolve(originalTripPattern, null); assertNotSame(originalTimetableForToday, originalTimetableScheduled); @@ -173,11 +178,11 @@ private static void assertOriginalTripPatternIsDeleted( assertEquals(RealTimeState.DELETED, scheduledTripTimes.getRealTimeState()); } - private static void assertNewTripTimesIsUpdated(RealtimeTestEnvironment env, String tripId) { - var trip = env.getTransitService().getTrip(id(tripId)); - var originalTripPattern = env.getTransitService().findPattern(trip); - var snapshot = env.getTimetableSnapshot(); - var originalTimetableForToday = snapshot.resolve(originalTripPattern, SERVICE_DATE); + private static void assertNewTripTimesIsUpdated(TransitTestEnvironment env, String tripId) { + var trip = env.transitService().getTrip(id(tripId)); + var originalTripPattern = env.transitService().findPattern(trip); + var snapshot = env.timetableSnapshot(); + var originalTimetableForToday = snapshot.resolve(originalTripPattern, env.defaultServiceDate()); var originalTimetableScheduled = snapshot.resolve(originalTripPattern, null); diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedWithRepeatedTimesTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedWithRepeatedTimesTest.java index 81255973eb1..6958ab46242 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedWithRepeatedTimesTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/delay/SkippedWithRepeatedTimesTest.java @@ -1,16 +1,15 @@ package org.opentripplanner.updater.trip.gtfs.moduletests.delay; -import static com.google.transit.realtime.GtfsRealtime.TripDescriptor.ScheduleRelationship.SCHEDULED; import static org.junit.jupiter.api.Assertions.assertEquals; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.TripUpdateBuilder; /** * Tests that stops can be SKIPPED for a trip which repeats times for consecutive stops. @@ -19,7 +18,7 @@ */ class SkippedWithRepeatedTimesTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final RegularStop STOP_C = ENV_BUILDER.stop(STOP_C_ID); @@ -27,24 +26,25 @@ class SkippedWithRepeatedTimesTest implements RealtimeTestConstants { private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "10:00:00", "10:01:00") .addStop(STOP_B, "10:01:00", "10:01:00") - .addStop(STOP_C, "10:01:00", "10:02:00") - .build(); + .addStop(STOP_C, "10:01:00", "10:02:00"); @Test void skippedWithRepeatedTimes() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var rt = GtfsRtTestHelper.of(env); - var tripUpdate = new TripUpdateBuilder(TRIP_1_ID, SERVICE_DATE, SCHEDULED, TIME_ZONE) + var tripUpdate = rt + .tripUpdateScheduled(TRIP_1_ID) .addStopTime(STOP_A_ID, "10:00:00") .addSkippedStop(STOP_B_ID, "10:01:00") .addStopTime(STOP_C_ID, "10:01:00") .build(); - assertSuccess(env.applyTripUpdate(tripUpdate)); + assertSuccess(rt.applyTripUpdate(tripUpdate)); assertEquals( "UPDATED | A 10:00 10:00 | B [C] 10:00 10:00 | C 10:01 10:01", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidInputTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidInputTest.java index 08a9c41cebe..9916dfeb56c 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidInputTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidInputTest.java @@ -9,11 +9,12 @@ import java.util.List; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; import org.opentripplanner.updater.trip.TripUpdateBuilder; /** @@ -22,7 +23,8 @@ */ class InvalidInputTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private static final LocalDate SERVICE_DATE = LocalDate.of(2025, 7, 8); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(SERVICE_DATE); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); @@ -35,17 +37,17 @@ public static List cases() { void invalidTripDate(LocalDate date) { var tripInput = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); var env = ENV_BUILDER.addTrip(tripInput).build(); + var rt = GtfsRtTestHelper.of(env); - var update = new TripUpdateBuilder(TRIP_1_ID, date, SCHEDULED, TIME_ZONE) + var update = new TripUpdateBuilder(TRIP_1_ID, date, SCHEDULED, env.timeZone()) .addDelayedStopTime(2, 60, 80) .build(); - var result = env.applyTripUpdate(update); + var result = rt.applyTripUpdate(update); - var snapshot = env.getTimetableSnapshot(); + var snapshot = env.timetableSnapshot(); assertTrue(snapshot.isEmpty()); assertFailure(NO_SERVICE_ON_DATE, result); } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidTripIdTest.java b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidTripIdTest.java index 3ac2fdc5869..00ea3eef696 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidTripIdTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/gtfs/moduletests/rejection/InvalidTripIdTest.java @@ -8,7 +8,8 @@ import java.util.stream.Stream; import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.MethodSource; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.updater.trip.GtfsRtTestHelper; class InvalidTripIdTest { @@ -22,7 +23,8 @@ static Stream invalidCases() { @ParameterizedTest(name = "tripId=\"{0}\"") @MethodSource("invalidCases") void invalidTripId(String tripId) { - var env = RealtimeTestEnvironment.of().build(); + var env = TransitTestEnvironment.of().build(); + var rt = GtfsRtTestHelper.of(env); var tripDescriptorBuilder = GtfsRealtime.TripDescriptor.newBuilder(); if (tripId != null) { tripDescriptorBuilder.setTripId(tripId); @@ -33,6 +35,6 @@ void invalidTripId(String tripId) { tripUpdateBuilder.setTrip(tripDescriptorBuilder); var tripUpdate = tripUpdateBuilder.build(); - assertFailure(INVALID_INPUT_STRUCTURE, env.applyTripUpdate(tripUpdate)); + assertFailure(INVALID_INPUT_STRUCTURE, rt.applyTripUpdate(tripUpdate)); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriEtBuilder.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriEtBuilder.java index 39347eadcde..9da0b867d33 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriEtBuilder.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriEtBuilder.java @@ -7,7 +7,7 @@ import java.util.List; import java.util.function.Function; import javax.annotation.Nullable; -import org.opentripplanner.DateTimeHelper; +import org.opentripplanner.LocalTimeParser; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.site.StopLocation; import uk.org.siri.siri21.DataFrameRefStructure; @@ -31,10 +31,10 @@ public class SiriEtBuilder { private final EstimatedVehicleJourney evj; - private final DateTimeHelper dateTimeHelper; + private final LocalTimeParser localTimeParser; - public SiriEtBuilder(DateTimeHelper dateTimeHelper) { - this.dateTimeHelper = dateTimeHelper; + public SiriEtBuilder(LocalTimeParser localTimeParser) { + this.localTimeParser = localTimeParser; this.evj = new EstimatedVehicleJourney(); // Set default values @@ -105,7 +105,7 @@ public SiriEtBuilder withRecordedCalls( "You need to call withRecordedCalls() before withEstimatedCalls()" ); } - var builder = new RecordedCallsBuilder(dateTimeHelper, 0); + var builder = new RecordedCallsBuilder(localTimeParser, 0); builder = producer.apply(builder); @@ -121,7 +121,7 @@ public SiriEtBuilder withEstimatedCalls( int offset = evj.getRecordedCalls() == null ? 0 : evj.getRecordedCalls().getRecordedCalls().size(); - var builder = new EstimatedCallsBuilder(dateTimeHelper, offset); + var builder = new EstimatedCallsBuilder(localTimeParser, offset); builder = producer.apply(builder); @@ -179,10 +179,10 @@ public static class RecordedCallsBuilder { private final ArrayList calls; private final int orderOffset; - private final DateTimeHelper dateTimeHelper; + private final LocalTimeParser localTimeParser; - public RecordedCallsBuilder(DateTimeHelper dateTimeHelper, int orderOffset) { - this.dateTimeHelper = dateTimeHelper; + public RecordedCallsBuilder(LocalTimeParser localTimeParser, int orderOffset) { + this.localTimeParser = localTimeParser; this.orderOffset = orderOffset; this.calls = new ArrayList<>(); } @@ -201,15 +201,15 @@ public RecordedCallsBuilder call(StopLocation stop) { public RecordedCallsBuilder arriveAimedActual(String aimedTime, String actualTime) { var call = calls.getLast(); - call.setAimedArrivalTime(dateTimeHelper.zonedDateTime(aimedTime)); - call.setActualArrivalTime(dateTimeHelper.zonedDateTime(actualTime)); + call.setAimedArrivalTime(localTimeParser.zonedDateTime(aimedTime)); + call.setActualArrivalTime(localTimeParser.zonedDateTime(actualTime)); return this; } public RecordedCallsBuilder departAimedActual(String aimedTime, String actualTime) { var call = calls.getLast(); - call.setAimedDepartureTime(dateTimeHelper.zonedDateTime(aimedTime)); - call.setActualDepartureTime(dateTimeHelper.zonedDateTime(actualTime)); + call.setAimedDepartureTime(localTimeParser.zonedDateTime(aimedTime)); + call.setActualDepartureTime(localTimeParser.zonedDateTime(actualTime)); return this; } @@ -234,10 +234,10 @@ public static class EstimatedCallsBuilder { private final ArrayList calls; private final int orderOffset; - private final DateTimeHelper dateTimeHelper; + private final LocalTimeParser localTimeParser; - public EstimatedCallsBuilder(DateTimeHelper dateTimeHelper, int orderOffset) { - this.dateTimeHelper = dateTimeHelper; + public EstimatedCallsBuilder(LocalTimeParser localTimeParser, int orderOffset) { + this.localTimeParser = localTimeParser; this.orderOffset = orderOffset; this.calls = new ArrayList<>(); } @@ -264,10 +264,10 @@ public EstimatedCallsBuilder arriveAimedExpected( ) { var call = calls.getLast(); if (aimedTime != null) { - call.setAimedArrivalTime(dateTimeHelper.zonedDateTime(aimedTime)); + call.setAimedArrivalTime(localTimeParser.zonedDateTime(aimedTime)); } if (expectedTime != null) { - call.setExpectedArrivalTime(dateTimeHelper.zonedDateTime(expectedTime)); + call.setExpectedArrivalTime(localTimeParser.zonedDateTime(expectedTime)); } return this; } @@ -278,10 +278,10 @@ public EstimatedCallsBuilder departAimedExpected( ) { var call = calls.getLast(); if (aimedTime != null) { - call.setAimedDepartureTime(dateTimeHelper.zonedDateTime(aimedTime)); + call.setAimedDepartureTime(localTimeParser.zonedDateTime(aimedTime)); } if (expectedTime != null) { - call.setExpectedDepartureTime(dateTimeHelper.zonedDateTime(expectedTime)); + call.setExpectedDepartureTime(localTimeParser.zonedDateTime(expectedTime)); } return this; } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriFuzzyTripMatcherTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriFuzzyTripMatcherTest.java index 16f920a84b5..d6a8b7e8cc9 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriFuzzyTripMatcherTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/SiriFuzzyTripMatcherTest.java @@ -2,24 +2,23 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertTrue; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import static org.opentripplanner.updater.spi.UpdateError.UpdateErrorType.MULTIPLE_FUZZY_TRIP_MATCHES; import static org.opentripplanner.updater.spi.UpdateError.UpdateErrorType.NO_FUZZY_TRIP_MATCH; -import java.util.Map; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.framework.Result; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; import uk.org.siri.siri21.EstimatedVehicleJourney; class SiriFuzzyTripMatcherTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); @@ -54,10 +53,10 @@ void scheduledStopPoint() { var trip1input = tripInput(TRIP_1_ID); var env = ENV_BUILDER.addTrip(trip1input) - .addScheduledStopPointMapping(Map.of(id(scheduledStopPointId), STOP_B)) + .addScheduledStopPointMapping(id(scheduledStopPointId), STOP_B) .build(); - var journey = new SiriEtBuilder(env.getDateTimeHelper()) + var journey = new SiriEtBuilder(env.localTimeParser()) .withEstimatedCalls(builder -> builder .call(STOP_A) @@ -77,7 +76,7 @@ void unknownStopPointRef() { var env = ENV_BUILDER.addTrip(trip1input).build(); - var journey = new SiriEtBuilder(env.getDateTimeHelper()) + var journey = new SiriEtBuilder(env.localTimeParser()) .withEstimatedCalls(builder -> builder .call(STOP_A) @@ -94,20 +93,20 @@ void unknownStopPointRef() { private static Result match( EstimatedVehicleJourney evj, - RealtimeTestEnvironment env + TransitTestEnvironment env ) { - var transitService = env.getTransitService(); + var transitService = env.transitService(); var fuzzyMatcher = new SiriFuzzyTripMatcher(transitService); return fuzzyMatcher.match( evj, - new EntityResolver(transitService, env.getFeedId()), + new EntityResolver(transitService, env.feedId()), transitService::findTimetable, transitService::findNewTripPatternForModifiedTrip ); } - private EstimatedVehicleJourney estimatedVehicleJourney(RealtimeTestEnvironment env) { - return new SiriEtBuilder(env.getDateTimeHelper()) + private EstimatedVehicleJourney estimatedVehicleJourney(TransitTestEnvironment env) { + return new SiriEtBuilder(env.localTimeParser()) .withEstimatedCalls(builder -> builder .call(STOP_A) @@ -121,7 +120,6 @@ private EstimatedVehicleJourney estimatedVehicleJourney(RealtimeTestEnvironment private TripInput tripInput(String trip1Id) { return TripInput.of(trip1Id) .addStop(STOP_A, "0:10:00", "0:10:00") - .addStop(STOP_B, "0:20:00", "0:20:00") - .build(); + .addStop(STOP_B, "0:20:00", "0:20:00"); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancellationTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancellationTest.java index 48c4169d520..9a82b8a5fd0 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancellationTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancellationTest.java @@ -3,34 +3,45 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; +import org.opentripplanner.transit.model.network.Route; +import org.opentripplanner.transit.model.organization.Operator; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.timetable.RealTimeState; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; +import org.opentripplanner.updater.trip.SiriTestHelper; import org.opentripplanner.updater.trip.siri.SiriEtBuilder; class CancellationTest implements RealtimeTestConstants { private static final String ADDED_TRIP_ID = "newJourney"; - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private static final String ROUTE_ID = "route-id"; + private static final String OPERATOR_ID = "operator-id"; + + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stopAtStation(STOP_B_ID, STATION_OMEGA_ID); private final RegularStop STOP_C = ENV_BUILDER.stopAtStation(STOP_D_ID, STATION_OMEGA_ID); + private final Operator OPERATOR = ENV_BUILDER.operator(OPERATOR_ID); + private final Route ROUTE = ENV_BUILDER.route(ROUTE_ID, OPERATOR); private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) + .withRoute(ROUTE) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); @Test void testCancelTrip() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - assertEquals(RealTimeState.SCHEDULED, env.getTripTimesForTrip(TRIP_1_ID).getRealTimeState()); + assertEquals(RealTimeState.SCHEDULED, env.tripData(TRIP_1_ID).realTimeState()); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withCancellation(true) .withEstimatedCalls(builder -> @@ -44,25 +55,29 @@ void testCancelTrip() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); - assertEquals(RealTimeState.CANCELED, env.getTripTimesForTrip(TRIP_1_ID).getRealTimeState()); + assertEquals(RealTimeState.CANCELED, env.tripData(TRIP_1_ID).realTimeState()); } @Test void testCancelTripWithMissingTimes() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); - assertEquals(RealTimeState.SCHEDULED, env.getTripTimesForTrip(TRIP_1_ID).getRealTimeState()); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var siri = SiriTestHelper.of(env); + + assertEquals(RealTimeState.SCHEDULED, env.tripData(TRIP_1_ID).realTimeState()); + + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withCancellation(true) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); - assertEquals(RealTimeState.CANCELED, env.getTripTimesForTrip(TRIP_1_ID).getRealTimeState()); + assertEquals(RealTimeState.CANCELED, env.tripData(TRIP_1_ID).realTimeState()); } /** @@ -72,15 +87,17 @@ void testCancelTripWithMissingTimes() { @Test void testChangeQuayAndCancelScheduledTrip() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); + assertEquals( "SCHEDULED | A 0:00:10 0:00:11 | B 0:00:20 0:00:21", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); - changeQuayAndCancelTrip(env, TRIP_1_ID); + changeQuayAndCancelTrip(siri, TRIP_1_ID); assertEquals( "CANCELED | A 0:00:10 0:00:11 | B 0:00:20 0:00:21", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } @@ -91,12 +108,13 @@ void testChangeQuayAndCancelScheduledTrip() { @Test void testChangeQuayAndCancelAddedTrip() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var creation = new SiriEtBuilder(env.getDateTimeHelper()) + var creation = new SiriEtBuilder(env.localTimeParser()) .withEstimatedVehicleJourneyCode(ADDED_TRIP_ID) .withIsExtraJourney(true) - .withOperatorRef(TRIP_INPUT.operatorId()) - .withLineRef(TRIP_INPUT.routeId()) + .withOperatorRef(OPERATOR_ID) + .withLineRef(ROUTE_ID) .withEstimatedCalls(builder -> builder .call(STOP_A) @@ -107,24 +125,25 @@ void testChangeQuayAndCancelAddedTrip() { .departAimedExpected("0:00:21", "0:00:21") ) .buildEstimatedTimetableDeliveries(); - var creationResult = env.applyEstimatedTimetable(creation); + var creationResult = siri.applyEstimatedTimetable(creation); assertEquals(1, creationResult.successful()); assertEquals( "ADDED | A 0:00:10 0:00:11 | B 0:00:20 0:00:21", - env.getRealtimeTimetable(ADDED_TRIP_ID) + env.tripData(ADDED_TRIP_ID).showTimetable() ); - changeQuayAndCancelTrip(env, ADDED_TRIP_ID); + changeQuayAndCancelTrip(siri, ADDED_TRIP_ID); // the arrival time on first stop is adjusted to the departure time to avoid negative dwell time // conversely the departure time on last stop is adjusted to the arrival time assertEquals( "CANCELED | A 0:00:11 0:00:11 | B 0:00:20 0:00:20", - env.getRealtimeTimetable(ADDED_TRIP_ID) + env.tripData(ADDED_TRIP_ID).showTimetable() ); } - private void changeQuayAndCancelTrip(RealtimeTestEnvironment env, String tripId) { - var modification = new SiriEtBuilder(env.getDateTimeHelper()) + private void changeQuayAndCancelTrip(SiriTestHelper siri, String tripId) { + var modification = siri + .etBuilder() .withDatedVehicleJourneyRef(tripId) .withEstimatedCalls(builder -> builder @@ -136,14 +155,16 @@ private void changeQuayAndCancelTrip(RealtimeTestEnvironment env, String tripId) ) .buildEstimatedTimetableDeliveries(); - var modificationResult = env.applyEstimatedTimetable(modification); + var modificationResult = siri.applyEstimatedTimetable(modification); assertEquals(1, modificationResult.successful()); + TransitTestEnvironment transitTestEnvironment = siri.realtimeTestEnvironment(); assertEquals( "MODIFIED | A 0:00:15 0:00:15 | D 0:00:25 0:00:25", - env.getRealtimeTimetable(tripId) + transitTestEnvironment.tripData(tripId).showTimetable() ); - var cancellation = new SiriEtBuilder(env.getDateTimeHelper()) + var cancellation = siri + .etBuilder() .withDatedVehicleJourneyRef(tripId) .withCancellation(true) .withEstimatedCalls(builder -> @@ -156,7 +177,7 @@ private void changeQuayAndCancelTrip(RealtimeTestEnvironment env, String tripId) ) .buildEstimatedTimetableDeliveries(); - var cancellationResult = env.applyEstimatedTimetable(cancellation); + var cancellationResult = siri.applyEstimatedTimetable(cancellation); assertEquals(1, cancellationResult.successful()); } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancelledStopTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancelledStopTest.java index f2016d791d4..f54d22489c7 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancelledStopTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/cancellation/CancelledStopTest.java @@ -4,31 +4,33 @@ import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertSuccess; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class CancelledStopTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final RegularStop STOP_D = ENV_BUILDER.stop(STOP_D_ID); private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) .addStop(STOP_A, "0:01:00", "0:01:01") .addStop(STOP_B, "0:01:10", "0:01:11") - .addStop(STOP_D, "0:01:20", "0:01:21") - .build(); + .addStop(STOP_D, "0:01:20", "0:01:21"); @Test void testCancelStop() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -41,12 +43,12 @@ void testCancelStop() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertSuccess(result); assertEquals( "MODIFIED | A 0:01:01 0:01:01 | B [C] 0:01:10 0:01:11 | D 0:01:30 0:01:30", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extracall/ExtraCallTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extracall/ExtraCallTest.java index 77852524242..e4e9f5454da 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extracall/ExtraCallTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extracall/ExtraCallTest.java @@ -5,87 +5,98 @@ import java.util.List; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; +import org.opentripplanner.transit.model.network.Route; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; +import org.opentripplanner.updater.trip.SiriTestHelper; import org.opentripplanner.updater.trip.siri.SiriEtBuilder; import uk.org.siri.siri21.EstimatedTimetableDeliveryStructure; class ExtraCallTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final String ROUTE_ID = "route-id"; + + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stopAtStation(STOP_A_ID, "A"); private final RegularStop STOP_B = ENV_BUILDER.stopAtStation(STOP_B_ID, "B"); private final RegularStop STOP_C = ENV_BUILDER.stopAtStation(STOP_C_ID, "C"); private final RegularStop STOP_D = ENV_BUILDER.stopAtStation(STOP_D_ID, "D"); + private final Route ROUTE = ENV_BUILDER.route(ROUTE_ID); private final TripInput TRIP_1_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) + .withRoute(ROUTE) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); @Test void testExtraCall() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updateWithExtraCall(env); + var updates = updateWithExtraCall(siri); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); assertEquals( "MODIFIED | A [R] 0:00:15 0:00:15 | D 0:00:20 0:00:25 | B 0:00:33 0:00:33", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } @Test void testExtraCallMultipleTimes() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updateWithExtraCall(env); - env.applyEstimatedTimetable(updates); - var result = env.applyEstimatedTimetable(updates); + var updates = updateWithExtraCall(siri); + siri.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); assertEquals( "MODIFIED | A [R] 0:00:15 0:00:15 | D 0:00:20 0:00:25 | B 0:00:33 0:00:33", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } @Test void testExtraCallAndCancellation() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updateWithExtraCall(env); - env.applyEstimatedTimetable(updates); - var result = env.applyEstimatedTimetable(updates); + var updates = updateWithExtraCall(siri); + siri.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); - var cancellation = new SiriEtBuilder(env.getDateTimeHelper()) + var cancellation = new SiriEtBuilder(env.localTimeParser()) .withDatedVehicleJourneyRef(TRIP_1_ID) .withCancellation(true) .buildEstimatedTimetableDeliveries(); - var cancellationResult = env.applyEstimatedTimetable(cancellation); + var cancellationResult = siri.applyEstimatedTimetable(cancellation); assertEquals(1, cancellationResult.successful()); assertEquals(1, result.successful()); assertEquals( "CANCELED | A 0:00:10 0:00:11 | B 0:00:20 0:00:21", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } @Test void testExtraUnknownStop() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -100,7 +111,7 @@ void testExtraUnknownStop() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertFailure(UpdateError.UpdateErrorType.TOO_MANY_STOPS, result); } @@ -108,8 +119,10 @@ void testExtraUnknownStop() { @Test void testExtraCallSameNumberOfStops() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -122,7 +135,7 @@ void testExtraCallSameNumberOfStops() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertFailure(UpdateError.UpdateErrorType.INVALID_STOP_SEQUENCE, result); } @@ -130,8 +143,10 @@ void testExtraCallSameNumberOfStops() { @Test void testExtraCallAndIllegalChangeOfOtherStops() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -147,17 +162,16 @@ void testExtraCallAndIllegalChangeOfOtherStops() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertFailure(UpdateError.UpdateErrorType.STOP_MISMATCH, result); } - private List updateWithExtraCall( - RealtimeTestEnvironment env - ) { - return new SiriEtBuilder(env.getDateTimeHelper()) + private List updateWithExtraCall(SiriTestHelper siri) { + return siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) - .withLineRef(TRIP_1_INPUT.routeId()) + .withLineRef(ROUTE_ID) .withRecordedCalls(builder -> builder.call(STOP_A).departAimedActual("00:00:11", "00:00:15")) .withEstimatedCalls(builder -> builder diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extrajourney/ExtraJourneyTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extrajourney/ExtraJourneyTest.java index d88fb0b71b9..6aebbb4e26d 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extrajourney/ExtraJourneyTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/extrajourney/ExtraJourneyTest.java @@ -2,11 +2,13 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import static org.junit.jupiter.api.Assertions.assertNotNull; -import static org.opentripplanner.transit.model._data.TimetableRepositoryForTest.id; +import static org.opentripplanner.transit.model._data.FeedScopedIdForTestFactory.id; import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import org.junit.jupiter.api.Test; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.framework.FeedScopedId; import org.opentripplanner.transit.model.network.Route; import org.opentripplanner.transit.model.organization.Operator; @@ -17,52 +19,60 @@ import org.opentripplanner.transit.service.TransitService; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; +import org.opentripplanner.updater.trip.SiriTestHelper; import org.opentripplanner.updater.trip.siri.SiriEtBuilder; class ExtraJourneyTest implements RealtimeTestConstants { private static final String ADDED_TRIP_ID = "newJourney"; - private static final Route ROUTE_2 = TimetableRepositoryForTest.route("route-2") - .withOperator(Operator.of(id("o2")).withName("o").build()) - .build(); + private static final String OPERATOR_ID = "operatorId"; + private static final String ROUTE_ID = "routeId"; - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final RegularStop STOP_C = ENV_BUILDER.stop(STOP_C_ID); private final RegularStop STOP_D = ENV_BUILDER.stop(STOP_D_ID); + private final Operator OPERATOR = ENV_BUILDER.operator(OPERATOR_ID); + private final Route ROUTE = ENV_BUILDER.route(ROUTE_ID, OPERATOR); + private final TripInput TRIP_1_INPUT = TripInput.of(TRIP_1_ID) - .withRoute(ROUTE_2) + .withRoute(ROUTE) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); @Test void testAddJourneyWithExistingRoute() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - Route route = ROUTE_2; - int numPatternForRoute = env.getTransitService().findPatterns(route).size(); + Route route = ROUTE; + int numPatternForRoute = env.transitService().findPatterns(route).size(); - var updates = createValidAddedJourney(env).buildEstimatedTimetableDeliveries(); + var updates = createValidAddedJourney(siri).buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); - assertEquals("ADDED | C [R] 0:02 0:02 | D 0:04 0:04", env.getRealtimeTimetable(ADDED_TRIP_ID)); - assertEquals("SCHEDULED | C 0:01 0:01 | D 0:03 0:03", env.getScheduledTimetable(ADDED_TRIP_ID)); + assertEquals( + "ADDED | C [R] 0:02 0:02 | D 0:04 0:04", + env.tripData(ADDED_TRIP_ID).showTimetable() + ); + assertEquals( + "SCHEDULED | C 0:01 0:01 | D 0:03 0:03", + env.tripData(ADDED_TRIP_ID).showScheduledTimetable() + ); FeedScopedId tripId = id(ADDED_TRIP_ID); - TransitService transitService = env.getTransitService(); + TransitService transitService = env.transitService(); Trip trip = transitService.getTrip(tripId); assertNotNull(trip); assertNotNull(transitService.findPattern(trip)); assertNotNull(transitService.getTripOnServiceDate(tripId)); assertNotNull( - transitService.getTripOnServiceDate(new TripIdAndServiceDate(tripId, SERVICE_DATE)) + transitService.getTripOnServiceDate( + new TripIdAndServiceDate(tripId, env.defaultServiceDate()) + ) ); assertEquals( numPatternForRoute + 1, @@ -75,19 +85,26 @@ void testAddJourneyWithExistingRoute() { void testAddJourneyWithNewRoute() { // we actually don't need the trip, but it's the only way to add a route to the index var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); String newRouteRef = "new route ref"; - var updates = createValidAddedJourney(env) + var updates = createValidAddedJourney(siri) .withLineRef(newRouteRef) .buildEstimatedTimetableDeliveries(); - int numRoutes = env.getTransitService().listRoutes().size(); - var result = env.applyEstimatedTimetable(updates); + int numRoutes = env.transitService().listRoutes().size(); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); - assertEquals("ADDED | C [R] 0:02 0:02 | D 0:04 0:04", env.getRealtimeTimetable(ADDED_TRIP_ID)); - assertEquals("SCHEDULED | C 0:01 0:01 | D 0:03 0:03", env.getScheduledTimetable(ADDED_TRIP_ID)); - TransitService transitService = env.getTransitService(); + assertEquals( + "ADDED | C [R] 0:02 0:02 | D 0:04 0:04", + env.tripData(ADDED_TRIP_ID).showTimetable() + ); + assertEquals( + "SCHEDULED | C 0:01 0:01 | D 0:03 0:03", + env.tripData(ADDED_TRIP_ID).showScheduledTimetable() + ); + TransitService transitService = env.transitService(); assertEquals(numRoutes + 1, transitService.listRoutes().size()); FeedScopedId newRouteId = id(newRouteRef); Route newRoute = transitService.getRoute(newRouteId); @@ -99,29 +116,33 @@ void testAddJourneyWithNewRoute() { void testAddJourneyMultipleTimes() { // we actually don't need the trip, but it's the only way to add a route to the index var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); - var updates = createValidAddedJourney(env).buildEstimatedTimetableDeliveries(); + var siri = SiriTestHelper.of(env); - int numTrips = env.getTransitService().listTrips().size(); - var result1 = env.applyEstimatedTimetable(updates); + var updates = createValidAddedJourney(siri).buildEstimatedTimetableDeliveries(); + + int numTrips = env.transitService().listTrips().size(); + var result1 = siri.applyEstimatedTimetable(updates); assertEquals(1, result1.successful()); - assertEquals(numTrips + 1, env.getTransitService().listTrips().size()); - var result2 = env.applyEstimatedTimetable(updates); + assertEquals(numTrips + 1, env.transitService().listTrips().size()); + var result2 = siri.applyEstimatedTimetable(updates); assertEquals(1, result2.successful()); - assertEquals(numTrips + 1, env.getTransitService().listTrips().size()); + assertEquals(numTrips + 1, env.transitService().listTrips().size()); } @Test void testAddedJourneyWithInvalidScheduledData() { // we actually don't need the trip, but it's the only way to add a route to the index var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); // Create an extra journey with invalid planned data (travel back in time) // and valid real time data - var createExtraJourney = new SiriEtBuilder(env.getDateTimeHelper()) + var createExtraJourney = siri + .etBuilder() .withEstimatedVehicleJourneyCode(ADDED_TRIP_ID) .withIsExtraJourney(true) - .withOperatorRef(TRIP_1_INPUT.operatorId()) - .withLineRef(TRIP_1_INPUT.routeId()) + .withOperatorRef(OPERATOR_ID) + .withLineRef(ROUTE_ID) .withEstimatedCalls(builder -> builder .call(STOP_A) @@ -131,7 +152,7 @@ void testAddedJourneyWithInvalidScheduledData() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(createExtraJourney); + var result = siri.applyEstimatedTimetable(createExtraJourney); assertEquals(0, result.successful()); assertFailure(UpdateError.UpdateErrorType.NEGATIVE_HOP_TIME, result); } @@ -139,40 +160,50 @@ void testAddedJourneyWithInvalidScheduledData() { @Test void testReplaceJourney() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withEstimatedVehicleJourneyCode(ADDED_TRIP_ID) .withIsExtraJourney(true) // replace trip1 .withVehicleJourneyRef(TRIP_1_ID) - .withOperatorRef(TRIP_1_INPUT.operatorId()) - .withLineRef(TRIP_1_INPUT.routeId()) + .withOperatorRef(OPERATOR_ID) + .withLineRef(ROUTE_ID) .withRecordedCalls(builder -> builder.call(STOP_A).departAimedActual("00:01", "00:02")) .withEstimatedCalls(builder -> builder.call(STOP_C).arriveAimedExpected("00:03", "00:04")) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); - assertEquals("ADDED | A [R] 0:02 0:02 | C 0:04 0:04", env.getRealtimeTimetable(ADDED_TRIP_ID)); - assertEquals("SCHEDULED | A 0:01 0:01 | C 0:03 0:03", env.getScheduledTimetable(ADDED_TRIP_ID)); + assertEquals( + "ADDED | A [R] 0:02 0:02 | C 0:04 0:04", + env.tripData(ADDED_TRIP_ID).showTimetable() + ); + assertEquals( + "SCHEDULED | A 0:01 0:01 | C 0:03 0:03", + env.tripData(ADDED_TRIP_ID).showScheduledTimetable() + ); // Original trip should not get canceled - var originalTripTimes = env.getTripTimesForTrip(TRIP_1_ID); + var originalTripTimes = env.tripData(TRIP_1_ID).tripTimes(); assertEquals(RealTimeState.SCHEDULED, originalTripTimes.getRealTimeState()); } @Test void testReplaceJourneyWithoutEstimatedVehicleJourneyCode() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(ADDED_TRIP_ID) .withIsExtraJourney(true) .withVehicleJourneyRef(TRIP_1_ID) - .withOperatorRef(TRIP_1_INPUT.operatorId()) - .withLineRef(TRIP_1_INPUT.routeId()) + .withOperatorRef(OPERATOR_ID) + .withLineRef(ROUTE_ID) .withEstimatedCalls(builder -> builder .call(STOP_A) @@ -182,18 +213,19 @@ void testReplaceJourneyWithoutEstimatedVehicleJourneyCode() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); // TODO: this should have a more specific error type assertFailure(UpdateError.UpdateErrorType.UNKNOWN, result); } - private SiriEtBuilder createValidAddedJourney(RealtimeTestEnvironment env) { - return new SiriEtBuilder(env.getDateTimeHelper()) + private SiriEtBuilder createValidAddedJourney(SiriTestHelper siri) { + return siri + .etBuilder() .withEstimatedVehicleJourneyCode(ADDED_TRIP_ID) .withIsExtraJourney(true) - .withOperatorRef(TRIP_1_INPUT.operatorId()) - .withLineRef(TRIP_1_INPUT.routeId()) + .withOperatorRef(OPERATOR_ID) + .withLineRef(ROUTE_ID) .withRecordedCalls(builder -> builder.call(STOP_C).departAimedActual("00:01", "00:02")) .withEstimatedCalls(builder -> builder.call(STOP_D).arriveAimedExpected("00:03", "00:04")); } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/fuzzymatching/FuzzyTripMatchingTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/fuzzymatching/FuzzyTripMatchingTest.java index f5efa4c911d..5d1f863959c 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/fuzzymatching/FuzzyTripMatchingTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/fuzzymatching/FuzzyTripMatchingTest.java @@ -4,24 +4,23 @@ import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class FuzzyTripMatchingTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); /** * Update calls without changing the pattern. Fuzzy matching. @@ -29,9 +28,19 @@ class FuzzyTripMatchingTest implements RealtimeTestConstants { @Test void testUpdateJourneyWithFuzzyMatching() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updatedJourneyBuilder(env).buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetableWithFuzzyMatcher(updates); + var updates = siri + .etBuilder() + .withEstimatedCalls(builder -> + builder + .call(STOP_A) + .departAimedExpected("00:00:11", "00:00:15") + .call(STOP_B) + .arriveAimedExpected("00:00:20", "00:00:25") + ) + .buildEstimatedTimetableDeliveries(); + var result = siri.applyEstimatedTimetableWithFuzzyMatcher(updates); assertEquals(1, result.successful()); assertTripUpdated(env); } @@ -43,10 +52,12 @@ void testUpdateJourneyWithFuzzyMatching() { @Test void testUpdateJourneyWithFuzzyMatchingAndMissingAimedDepartureTime() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withFramedVehicleJourneyRef(builder -> - builder.withServiceDate(SERVICE_DATE).withVehicleJourneyRef("XXX") + builder.withServiceDate(env.defaultServiceDate()).withVehicleJourneyRef("XXX") ) .withEstimatedCalls(builder -> builder @@ -57,25 +68,15 @@ void testUpdateJourneyWithFuzzyMatchingAndMissingAimedDepartureTime() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetableWithFuzzyMatcher(updates); + var result = siri.applyEstimatedTimetableWithFuzzyMatcher(updates); assertEquals(0, result.successful(), "Should fail gracefully"); assertFailure(UpdateError.UpdateErrorType.NO_FUZZY_TRIP_MATCH, result); } - private SiriEtBuilder updatedJourneyBuilder(RealtimeTestEnvironment env) { - return new SiriEtBuilder(env.getDateTimeHelper()).withEstimatedCalls(builder -> - builder - .call(STOP_A) - .departAimedExpected("00:00:11", "00:00:15") - .call(STOP_B) - .arriveAimedExpected("00:00:20", "00:00:25") - ); - } - - private static void assertTripUpdated(RealtimeTestEnvironment env) { + private static void assertTripUpdated(TransitTestEnvironment env) { assertEquals( "UPDATED | A 0:00:15 0:00:15 | B 0:00:25 0:00:25", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidCallsTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidCallsTest.java index 207fbc1995c..5a021682c5d 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidCallsTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidCallsTest.java @@ -8,18 +8,17 @@ import java.util.Set; import org.junit.jupiter.api.Test; -import org.opentripplanner.transit.model._data.TimetableRepositoryForTest; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.transit.model.site.Station; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class InvalidCallsTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final String TRIP_1_ID = "TestTrip1"; private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); @@ -28,18 +27,18 @@ class InvalidCallsTest implements RealtimeTestConstants { private final Station STATION_A = STOP_A.getParentStation(); private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") .addStop(STOP_B, "0:00:20", "0:00:21") - .addStop(STOP_C, "0:00:40", "0:00:41") - .build(); - - private static final TimetableRepositoryForTest TEST_MODEL = TimetableRepositoryForTest.of(); + .addStop(STOP_C, "0:00:40", "0:00:41"); @Test void testTooFewCalls() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -50,7 +49,7 @@ void testTooFewCalls() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.failed()); assertEquals(Set.of(TOO_FEW_STOPS), result.failures().keySet()); @@ -59,8 +58,10 @@ void testTooFewCalls() { @Test void testTooManyCalls() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -75,7 +76,7 @@ void testTooManyCalls() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.failed()); assertEquals(Set.of(TOO_MANY_STOPS), result.failures().keySet()); @@ -84,8 +85,10 @@ void testTooManyCalls() { @Test void testMismatchedStop() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder @@ -98,7 +101,7 @@ void testMismatchedStop() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.failed()); assertEquals(Set.of(STOP_MISMATCH), result.failures().keySet()); @@ -107,21 +110,23 @@ void testMismatchedStop() { @Test void testUnknownStop() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withEstimatedCalls(builder -> builder - .call(STOP_A) + .call(STOP_A_ID) .departAimedExpected("00:00:10", "00:00:11") - .call(TEST_MODEL.stop("Unknown stop").withParentStation(STATION_A).build()) + .call("Unknown stop") .departAimedExpected("00:00:21", "00:00:25") - .call(STOP_C) + .call(STOP_C_ID) .departAimedExpected("00:00:40", "00:00:41") ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.failed()); assertEquals(Set.of(UNKNOWN_STOP), result.failures().keySet()); diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidStopPointRefTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidStopPointRefTest.java index 52beda471f5..0cf7f8ef3a1 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidStopPointRefTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/InvalidStopPointRefTest.java @@ -7,9 +7,9 @@ import org.junit.jupiter.params.ParameterizedTest; import org.junit.jupiter.params.provider.Arguments; import org.junit.jupiter.params.provider.MethodSource; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; import org.opentripplanner.updater.spi.UpdateError; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class InvalidStopPointRefTest { @@ -22,11 +22,13 @@ private static Stream cases() { @ParameterizedTest(name = "invalid id of ''{0}'', extraJourney={1}") @MethodSource("cases") void rejectEmptyStopPointRef(String invalidRef, boolean extraJourney) { - var env = RealtimeTestEnvironment.of().build(); + var env = TransitTestEnvironment.of().build(); + var siri = SiriTestHelper.of(env); // journey contains empty stop point ref elements // happens in the South Tyrolian feed: https://github.com/noi-techpark/odh-mentor-otp/issues/213 - var invalidJourney = new SiriEtBuilder(env.getDateTimeHelper()) + var invalidJourney = siri + .etBuilder() .withEstimatedVehicleJourneyCode("invalid-journey") .withOperatorRef("unknown-operator") .withLineRef("unknown-line") @@ -40,7 +42,7 @@ void rejectEmptyStopPointRef(String invalidRef, boolean extraJourney) { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(invalidJourney); + var result = siri.applyEstimatedTimetable(invalidJourney); assertEquals(0, result.successful()); assertFailure(UpdateError.UpdateErrorType.EMPTY_STOP_POINT_REF, result); } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NegativeTimesTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NegativeTimesTest.java index fa0c42101c1..60afc42ac6d 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NegativeTimesTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NegativeTimesTest.java @@ -3,37 +3,39 @@ import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class NegativeTimesTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final RegularStop STOP_C = ENV_BUILDER.stop(STOP_C_ID); private final TripInput TRIP_1_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); private final TripInput TRIP_2_INPUT = TripInput.of(TRIP_2_ID) + .withWithTripOnServiceDate(TRIP_2_ID) .addStop(STOP_A, "0:01:00", "0:01:01") .addStop(STOP_B, "0:01:10", "0:01:11") - .addStop(STOP_C, "0:01:20", "0:01:21") - .build(); + .addStop(STOP_C, "0:01:20", "0:01:21"); @Test void testNegativeHopTime() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withRecordedCalls(builder -> builder @@ -44,7 +46,7 @@ void testNegativeHopTime() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertFailure(UpdateError.UpdateErrorType.NEGATIVE_HOP_TIME, result); } @@ -52,8 +54,10 @@ void testNegativeHopTime() { @Test void testNegativeDwellTime() { var env = ENV_BUILDER.addTrip(TRIP_2_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_2_ID) .withRecordedCalls(builder -> builder @@ -67,7 +71,7 @@ void testNegativeDwellTime() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertFailure(UpdateError.UpdateErrorType.NEGATIVE_DWELL_TIME, result); } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NotMonitoredTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NotMonitoredTest.java index 78a3d2ec078..cb0cfcd488b 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NotMonitoredTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/rejection/NotMonitoredTest.java @@ -3,34 +3,32 @@ import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class NotMonitoredTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final TripInput TRIP_1_INPUT = TripInput.of(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); @Test void testNotMonitored() { var env = ENV_BUILDER.addTrip(TRIP_1_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) - .withMonitored(false) - .buildEstimatedTimetableDeliveries(); + var updates = siri.etBuilder().withMonitored(false).buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertFailure(UpdateError.UpdateErrorType.NOT_MONITORED, result); } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/QuayChangeTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/QuayChangeTest.java index e66d8921b0a..c4027591ca3 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/QuayChangeTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/QuayChangeTest.java @@ -3,24 +3,24 @@ import static org.junit.jupiter.api.Assertions.assertEquals; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; -import org.opentripplanner.updater.trip.siri.SiriEtBuilder; +import org.opentripplanner.updater.trip.SiriTestHelper; class QuayChangeTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stopAtStation(STOP_B_ID, STATION_OMEGA_ID); private final RegularStop STOP_C = ENV_BUILDER.stopAtStation(STOP_C_ID, STATION_OMEGA_ID); private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); /** * Change quay on a trip @@ -28,8 +28,10 @@ class QuayChangeTest implements RealtimeTestConstants { @Test void testChangeQuay() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = new SiriEtBuilder(env.getDateTimeHelper()) + var updates = siri + .etBuilder() .withDatedVehicleJourneyRef(TRIP_1_ID) .withRecordedCalls(builder -> builder.call(STOP_A).departAimedActual("00:00:11", "00:00:15")) .withEstimatedCalls(builder -> @@ -37,12 +39,12 @@ void testChangeQuay() { ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); assertEquals( "MODIFIED | A [R] 0:00:15 0:00:15 | C 0:00:33 0:00:33", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } } diff --git a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/UpdatedTimesTest.java b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/UpdatedTimesTest.java index 2c0f462629a..2d53fa83944 100644 --- a/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/UpdatedTimesTest.java +++ b/application/src/test/java/org/opentripplanner/updater/trip/siri/moduletests/update/UpdatedTimesTest.java @@ -4,24 +4,25 @@ import static org.opentripplanner.updater.spi.UpdateResultAssertions.assertFailure; import org.junit.jupiter.api.Test; +import org.opentripplanner.transit.model._data.TransitTestEnvironment; +import org.opentripplanner.transit.model._data.TransitTestEnvironmentBuilder; +import org.opentripplanner.transit.model._data.TripInput; import org.opentripplanner.transit.model.site.RegularStop; import org.opentripplanner.updater.spi.UpdateError; import org.opentripplanner.updater.trip.RealtimeTestConstants; -import org.opentripplanner.updater.trip.RealtimeTestEnvironment; -import org.opentripplanner.updater.trip.RealtimeTestEnvironmentBuilder; -import org.opentripplanner.updater.trip.TripInput; +import org.opentripplanner.updater.trip.SiriTestHelper; import org.opentripplanner.updater.trip.siri.SiriEtBuilder; class UpdatedTimesTest implements RealtimeTestConstants { - private final RealtimeTestEnvironmentBuilder ENV_BUILDER = RealtimeTestEnvironment.of(); + private final TransitTestEnvironmentBuilder ENV_BUILDER = TransitTestEnvironment.of(); private final RegularStop STOP_A = ENV_BUILDER.stop(STOP_A_ID); private final RegularStop STOP_B = ENV_BUILDER.stop(STOP_B_ID); private final TripInput TRIP_INPUT = TripInput.of(TRIP_1_ID) + .withWithTripOnServiceDate(TRIP_1_ID) .addStop(STOP_A, "0:00:10", "0:00:11") - .addStop(STOP_B, "0:00:20", "0:00:21") - .build(); + .addStop(STOP_B, "0:00:20", "0:00:21"); /** * Update calls without changing the pattern. Match trip by dated vehicle journey. @@ -29,16 +30,17 @@ class UpdatedTimesTest implements RealtimeTestConstants { @Test void testUpdateJourneyWithDatedVehicleJourneyRef() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updatedJourneyBuilder(env) + var updates = updatedJourneyBuilder(siri) .withDatedVehicleJourneyRef(TRIP_1_ID) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); assertTripUpdated(env); assertEquals( "UPDATED | A 0:00:15 0:00:15 | B 0:00:25 0:00:25", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } @@ -48,13 +50,14 @@ void testUpdateJourneyWithDatedVehicleJourneyRef() { @Test void testUpdateJourneyWithFramedVehicleJourneyRef() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updatedJourneyBuilder(env) + var updates = updatedJourneyBuilder(siri) .withFramedVehicleJourneyRef(builder -> - builder.withServiceDate(SERVICE_DATE).withVehicleJourneyRef(TRIP_1_ID) + builder.withServiceDate(env.defaultServiceDate()).withVehicleJourneyRef(TRIP_1_ID) ) .buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var result = siri.applyEstimatedTimetable(updates); assertEquals(1, result.successful()); assertTripUpdated(env); } @@ -65,27 +68,30 @@ void testUpdateJourneyWithFramedVehicleJourneyRef() { @Test void testUpdateJourneyWithoutJourneyRef() { var env = ENV_BUILDER.addTrip(TRIP_INPUT).build(); + var siri = SiriTestHelper.of(env); - var updates = updatedJourneyBuilder(env).buildEstimatedTimetableDeliveries(); - var result = env.applyEstimatedTimetable(updates); + var updates = updatedJourneyBuilder(siri).buildEstimatedTimetableDeliveries(); + var result = siri.applyEstimatedTimetable(updates); assertEquals(0, result.successful()); assertFailure(UpdateError.UpdateErrorType.TRIP_NOT_FOUND, result); } - private SiriEtBuilder updatedJourneyBuilder(RealtimeTestEnvironment env) { - return new SiriEtBuilder(env.getDateTimeHelper()).withEstimatedCalls(builder -> - builder - .call(STOP_A) - .departAimedExpected("00:00:11", "00:00:15") - .call(STOP_B) - .arriveAimedExpected("00:00:20", "00:00:25") - ); + private SiriEtBuilder updatedJourneyBuilder(SiriTestHelper siri) { + return siri + .etBuilder() + .withEstimatedCalls(builder -> + builder + .call(STOP_A) + .departAimedExpected("00:00:11", "00:00:15") + .call(STOP_B) + .arriveAimedExpected("00:00:20", "00:00:25") + ); } - private static void assertTripUpdated(RealtimeTestEnvironment env) { + private static void assertTripUpdated(TransitTestEnvironment env) { assertEquals( "UPDATED | A 0:00:15 0:00:15 | B 0:00:25 0:00:25", - env.getRealtimeTimetable(TRIP_1_ID) + env.tripData(TRIP_1_ID).showTimetable() ); } }