improve mocking framework for tests

config/config.exs

@@ -22,6 +22,16 @@ import Config
 #
 
 config :realtime_signs,
+  location_engine: Engine.Locations,
+  config_engine: Engine.Config,
+  headway_engine: Engine.ScheduledHeadways,
+  prediction_engine: Engine.Predictions,
+  alert_engine: Engine.Alerts,
+  last_trip_engine: Engine.LastTrip,
+  bridge_engine: Engine.ChelseaBridge,
+  route_engine: Engine.Routes,
+  bus_prediction_engine: Engine.BusPredictions,
+  sign_updater: PaEss.Updater,
   http_client: HTTPoison,
   posts_log_dir: "log/posts/",
   time_zone: "America/New_York",

config/test.exs

@@ -1,6 +1,16 @@
 import Config
 
 config :realtime_signs,
+  location_engine: Engine.Locations.Mock,
+  config_engine: Engine.Config.Mock,
+  headway_engine: Engine.ScheduledHeadways.Mock,
+  prediction_engine: Engine.Predictions.Mock,
+  alert_engine: Engine.Alerts.Mock,
+  last_trip_engine: Engine.LastTrip.Mock,
+  bridge_engine: Engine.ChelseaBridge.Mock,
+  route_engine: Engine.Routes.Mock,
+  bus_prediction_engine: Engine.BusPredictions.Mock,
+  sign_updater: PaEss.Updater.Mock,
   http_client: Fake.HTTPoison,
   trip_update_url: "https://fake_update/mbta-gtfs-s3/fake_trip_update.json",
   sign_head_end_host: "signs.example.com",

lib/engine/alerts.ex

@@ -1,5 +1,4 @@
 defmodule Engine.Alerts do
-  @behaviour Engine.AlertsAPI
   use GenServer
   require Logger
   alias Engine.Alerts.Fetcher
@@ -25,7 +24,7 @@ defmodule Engine.Alerts do
     GenServer.start_link(__MODULE__, opts, name: name)
   end
 
