diff --git a/lib/trip_planner/parser.ex b/lib/trip_planner/parser.ex
index 8ee28696ea..20e2001b23 100644
--- a/lib/trip_planner/parser.ex
+++ b/lib/trip_planner/parser.ex
@@ -10,9 +10,11 @@ defmodule Dotcom.TripPlanner.Parser do
      MBTA system.
   """
 
-  alias TripPlan.{Itinerary, Leg, NamedPosition, PersonalDetail, TransitDetail}
   alias Dotcom.TripPlanner.FarePasses
   alias OpenTripPlannerClient.Schema
+  alias TripPlan.{Itinerary, Leg, NamedPosition, PersonalDetail, TransitDetail}
+
+  @stops_repo Application.compile_env!(:dotcom, :repo_modules)[:stops]
 
   @spec parse(Schema.Itinerary.t()) :: Itinerary.t()
   def parse(
@@ -166,15 +168,11 @@ defmodule Dotcom.TripPlanner.Parser do
 
   defp build_stop(
          %Schema.Stop{
-           gtfs_id: "mbta-ma-us:" <> gtfs_id,
-           name: name
+           gtfs_id: "mbta-ma-us:" <> gtfs_id
          },
          attributes
        ) do
-    %Stops.Stop{
-      id: gtfs_id,
-      name: name
-    }
+    @stops_repo.get(gtfs_id)
     |> struct(attributes)
   end
 
diff --git a/test/dotcom/trip_plan/alerts_test.exs b/test/dotcom/trip_plan/alerts_test.exs
index e5a5a8dd89..20f8ad5d33 100644
--- a/test/dotcom/trip_plan/alerts_test.exs
+++ b/test/dotcom/trip_plan/alerts_test.exs
@@ -3,24 +3,28 @@ defmodule Dotcom.TripPlan.AlertsTest do
 
   import Dotcom.TripPlan.Alerts
   import Mox
-  import Test.Support.Factories.TripPlanner.TripPlanner
 
-  alias Alerts.Alert
-  alias Alerts.InformedEntity, as: IE
+  alias Alerts.{Alert, InformedEntity}
+  alias Test.Support.Factories.{MBTA.Api, Stops.Stop, TripPlanner.TripPlanner}
   alias TripPlan.Itinerary
 
   setup :verify_on_exit!
 
   setup do
-    leg = build(:transit_leg)
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
+    leg = TripPlanner.build(:transit_leg)
 
     itinerary =
-      build(:itinerary,
+      TripPlanner.build(:itinerary,
         legs: [leg]
       )
 
     [route_id] = Itinerary.route_ids(itinerary)
     [trip_id] = Itinerary.trip_ids(itinerary)
+
     {:ok, %{itinerary: itinerary, route_id: route_id, trip_id: trip_id, route: leg.mode.route}}
   end
 
@@ -29,7 +33,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       expect(MBTA.Api.Mock, :get_json, fn "/trips/" <> id, [] ->
         %JsonApi{
           data: [
-            Test.Support.Factories.MBTA.Api.build(:trip_item, %{id: id})
+            Api.build(:trip_item, %{id: id})
           ]
         }
       end)
@@ -37,10 +41,10 @@ defmodule Dotcom.TripPlan.AlertsTest do
       good_alert =
         Alert.new(
           active_period: [valid_active_period(itinerary)],
-          informed_entity: [%IE{route: route_id}]
+          informed_entity: [%InformedEntity{route: route_id}]
         )
 
-      bad_alert = Alert.update(good_alert, informed_entity: [%IE{route: "not_valid"}])
+      bad_alert = Alert.update(good_alert, informed_entity: [%InformedEntity{route: "not_valid"}])
       assert_only_good_alert(good_alert, bad_alert, itinerary)
     end
 
@@ -48,7 +52,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       expect(MBTA.Api.Mock, :get_json, fn "/trips/" <> ^trip_id, [] ->
         %JsonApi{
           data: [
-            Test.Support.Factories.MBTA.Api.build(:trip_item, %{id: trip_id})
+            Api.build(:trip_item, %{id: trip_id})
           ]
         }
       end)
@@ -56,10 +60,10 @@ defmodule Dotcom.TripPlan.AlertsTest do
       good_alert =
         Alert.new(
           active_period: [valid_active_period(itinerary)],
-          informed_entity: [%IE{trip: trip_id}]
+          informed_entity: [%InformedEntity{trip: trip_id}]
         )
 
-      bad_alert = Alert.update(good_alert, informed_entity: [%IE{trip: "not_valid"}])
+      bad_alert = Alert.update(good_alert, informed_entity: [%InformedEntity{trip: "not_valid"}])
       assert_only_good_alert(good_alert, bad_alert, itinerary)
     end
 
@@ -70,7 +74,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       expect(MBTA.Api.Mock, :get_json, fn "/trips/" <> id, [] ->
         %JsonApi{
           data: [
-            Test.Support.Factories.MBTA.Api.build(:trip_item, %{
+            Api.build(:trip_item, %{
               id: id,
               attributes: %{"direction_id" => 1}
             })
@@ -81,11 +85,13 @@ defmodule Dotcom.TripPlan.AlertsTest do
       good_alert =
         Alert.new(
           active_period: [valid_active_period(itinerary)],
-          informed_entity: [%IE{route: route_id, direction_id: 1}]
+          informed_entity: [%InformedEntity{route: route_id, direction_id: 1}]
         )
 
       bad_alert =
-        Alert.update(good_alert, informed_entity: [%IE{route: route_id, direction_id: 0}])
+        Alert.update(good_alert,
+          informed_entity: [%InformedEntity{route: route_id, direction_id: 0}]
+        )
 
       assert_only_good_alert(good_alert, bad_alert, itinerary)
     end
@@ -97,7 +103,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       expect(MBTA.Api.Mock, :get_json, fn "/trips/" <> id, [] ->
         %JsonApi{
           data: [
-            Test.Support.Factories.MBTA.Api.build(:trip_item, %{id: id})
+            Api.build(:trip_item, %{id: id})
           ]
         }
       end)
@@ -105,10 +111,12 @@ defmodule Dotcom.TripPlan.AlertsTest do
       good_alert =
         Alert.new(
           active_period: [valid_active_period(itinerary)],
-          informed_entity: [%IE{route_type: route.type}]
+          informed_entity: [%InformedEntity{route_type: route.type}]
         )
 
-      bad_alert = Alert.update(good_alert, informed_entity: [%IE{route_type: route.type + 1}])
+      bad_alert =
+        Alert.update(good_alert, informed_entity: [%InformedEntity{route_type: route.type + 1}])
+
       assert_only_good_alert(good_alert, bad_alert, itinerary)
     end
 
@@ -116,7 +124,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       expect(MBTA.Api.Mock, :get_json, fn "/trips/" <> id, [] ->
         %JsonApi{
           data: [
-            Test.Support.Factories.MBTA.Api.build(:trip_item, %{id: id})
+            Api.build(:trip_item, %{id: id})
           ]
         }
       end)
@@ -126,11 +134,13 @@ defmodule Dotcom.TripPlan.AlertsTest do
       good_alert =
         Alert.new(
           active_period: [valid_active_period(itinerary)],
-          informed_entity: [%IE{stop: stop_id}]
+          informed_entity: [%InformedEntity{stop: stop_id}]
         )
 
       bad_alert =
-        Alert.update(good_alert, informed_entity: [%IE{stop: stop_id, route: "different route"}])
+        Alert.update(good_alert,
+          informed_entity: [%InformedEntity{stop: stop_id, route: "different route"}]
+        )
 
       assert_only_good_alert(good_alert, bad_alert, itinerary)
     end
@@ -139,7 +149,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       expect(MBTA.Api.Mock, :get_json, fn "/trips/" <> id, [] ->
         %JsonApi{
           data: [
-            Test.Support.Factories.MBTA.Api.build(:trip_item, %{id: id})
+            Api.build(:trip_item, %{id: id})
           ]
         }
       end)
@@ -147,7 +157,7 @@ defmodule Dotcom.TripPlan.AlertsTest do
       good_alert =
         Alert.new(
           active_period: [valid_active_period(itinerary)],
-          informed_entity: [%IE{route: route_id}]
+          informed_entity: [%InformedEntity{route: route_id}]
         )
 
       bad_alert = Alert.update(good_alert, active_period: [invalid_active_period(itinerary)])
diff --git a/test/dotcom/trip_plan/itinerary_row_list_test.exs b/test/dotcom/trip_plan/itinerary_row_list_test.exs
index 610fc3aa94..60ff7535c8 100644
--- a/test/dotcom/trip_plan/itinerary_row_list_test.exs
+++ b/test/dotcom/trip_plan/itinerary_row_list_test.exs
@@ -3,7 +3,8 @@ defmodule Dotcom.TripPlan.ItineraryRowListTest do
 
   import Dotcom.TripPlan.ItineraryRowList
   import Mox
-  import Test.Support.Factories.TripPlanner.TripPlanner
+
+  alias Test.Support.Factories.{Stops.Stop, TripPlanner.TripPlanner}
 
   @date_time ~N[2017-06-27T11:43:00]
 
@@ -23,7 +24,11 @@ defmodule Dotcom.TripPlan.ItineraryRowListTest do
         []
       end)
 
-      itinerary = build(:itinerary)
+      stub(Stops.Repo.Mock, :get, fn _ ->
+        Stop.build(:stop)
+      end)
+
+      itinerary = TripPlanner.build(:itinerary)
 
       stub(MBTA.Api.Mock, :get_json, fn "/trips" <> _, _ ->
         %JsonApi{data: [Test.Support.Factories.MBTA.Api.build(:trip_item)]}
@@ -33,14 +38,17 @@ defmodule Dotcom.TripPlan.ItineraryRowListTest do
     end
 
     test "ItineraryRow contains given stop name when no stop_id present" do
-      from = build(:stop_named_position, stop: nil)
-      to = build(:stop_named_position, stop: %Stops.Stop{id: "place-sstat"})
+      from = TripPlanner.build(:stop_named_position, stop: nil)
+      to = TripPlanner.build(:stop_named_position, stop: %Stops.Stop{id: "place-sstat"})
       date_time = ~N[2017-06-27T11:43:00]
 
       itinerary =
-        build(:itinerary,
+        TripPlanner.build(:itinerary,
           start: date_time,
-          legs: [build(:transit_leg, from: from), build(:transit_leg, to: to)]
+          legs: [
+            TripPlanner.build(:transit_leg, from: from),
+            TripPlanner.build(:transit_leg, to: to)
+          ]
         )
 
       itinerary_row_list = from_itinerary(itinerary)
@@ -105,7 +113,7 @@ defmodule Dotcom.TripPlan.ItineraryRowListTest do
     end
 
     test "Distance is given with personal steps", %{itinerary: itinerary} do
-      leg = build(:walking_leg)
+      leg = TripPlanner.build(:walking_leg)
       personal_itinerary = %{itinerary | legs: [leg]}
       row_list = from_itinerary(personal_itinerary)
 
@@ -132,12 +140,12 @@ defmodule Dotcom.TripPlan.ItineraryRowListTest do
     test "Does not replace to stop_id" do
       stop_id = Faker.Internet.slug()
       stop_name = Faker.Address.city()
-      to = build(:stop_named_position, stop: %Stops.Stop{id: stop_id})
+      to = TripPlanner.build(:stop_named_position, stop: %Stops.Stop{id: stop_id})
 
       itinerary = %TripPlan.Itinerary{
         start: nil,
         stop: nil,
-        legs: [build(:transit_leg, to: to)]
+        legs: [TripPlanner.build(:transit_leg, to: to)]
       }
 
       {name, id, _datetime, _alerts} =
diff --git a/test/dotcom/trip_plan/itinerary_row_test.exs b/test/dotcom/trip_plan/itinerary_row_test.exs
index e7fabef467..9c17c909b8 100644
--- a/test/dotcom/trip_plan/itinerary_row_test.exs
+++ b/test/dotcom/trip_plan/itinerary_row_test.exs
@@ -3,16 +3,23 @@ defmodule TripPlan.ItineraryRowTest do
 
   import Dotcom.TripPlan.ItineraryRow
   import Mox
-  import Test.Support.Factories.TripPlanner.TripPlanner
 
+  alias Alerts.{Alert, InformedEntity}
   alias Dotcom.TripPlan.ItineraryRow
   alias Routes.Route
-  alias Alerts.{Alert, InformedEntity}
-  alias Test.Support.Factories.MBTA.Api
+  alias Test.Support.Factories.{MBTA.Api, Stops.Stop, TripPlanner.TripPlanner}
   alias TripPlan.{Leg, NamedPosition, PersonalDetail}
 
   setup :verify_on_exit!
 
+  setup do
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
+    :ok
+  end
+
   describe "route_id/1" do
     test "returns the route id when a route is present" do
       row = %ItineraryRow{route: %Route{id: "route"}}
@@ -318,8 +325,12 @@ defmodule TripPlan.ItineraryRowTest do
   end
 
   describe "from_leg/3" do
-    @personal_leg build(:walking_leg)
-    @transit_leg build(:transit_leg)
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
+    @personal_leg TripPlanner.build(:walking_leg)
+    @transit_leg TripPlanner.build(:transit_leg)
 
     setup do
       stub(MBTA.Api.Mock, :get_json, fn path, _ ->
@@ -339,7 +350,7 @@ defmodule TripPlan.ItineraryRowTest do
     end
 
     test "returns an itinerary row from a Leg" do
-      leg = build(:transit_leg)
+      leg = TripPlanner.build(:transit_leg)
 
       stub(Stops.Repo.Mock, :get_parent, fn id ->
         %Stops.Stop{id: id}
diff --git a/test/dotcom/trip_plan/related_link_test.exs b/test/dotcom/trip_plan/related_link_test.exs
index 3f5b6aea43..a5cad6a72c 100644
--- a/test/dotcom/trip_plan/related_link_test.exs
+++ b/test/dotcom/trip_plan/related_link_test.exs
@@ -12,6 +12,10 @@ defmodule Dotcom.TripPlan.RelatedLinkTest do
   setup :verify_on_exit!
 
   setup do
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
     itinerary =
       build(:itinerary,
         legs: [build(:transit_leg)]
diff --git a/test/dotcom_web/views/trip_plan_view_test.exs b/test/dotcom_web/views/trip_plan_view_test.exs
index 85aae5f7d8..53bea13075 100644
--- a/test/dotcom_web/views/trip_plan_view_test.exs
+++ b/test/dotcom_web/views/trip_plan_view_test.exs
@@ -8,7 +8,7 @@ defmodule DotcomWeb.TripPlanViewTest do
 
   alias Fares.Fare
   alias Dotcom.TripPlan.{IntermediateStop, ItineraryRow, Query}
-  alias Test.Support.Factories.TripPlanner.TripPlanner
+  alias Test.Support.Factories.{Stops.Stop, TripPlanner.TripPlanner}
   alias TripPlan.{Itinerary, Leg, NamedPosition, TransitDetail}
 
   @highest_one_way_fare %Fares.Fare{
@@ -77,6 +77,10 @@ defmodule DotcomWeb.TripPlanViewTest do
   setup :verify_on_exit!
 
   setup do
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
     stub(MBTA.Api.Mock, :get_json, fn "/schedules/", [route: "Red", date: "1970-01-01"] ->
       {:error,
        [
diff --git a/test/trip_plan/itinerary_test.exs b/test/trip_plan/itinerary_test.exs
index 51cf938e89..c9605cc920 100644
--- a/test/trip_plan/itinerary_test.exs
+++ b/test/trip_plan/itinerary_test.exs
@@ -2,19 +2,24 @@ defmodule TripPlan.ItineraryTest do
   use ExUnit.Case, async: true
 
   import Mox
-  import Test.Support.Factories.TripPlanner.TripPlanner
   import TripPlan.Itinerary
 
-  alias TripPlan.{TransitDetail, Leg, PersonalDetail, TransitDetail}
+  alias Test
+  alias Test.Support.Factories.{Stops.Stop, TripPlanner.TripPlanner}
+  alias TripPlan.{Leg, PersonalDetail, TransitDetail}
 
-  @from build(:stop_named_position)
-  @to build(:stop_named_position)
-  @transit_leg build(:transit_leg, from: @from, to: @to)
+  @from TripPlanner.build(:stop_named_position)
+  @to TripPlanner.build(:stop_named_position)
 
   setup :verify_on_exit!
 
   setup do
-    itinerary = build(:itinerary, legs: [@transit_leg])
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
+    transit_leg = TripPlanner.build(:transit_leg, from: @from, to: @to)
+    itinerary = TripPlanner.build(:itinerary, legs: [transit_leg])
     %{itinerary: itinerary}
   end
 
@@ -75,8 +80,8 @@ defmodule TripPlan.ItineraryTest do
   describe "positions/1" do
     test "returns all named positions for the itinerary" do
       itinerary =
-        build(:itinerary,
-          legs: build_list(3, :walking_leg, from: @from, to: @to)
+        TripPlanner.build(:itinerary,
+          legs: TripPlanner.build_list(3, :walking_leg, from: @from, to: @to)
         )
 
       [first, second, third] = itinerary.legs
diff --git a/test/trip_plan/leg_test.exs b/test/trip_plan/leg_test.exs
index 6592b6df5f..e2613759eb 100644
--- a/test/trip_plan/leg_test.exs
+++ b/test/trip_plan/leg_test.exs
@@ -1,60 +1,72 @@
 defmodule TripPlan.LegTest do
   use ExUnit.Case, async: true
 
-  import Test.Support.Factories.TripPlanner.TripPlanner
+  import Mox
   import TripPlan.Leg
 
-  alias Test.Support.Factories.{Routes.Route, Stops.Stop}
+  alias Test.Support.Factories.{Routes.Route, Stops.Stop, TripPlanner.TripPlanner}
 
-  @from build(:stop_named_position)
-  @to build(:stop_named_position)
+  @from TripPlanner.build(:stop_named_position)
+  @to TripPlanner.build(:stop_named_position)
   @start ~N[2017-01-01T00:00:00]
   @stop ~N[2017-01-01T23:59:59]
-  @personal_leg build(:walking_leg,
-                  from: @from,
-                  to: @to,
-                  start: @start,
-                  stop: @stop
-                )
-  @transit_leg build(:transit_leg,
-                 from: @from,
-                 to: @to,
-                 start: @start,
-                 stop: @stop
-               )
+
+  setup do
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
+    personal_leg =
+      TripPlanner.build(:walking_leg,
+        from: @from,
+        to: @to,
+        start: @start,
+        stop: @stop
+      )
+
+    transit_leg =
+      TripPlanner.build(:transit_leg,
+        from: @from,
+        to: @to,
+        start: @start,
+        stop: @stop
+      )
+
+    {:ok, %{personal_leg: personal_leg, transit_leg: transit_leg}}
+  end
 
   describe "route_id/1" do
-    test "returns {:ok, id} for a transit leg" do
-      route_id = @transit_leg.mode.route.id
-      assert {:ok, ^route_id} = route_id(@transit_leg)
+    test "returns {:ok, id} for a transit leg", context do
+      route_id = context.transit_leg.mode.route.id
+      assert {:ok, ^route_id} = route_id(context.transit_leg)
     end
 
-    test "returns :error for a personal leg" do
-      assert :error = route_id(@personal_leg)
+    test "returns :error for a personal leg", context do
+      assert :error = route_id(context.personal_leg)
     end
   end
 
   describe "trip_id/1" do
-    test "returns {:ok, id} for a transit leg" do
-      trip_id = @transit_leg.mode.trip_id
-      assert {:ok, ^trip_id} = trip_id(@transit_leg)
+    test "returns {:ok, id} for a transit leg", context do
+      trip_id = context.transit_leg.mode.trip_id
+      assert {:ok, ^trip_id} = trip_id(context.transit_leg)
     end
 
-    test "returns :error for a personal leg" do
-      assert :error = trip_id(@personal_leg)
+    test "returns :error for a personal leg", context do
+      assert :error = trip_id(context.personal_leg)
     end
   end
 
   describe "stop_ids/1" do
-    test "returns the stop IDs @from and @to" do
-      assert [@from.stop.id, @to.stop.id] == stop_ids(@transit_leg)
+    test "returns the stop IDs @from and @to", context do
+      assert [@from.stop.id, @to.stop.id] == stop_ids(context.transit_leg)
     end
 
     test "ignores nil stop IDs" do
       from = %{@from | stop: nil}
 
       personal_leg =
-        build(:walking_leg,
+        TripPlanner.build(:walking_leg,
           from: from,
           to: @to,
           start: @start,
@@ -66,23 +78,23 @@ defmodule TripPlan.LegTest do
   end
 
   describe "transit?/1" do
-    test "Returns true for transit leg" do
-      assert transit?(@transit_leg)
+    test "Returns true for transit leg", context do
+      assert transit?(context.transit_leg)
     end
 
-    test "Returns false for personal leg" do
-      refute transit?(@personal_leg)
+    test "Returns false for personal leg", context do
+      refute transit?(context.personal_leg)
     end
   end
 
   describe "fare_complete_transit_leg?/1" do
     test "returns false for commuter rail routes between stops without commuter rail zone information" do
-      cr_mode = build(:transit_detail, route: Route.build(:route, %{type: 2}))
+      cr_mode = TripPlanner.build(:transit_detail, route: Route.build(:route, %{type: 2}))
 
       leg =
-        build(:transit_leg,
-          from: build(:stop_named_position, stop: Stop.build(:stop, %{zone: "2"})),
-          to: build(:stop_named_position, stop: Stop.build(:stop, %{zone: "5"})),
+        TripPlanner.build(:transit_leg,
+          from: TripPlanner.build(:stop_named_position, stop: Stop.build(:stop, %{zone: "2"})),
+          to: TripPlanner.build(:stop_named_position, stop: Stop.build(:stop, %{zone: "5"})),
           start: @start,
           stop: @stop,
           mode: cr_mode
@@ -91,9 +103,9 @@ defmodule TripPlan.LegTest do
       assert fare_complete_transit_leg?(leg)
 
       bad_leg =
-        build(:transit_leg,
-          from: build(:stop_named_position, stop: Stop.build(:stop, zone: nil)),
-          to: build(:stop_named_position, stop: Stop.build(:stop, zone: nil)),
+        TripPlanner.build(:transit_leg,
+          from: TripPlanner.build(:stop_named_position, stop: Stop.build(:stop, zone: nil)),
+          to: TripPlanner.build(:stop_named_position, stop: Stop.build(:stop, zone: nil)),
           start: @start,
           stop: @stop,
           mode: cr_mode
@@ -104,18 +116,18 @@ defmodule TripPlan.LegTest do
   end
 
   describe "stop_is_silver_line_airport?/2" do
-    test "stop is not the Silver Line" do
-      assert stop_is_silver_line_airport?([@transit_leg], :from) == false
+    test "stop is not the Silver Line", context do
+      assert stop_is_silver_line_airport?([context.transit_leg], :from) == false
     end
 
     test "stop is the Silver Line" do
       leg =
-        build(:transit_leg,
-          from: build(:stop_named_position, stop: Stop.build(:stop, %{id: "17091"})),
+        TripPlanner.build(:transit_leg,
+          from: TripPlanner.build(:stop_named_position, stop: Stop.build(:stop, %{id: "17091"})),
           to: @to,
           start: @start,
           stop: @stop,
-          mode: build(:transit_detail, route: %Routes.Route{id: "741"})
+          mode: TripPlanner.build(:transit_detail, route: %Routes.Route{id: "741"})
         )
 
       assert stop_is_silver_line_airport?([leg], :from) == true
diff --git a/test/trip_plan/transfer_test.exs b/test/trip_plan/transfer_test.exs
index 512716556c..7da55e5230 100644
--- a/test/trip_plan/transfer_test.exs
+++ b/test/trip_plan/transfer_test.exs
@@ -3,20 +3,28 @@ defmodule TransferTest do
 
   import Mox
   import TripPlan.Transfer
-  import Test.Support.Factories.TripPlanner.TripPlanner
 
+  alias Test.Support.Factories.{Stops.Stop, TripPlanner.TripPlanner}
   alias TripPlan.{Leg, NamedPosition, PersonalDetail, TransitDetail}
 
   setup :verify_on_exit!
 
+  setup do
+    stub(Stops.Repo.Mock, :get, fn _ ->
+      Stop.build(:stop)
+    end)
+
+    :ok
+  end
+
   describe "maybe_transfer?/1 correctly identifies the potential presence of a transfer [assumes single ride media]" do
-    defp bus_leg, do: build(:bus_leg)
-    defp subway_leg, do: build(:subway_leg)
-    defp cr_leg, do: build(:cr_leg)
-    defp ferry_leg, do: build(:ferry_leg)
-    defp xp_leg, do: build(:express_bus_leg)
-    defp sl_rapid_leg, do: build(:sl_rapid_leg)
-    defp shuttle_leg, do: build(:shuttle_leg)
+    defp bus_leg, do: TripPlanner.build(:bus_leg)
+    defp subway_leg, do: TripPlanner.build(:subway_leg)
+    defp cr_leg, do: TripPlanner.build(:cr_leg)
+    defp ferry_leg, do: TripPlanner.build(:ferry_leg)
+    defp xp_leg, do: TripPlanner.build(:express_bus_leg)
+    defp sl_rapid_leg, do: TripPlanner.build(:sl_rapid_leg)
+    defp shuttle_leg, do: TripPlanner.build(:shuttle_leg)
 
     test "if from or to is nil" do
       refute [nil, nil] |> maybe_transfer?