First pass at security price reference (#1388)

* First pass at security price reference

* Data cleanup

* Synth security fetching does better with a mic_code

* Update test suite

😭

* Update schema.rb

* Update generator.rb

test/models/security/price_test.rb

@@ -18,54 +18,63 @@ class Security::PriceTest < ActiveSupport::TestCase
 
   test "finds single security price in DB" do
     @provider.expects(:fetch_security_prices).never
+    security = securities(:aapl)
 
     price = security_prices(:one)
 
-    assert_equal price, Security::Price.find_price(ticker: price.ticker, date: price.date)
+    assert_equal price, Security::Price.find_price(security: security, date: price.date)
   end
 
   test "caches prices to DB" do
     expected_price = 314.34
-    @provider.expects(:fetch_security_prices)
-             .once
-             .returns(
-               OpenStruct.new(
-                 success?: true,
-                 prices: [ { date: Date.current, price: expected_price } ]
-               )
-             )
+    security = securities(:aapl)
+    tomorrow = Date.current + 1.day
 
-    fetched_rate = Security::Price.find_price(ticker: "NVDA", date: Date.current, cache: true)
-    refetched_rate = Security::Price.find_price(ticker: "NVDA", date: Date.current, cache: true)
+    @provider.expects(:fetch_security_prices)
+            .with(ticker: security.ticker, mic_code: security.exchange_mic, start_date: tomorrow, end_date: tomorrow)
+            .once
+            .returns(
+              OpenStruct.new(
+                success?: true,
+                prices: [ { date: tomorrow, price: expected_price } ]
+              )
+            )
+
+    fetched_rate = Security::Price.find_price(security: security, date: tomorrow, cache: true)
+    refetched_rate = Security::Price.find_price(security: security, date: tomorrow, cache: true)
 
     assert_equal expected_price, fetched_rate.price
     assert_equal expected_price, refetched_rate.price
   end
 
   test "returns nil if no price found in DB or from provider" do
+    security = securities(:aapl)
+    Security::Price.delete_all # Clear any existing prices
+
     @provider.expects(:fetch_security_prices)
-             .with(ticker: "NVDA", start_date: Date.current, end_date: Date.current)
+             .with(ticker: security.ticker, mic_code: security.exchange_mic, start_date: Date.current, end_date: Date.current)
              .once
              .returns(OpenStruct.new(success?: false))
 
-    assert_not Security::Price.find_price(ticker: "NVDA", date: Date.current)
+    assert_not Security::Price.find_price(security: security, date: Date.current)
   end
 
   test "returns nil if price not found in DB and provider disabled" do
     Security::Price.unstub(:security_prices_provider)
+    security = Security.new(ticker: "NVDA")
 
     with_env_overrides SYNTH_API_KEY: nil do
-      assert_not Security::Price.find_price(ticker: "NVDA", date: Date.current)
+      assert_not Security::Price.find_price(security: security, date: Date.current)
     end
   end
 
   test "fetches multiple dates at once" do
     @provider.expects(:fetch_security_prices).never
-
+    security = securities(:aapl)
     price1 = security_prices(:one) # AAPL today
     price2 = security_prices(:two) # AAPL yesterday
 
-    fetched_prices = Security::Price.find_prices(start_date: 1.day.ago.to_date, end_date: Date.current, ticker: "AAPL").sort_by(&:date)
+    fetched_prices = Security::Price.find_prices(security: security, start_date: 1.day.ago.to_date, end_date: Date.current).sort_by(&:date)
 
     assert_equal price1, fetched_prices[1]
     assert_equal price2, fetched_prices[0]
@@ -73,26 +82,33 @@ class Security::PriceTest < ActiveSupport::TestCase
 
   test "caches multiple prices to DB" do
     missing_price = 213.21
+    security = securities(:aapl)
+
     @provider.expects(:fetch_security_prices)
-             .with(ticker: "AAPL", start_date: 2.days.ago.to_date, end_date: 2.days.ago.to_date)
+             .with(ticker: security.ticker,
+                  mic_code: security.exchange_mic,
+                  start_date: 2.days.ago.to_date,
+                  end_date: 2.days.ago.to_date)
              .returns(OpenStruct.new(success?: true, prices: [ { date: 2.days.ago.to_date, price: missing_price } ]))
              .once
 
     price1 = security_prices(:one) # AAPL today
     price2 = security_prices(:two) # AAPL yesterday
 
-    fetched_prices = Security::Price.find_prices(ticker: "AAPL", start_date: 2.days.ago.to_date, end_date: Date.current, cache: true)
-    refetched_prices = Security::Price.find_prices(ticker: "AAPL", start_date: 2.days.ago.to_date, end_date: Date.current, cache: true)
+    fetched_prices = Security::Price.find_prices(security: security, start_date: 2.days.ago.to_date, end_date: Date.current, cache: true)
+    refetched_prices = Security::Price.find_prices(security: security, start_date: 2.days.ago.to_date, end_date: Date.current, cache: true)
 
     assert_equal [ missing_price, price2.price, price1.price ], fetched_prices.sort_by(&:date).map(&:price)
     assert_equal [ missing_price, price2.price, price1.price ], refetched_prices.sort_by(&:date).map(&:price)
+
+    assert Security::Price.exists?(security: security, date: 2.days.ago.to_date, price: missing_price)
   end
 
   test "returns empty array if no prices found in DB or from provider" do
     Security::Price.unstub(:security_prices_provider)
 
     with_env_overrides SYNTH_API_KEY: nil do
-      assert_equal [], Security::Price.find_prices(ticker: "NVDA", start_date: 10.days.ago.to_date, end_date: Date.current)
+      assert_equal [], Security::Price.find_prices(security: Security.new(ticker: "NVDA"), start_date: 10.days.ago.to_date, end_date: Date.current)
     end
   end
 end