-  @impl true
+  @callback max_stop_status([Fetcher.stop_id()], [Fetcher.route_id()]) :: Fetcher.stop_status()
   def max_stop_status(
         tables \\ %{stops_table: @stops_table, routes_table: @routes_table},
         stop_ids,
@@ -51,15 +50,15 @@ defmodule Engine.Alerts do
     end
   end
 
-  @spec stop_status(:ets.tab(), Fetcher.stop_id()) :: Fetcher.stop_status()
+  @callback stop_status(Fetcher.stop_id()) :: Fetcher.stop_status()
   def stop_status(ets_table_name \\ @stops_table, stop_id) do
     case :ets.lookup(ets_table_name, stop_id) do
       [{^stop_id, status}] -> status
       _ -> :none
     end
   end
 
-  @spec route_status(:ets.tab(), Fetcher.route_id()) :: Fetcher.stop_status()
+  @callback route_status(Fetcher.route_id()) :: Fetcher.stop_status()
   def route_status(ets_table_name \\ @routes_table, route_id) do
     case :ets.lookup(ets_table_name, route_id) do
       [{^route_id, status}] -> status

lib/engine/bus_predictions.ex

@@ -2,6 +2,7 @@ defmodule Engine.BusPredictions do
   use GenServer
   require Logger
 
+  @callback predictions_for_stop(String.t()) :: [Predictions.BusPrediction.t()]
   def predictions_for_stop(id) do
     case :ets.lookup(:bus_predictions, id) do
       [{^id, predictions}] -> predictions

lib/engine/chelsea_bridge.ex

@@ -2,6 +2,7 @@ defmodule Engine.ChelseaBridge do
   use GenServer
   require Logger
 
+  @callback bridge_status() :: %{raised: boolean() | nil, estimate: DateTime.t() | nil}
   def bridge_status() do
     case :ets.lookup(:bridge_status, :value) do
       [{:value, data}] -> data

lib/engine/config.ex

@@ -2,8 +2,6 @@ defmodule Engine.Config do
   @moduledoc """
   Manages the dynamic configurable pieces of the signs such as if they are on
   """
-  @behaviour Engine.ConfigAPI
-
   use GenServer
   require Logger
   alias Engine.Config.Headway
@@ -31,29 +29,30 @@ defmodule Engine.Config do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
-  @impl true
+  @callback sign_config(id :: String.t(), default :: Engine.Config.sign_config()) ::
+              Engine.Config.sign_config()
   def sign_config(table \\ @table_signs, sign_id, default) do
     case :ets.lookup(table, sign_id) do
       [{^sign_id, config}] when not is_nil(config) -> config
       _ -> default
     end
   end
 
-  @impl true
+  @callback headway_config(String.t(), DateTime.t()) :: Engine.Config.Headway.t() | nil
   def headway_config(table_name \\ @table_headways, headway_group, current_time) do
     time_period = Headway.current_time_period(current_time)
     Headways.get_headway(table_name, {headway_group, time_period})
   end
 
-  @impl true
+  @callback scu_migrated?(String.t()) :: boolean()
   def scu_migrated?(table_name \\ @table_scus_migrated, scu_id) do
     case :ets.lookup(table_name, scu_id) do
       [{^scu_id, value}] -> value
       _ -> false
     end
   end
 
-  @spec chelsea_bridge_config(:ets.tab()) :: :off | :auto
+  @callback chelsea_bridge_config() :: :off | :auto
   def chelsea_bridge_config(table_name \\ @table_chelsea_bridge) do
     case :ets.lookup(table_name, :status) do
       [{_, "auto"}] -> :auto

lib/engine/last_trip.ex

@@ -1,5 +1,4 @@
 defmodule Engine.LastTrip do
-  @behaviour Engine.LastTripAPI
   use GenServer
   require Logger
 
@@ -16,15 +15,15 @@ defmodule Engine.LastTrip do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
-  @impl true
+  @callback get_recent_departures(String.t()) :: map()
   def get_recent_departures(recent_departures_table \\ @recent_departures_table, stop_id) do
     case :ets.lookup(recent_departures_table, stop_id) do
       [{^stop_id, departures}] -> departures
       _ -> []
     end
   end
 
-  @impl true
+  @callback is_last_trip?(String.t()) :: boolean()
   def is_last_trip?(last_trips_table \\ @last_trips_table, trip_id) do
     case :ets.lookup(last_trips_table, trip_id) do
       [{^trip_id, _timestamp}] -> true

lib/engine/locations.ex

@@ -3,8 +3,6 @@ defmodule Engine.Locations do
   Maintains an up-to-date internal state of the realtime locations of vehicles in the system. Fetches
   from the GTFS-rt enhanced JSON file about once per second.
   """
-  @behaviour Engine.LocationsAPI
-
   use GenServer
   require Logger
   alias Signs.Utilities.EtsUtils
@@ -22,7 +20,7 @@ defmodule Engine.Locations do
     GenServer.start_link(__MODULE__, [], name: __MODULE__)
   end
 
-  @impl true
+  @callback for_vehicle(String.t()) :: Locations.Location.t()
   def for_vehicle(locations_table_id \\ @vehicle_locations_table, vehicle_id) do
     case :ets.lookup(locations_table_id, vehicle_id) do
       [{_, :none}] -> nil
@@ -31,7 +29,7 @@ defmodule Engine.Locations do
     end
   end
 
-  @impl true
+  @callback for_stop(String.t()) :: [Locations.Location.t()]
   def for_stop(stop_id) do
     case :ets.lookup(@stop_locations_table, stop_id) do
       [{^stop_id, locations}] -> locations

lib/engine/predictions.ex

@@ -7,8 +7,6 @@ defmodule Engine.Predictions do
   Offers a `for_stop/1` public interface to get a list of Predictions.Prediction's
   for a given GTFS stop.
   """
-  @behaviour Engine.PredictionsAPI
-
   use GenServer
   require Logger
   alias Signs.Utilities.EtsUtils
@@ -23,15 +21,15 @@ defmodule Engine.Predictions do
   end
 
   @doc "The upcoming predicted times a vehicle will be at this stop"
-  @impl true
+  @callback for_stop(String.t(), 0 | 1) :: [Predictions.Prediction.t()]
   def for_stop(predictions_table_id \\ :trip_updates, gtfs_stop_id, direction_id) do
     case :ets.lookup(predictions_table_id, {gtfs_stop_id, direction_id}) do
       [{{^gtfs_stop_id, ^direction_id}, predictions}] -> predictions
       _ -> []
     end
   end
 
-  @impl true
+  @callback revenue_vehicles() :: MapSet.t()
   def revenue_vehicles() do
     case :ets.lookup(:revenue_vehicles, :all) do
       [{:all, data}] -> data

lib/engine/routes.ex

@@ -2,7 +2,7 @@ defmodule Engine.Routes do
   use GenServer
   require Logger
 
-  @spec route_destination(String.t(), 0 | 1) :: String.t() | nil
+  @callback route_destination(String.t(), 0 | 1) :: String.t() | nil
   def route_destination(route_id, direction_id) do
     case :ets.lookup(:route_destinations, {route_id, direction_id}) do
       [{{^route_id, ^direction_id}, destination}] -> destination

lib/engine/scheduled_headways.ex

@@ -4,7 +4,6 @@ defmodule Engine.ScheduledHeadways do
   Initially we will quickly update any newly registered stop so that we have something to show,
   then over time we will update every stop once every hour to make sure we stay up to date.
   """
-  @behaviour Engine.ScheduledHeadwaysAPI
   use GenServer
   require Logger
   require Signs.Utilities.SignsConfig
@@ -79,7 +78,7 @@ defmodule Engine.ScheduledHeadways do
     :ets.select(table_name, pattern)
   end
 
-  @impl true
+  @callback get_first_scheduled_departure([binary]) :: nil | DateTime.t()
   def get_first_scheduled_departure(stop_ids) do
     get_first_last_departures(stop_ids)
     |> Enum.map(&elem(&1, 0))
@@ -89,7 +88,7 @@ defmodule Engine.ScheduledHeadways do
   @doc "Checks if the given time is after the first scheduled stop and before the last.
   A buffer of minutes (positive) is subtracted from the first time. so that headways are
   shown for a short time before the first train."
-  @impl true
+  @callback display_headways?([String.t()], DateTime.t(), Engine.Config.Headway.t()) :: boolean()
   def display_headways?(
         table \\ :scheduled_headways_first_last_departures,
         stop_ids,

lib/headway_analysis/server.ex

@@ -11,10 +11,7 @@ defmodule HeadwayAnalysis.Server do
     :sign_id,
     :headway_group,
     :stop_ids,
-    :vehicles_present,
-    :prediction_engine,
-    :config_engine,
-    :location_engine
+    :vehicles_present
   ]
   defstruct @enforce_keys
 
@@ -31,10 +28,7 @@ defmodule HeadwayAnalysis.Server do
        sign_id: config["id"],
        headway_group: config["source_config"]["headway_group"],
        stop_ids: Enum.map(config["source_config"]["sources"], & &1["stop_id"]),
-       vehicles_present: MapSet.new(),
-       prediction_engine: Engine.Predictions,
-       config_engine: Engine.Config,
-       location_engine: Engine.Locations
+       vehicles_present: MapSet.new()
      }}
   end
 
@@ -46,16 +40,16 @@ defmodule HeadwayAnalysis.Server do
       DateTime.utc_now() |> DateTime.shift_zone!(Application.get_env(:realtime_signs, :time_zone))
 
     {headway_low, headway_high} =
-      case state.config_engine.headway_config(state.headway_group, current_time) do
+      case RealtimeSigns.config_engine().headway_config(state.headway_group, current_time) do
         %Engine.Config.Headway{range_low: low, range_high: high} -> {low, high}
         nil -> {nil, nil}
       end
 
-    revenue_vehicles = state.prediction_engine.revenue_vehicles()
+    revenue_vehicles = RealtimeSigns.prediction_engine().revenue_vehicles()
 
     new_vehicles_present =
       for stop_id <- state.stop_ids,
-          location <- state.location_engine.for_stop(stop_id),
+          location <- RealtimeSigns.location_engine().for_stop(stop_id),
           location.status == :stopped_at,
           into: MapSet.new() do
         location.vehicle_id

lib/pa_ess/updater.ex

@@ -1,31 +1,32 @@
 defmodule PaEss.Updater do
-  @behaviour PaEss.UpdaterAPI
-
   require Logger
 
-  @impl true
+  @callback set_background_message(
+              Signs.Realtime.t() | Signs.Bus.t(),
+              Content.Message.value(),
+              Content.Message.value()
+            ) :: :ok
   def set_background_message(
         %{
           id: id,
           scu_id: scu_id,
           pa_ess_loc: pa_ess_loc,
           text_zone: text_zone,
-          default_mode: default_mode,
-          config_engine: config_engine
+          default_mode: default_mode
         },
         top,
         bottom
       ) do
     log_config =
-      case config_engine.sign_config(id, default_mode) do
+      case RealtimeSigns.config_engine().sign_config(id, default_mode) do
         mode when is_atom(mode) -> mode
         mode when is_tuple(mode) -> elem(mode, 0)
         _ -> nil
       end
 
     visual = zip_pages(top, bottom) |> format_pages()
     tag = create_tag()
-    scu_migrated? = config_engine.scu_migrated?(scu_id)
+    scu_migrated? = RealtimeSigns.config_engine().scu_migrated?(scu_id)
 
     log_meta = [
       sign_id: id,
@@ -51,21 +52,26 @@ defmodule PaEss.Updater do
     end
   end
 
-  @impl true
+  @callback play_message(
+              Signs.Realtime.t() | Signs.Bus.t(),
+              [Content.Audio.value()],
+              [Content.Audio.tts_value()],
+              [keyword()]
+            ) ::
+              :ok
   def play_message(
         %{
           id: id,
           scu_id: scu_id,
           pa_ess_loc: pa_ess_loc,
-          audio_zones: audio_zones,
-          config_engine: config_engine
+          audio_zones: audio_zones
         },
         audios,
         tts_audios,
         log_metas
       ) do
     tags = Enum.map(audios, fn _ -> create_tag() end)
-    scu_migrated? = config_engine.scu_migrated?(scu_id)
+    scu_migrated? = RealtimeSigns.config_engine().scu_migrated?(scu_id)
 
     log_metas =
       Enum.zip([tts_audios, tags, log_metas])