feat(SF2.0/UpcomingDepartures): Cross out other_stops on cancelled trips

Author: joshlarson

lib/dotcom/schedule_finder/upcoming_departures.ex

@@ -52,6 +52,7 @@ defmodule Dotcom.ScheduleFinder.UpcomingDepartures do
       """
 
       defstruct [
+        :cancelled?,
         :stop_id,
         :stop_name,
         :time
@@ -204,6 +205,7 @@ defmodule Dotcom.ScheduleFinder.UpcomingDepartures do
       stop = ps |> PredictedSchedule.stop()
 
       %OtherStop{
+        cancelled?: cancelled?(ps),
         stop_id: stop.id,
         stop_name: stop.name,
         time: prediction_time(ps)
@@ -227,6 +229,16 @@ defmodule Dotcom.ScheduleFinder.UpcomingDepartures do
   defp prediction_time(%PredictedSchedule{schedule: schedule}) when schedule != nil,
     do: prediction_time(schedule)
 
+  defp cancelled?(%PredictedSchedule{schedule: schedule, prediction: prediction})
+       when prediction != nil and schedule != nil do
+    schedule_time = prediction_time(schedule)
+    prediction_time = prediction_time(prediction)
+
+    schedule_time != nil && prediction_time == nil
+  end
+
+  defp cancelled?(_), do: false
+
   defp arrival_status(%{
          predicted_schedule: %PredictedSchedule{prediction: nil},
          route_type: :subway

lib/dotcom_web/live/schedule_finder_live.ex

@@ -552,7 +552,7 @@ defmodule DotcomWeb.ScheduleFinderLive do
       <div class={["grow", @stop_id == @other_stop.stop_id && "font-bold"]}>
         {@other_stop.stop_name}
       </div>
-      <div class={["ml-auto", @stop_id == @other_stop.stop_id && "font-bold"]}>
+      <div class={["ml-auto", @stop_id == @other_stop.stop_id && "font-bold", @other_stop.cancelled? && "line-through"]}>
         {format!(@other_stop.time, :hour_12_minutes)}
       </div>
     </.lined_list_item>

test/dotcom/schedule_finder/upcoming_departures_test.exs

@@ -1416,16 +1416,31 @@ defmodule Dotcom.ScheduleFinder.UpcomingDeparturesTest do
       trip_details = departure.trip_details
 
       assert trip_details.stops_before
-             |> Enum.map(&(&1 |> Map.take([:stop_id, :stop_name, :time]))) == [
-               %{stop_id: stop_before.id, stop_name: stop_before.name, time: arrival_time_before}
+             |> Enum.map(&(&1 |> Map.take([:cancelled?, :stop_id, :stop_name, :time]))) == [
+               %{
+                 cancelled?: false,
+                 stop_id: stop_before.id,
+                 stop_name: stop_before.name,
+                 time: arrival_time_before
+               }
              ]
 
-      assert trip_details.stop |> Map.take([:stop_id, :stop_name, :time]) ==
-               %{stop_id: stop.id, stop_name: stop.name, time: arrival_time}
+      assert trip_details.stop |> Map.take([:cancelled?, :stop_id, :stop_name, :time]) ==
+               %{
+                 cancelled?: false,
+                 stop_id: stop.id,
+                 stop_name: stop.name,
+                 time: arrival_time
+               }
 
       assert trip_details.stops_after
-             |> Enum.map(&(&1 |> Map.take([:stop_id, :stop_name, :time]))) == [
-               %{stop_id: stop_after.id, stop_name: stop_after.name, time: arrival_time_after}
+             |> Enum.map(&(&1 |> Map.take([:cancelled?, :stop_id, :stop_name, :time]))) == [
+               %{
+                 cancelled?: false,
+                 stop_id: stop_after.id,
+                 stop_name: stop_after.name,
+                 time: arrival_time_after
+               }
              ]
     end
 
@@ -1648,6 +1663,84 @@ defmodule Dotcom.ScheduleFinder.UpcomingDeparturesTest do
              ]
     end
 
+    test "shows an `other_stop` as cancelled if the time on its prediction is nil and the time on its schedule is non-nil" do
+      # Setup
+      now = Dotcom.Utils.DateTime.now()
+
+      route = Factories.Routes.Route.build(:route)
+      route_id = route.id
+
+      stop_ids =
+        Faker.Util.sample_uniq(2, fn -> FactoryHelpers.build(:id) end)
+
+      [stop, stop_after] =
+        stop_ids |> Enum.map(&Factories.Stops.Stop.build(:stop, id: &1))
+
+      trip_id = FactoryHelpers.build(:id)
+      trip = Factories.Schedules.Trip.build(:trip, id: trip_id)
+      direction_id = Faker.Util.pick([0, 1])
+
+      arrival_time_offsets =
+        Faker.Util.sample_uniq(2, fn -> Faker.random_between(2, 59) end) |> Enum.sort()
+
+      [arrival_time, arrival_time_after] =
+        arrival_time_offsets |> Enum.map(&(now |> DateTime.shift(minute: &1)))
+
+      expect(Predictions.Repo.Mock, :all, fn [
+                                               route: ^route_id,
+                                               direction_id: ^direction_id,
+                                               include_terminals: true
+                                             ] ->
+        [
+          Factories.Predictions.Prediction.build(:prediction,
+            arrival_time: arrival_time,
+            stop: stop,
+            trip: trip
+          ),
+          Factories.Predictions.Prediction.build(:prediction,
+            arrival_time: nil,
+            departure_time: nil,
+            stop: stop_after,
+            trip: trip
+          )
+        ]
+      end)
+
+      expect(Schedules.Repo.Mock, :by_route_ids, fn
+        [^route_id], direction_id: ^direction_id, date: _date ->
+          [
+            Factories.Schedules.Schedule.build(:schedule,
+              stop: stop,
+              trip: trip
+            ),
+            Factories.Schedules.Schedule.build(:schedule,
+              arrival_time: arrival_time_after,
+              departure_time: arrival_time_after |> DateTime.shift(second: 30),
+              time: arrival_time_after,
+              stop: stop_after,
+              trip: trip
+            )
+          ]
+      end)
+
+      # Exercise
+      departures =
+        UpcomingDepartures.upcoming_departures(%{
+          direction_id: direction_id,
+          now: now,
+          route: route,
+          stop_id: stop.id
+        })
+
+      # Verify
+      assert [departure] = departures
+      trip_details = departure.trip_details
+
+      assert [stop_after] = trip_details.stops_after
+      assert stop_after.time == arrival_time_after
+      assert stop_after.cancelled?
+    end
+
     test "does not include upcoming departures for other stops" do
       # Setup
       now = Dotcom.Utils.DateTime.now()