Start and end balance anchors for historical account balances (#2455)

* Add kind field to valuation

* Fix schema conflict

* Add kind to valuation

* Scaffold opening balance manager

* Opening balance manager implementation

* Update account import to use opening balance manager + tests

* Update account to use opening balance manager

* Fix test assertions, usage of current balance manager

* Lint fixes

* Add Opening Balance manager, add tests to forward calculator

* Add credit card to "all cash" designation

* Simplify valuation model

* Add current balance manager with tests

* Add current balance logic to reverse calculator and plaid sync

* Tweaks to initial calc logic

* Ledger testing helper, tweak assertions for reverse calculator

* Update test assertions

* Extract balance transformer, simplify calculators

* Algo simplifications

* Final tweaks to calculators

* Cleanup

* Fix error, propagate sync errors up to parent

* Update migration script, valuation naming

test/controllers/credit_cards_controller_test.rb

@@ -11,8 +11,8 @@ class CreditCardsControllerTest < ActionDispatch::IntegrationTest
   test "creates with credit card details" do
     assert_difference -> { Account.count } => 1,
       -> { CreditCard.count } => 1,
-      -> { Valuation.count } => 2,
-      -> { Entry.count } => 2 do
+      -> { Valuation.count } => 1,
+      -> { Entry.count } => 1 do
       post credit_cards_path, params: {
         account: {
           name: "New Credit Card",

test/controllers/loans_controller_test.rb

@@ -11,8 +11,8 @@ class LoansControllerTest < ActionDispatch::IntegrationTest
   test "creates with loan details" do
     assert_difference -> { Account.count } => 1,
       -> { Loan.count } => 1,
-      -> { Valuation.count } => 2,
-      -> { Entry.count } => 2 do
+      -> { Valuation.count } => 1,
+      -> { Entry.count } => 1 do
       post loans_path, params: {
         account: {
           name: "New Loan",

test/controllers/vehicles_controller_test.rb

@@ -11,8 +11,8 @@ class VehiclesControllerTest < ActionDispatch::IntegrationTest
   test "creates with vehicle details" do
     assert_difference -> { Account.count } => 1,
       -> { Vehicle.count } => 1,
-      -> { Valuation.count } => 2,
-      -> { Entry.count } => 2 do
+      -> { Valuation.count } => 1,
+      -> { Entry.count } => 1 do
       post vehicles_path, params: {
         account: {
           name: "Vehicle",

test/fixtures/imports.yml

@@ -7,3 +7,8 @@ trade:
   family: dylan_family
   type: TradeImport
   status: pending
+
+account:
+  family: dylan_family
+  type: AccountImport
+  status: pending

test/fixtures/valuations.yml

@@ -1,2 +1,2 @@
-one: { }
-two: { }
+one:
+  kind: reconciliation

test/models/account/current_balance_manager_test.rb

@@ -0,0 +1,153 @@
+require "test_helper"
+
+class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
+  setup do
+    @connected_account = accounts(:connected)  # Connected account - can update current balance
+    @manual_account = accounts(:depository)  # Manual account - cannot update current balance
+  end
+
+  test "when no existing anchor, creates new anchor" do
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+
+    assert_difference -> { @connected_account.entries.count } => 1,
+                     -> { @connected_account.valuations.count } => 1 do
+      result = manager.set_current_balance(1000)
+
+      assert result.success?
+      assert result.changes_made?
+      assert_nil result.error
+    end
+
+    current_anchor = @connected_account.valuations.current_anchor.first
+    assert_not_nil current_anchor
+    assert_equal 1000, current_anchor.entry.amount
+    assert_equal "current_anchor", current_anchor.kind
+
+    entry = current_anchor.entry
+    assert_equal 1000, entry.amount
+    assert_equal Date.current, entry.date
+    assert_equal "Current balance", entry.name  # Depository type returns "Current balance"
+  end
+
+  test "updates existing anchor" do
+    # First create a current anchor
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+    result = manager.set_current_balance(1000)
+    assert result.success?
+
+    current_anchor = @connected_account.valuations.current_anchor.first
+    original_id = current_anchor.id
+    original_entry_id = current_anchor.entry.id
+
+    # Travel to tomorrow to ensure date change
+    travel_to Date.current + 1.day do
+      # Now update it
+      assert_no_difference -> { @connected_account.entries.count } do
+        assert_no_difference -> { @connected_account.valuations.count } do
+          result = manager.set_current_balance(2000)
+          assert result.success?
+          assert result.changes_made?
+        end
+      end
+
+      current_anchor.reload
+      assert_equal original_id, current_anchor.id # Same valuation record
+      assert_equal original_entry_id, current_anchor.entry.id # Same entry record
+      assert_equal 2000, current_anchor.entry.amount
+      assert_equal Date.current, current_anchor.entry.date # Should be updated to current date
+    end
+  end
+
+  test "when manual account, raises InvalidOperation error" do
+    manager = Account::CurrentBalanceManager.new(@manual_account)
+
+    error = assert_raises(Account::CurrentBalanceManager::InvalidOperation) do
+      manager.set_current_balance(1000)
+    end
+
+    assert_equal "Manual accounts cannot set current balance anchor. Set opening balance or use a reconciliation instead.", error.message
+
+    # Verify no current anchor was created
+    assert_nil @manual_account.valuations.current_anchor.first
+  end
+
+  test "when no changes made, returns success with no changes made" do
+    # First create a current anchor
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+    result = manager.set_current_balance(1000)
+    assert result.success?
+    assert result.changes_made?
+
+    # Try to set the same value on the same date
+    result = manager.set_current_balance(1000)
+
+    assert result.success?
+    assert_not result.changes_made?
+    assert_nil result.error
+  end
+
+  test "updates only amount when balance changes" do
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+
+    # Create initial anchor
+    result = manager.set_current_balance(1000)
+    assert result.success?
+
+    current_anchor = @connected_account.valuations.current_anchor.first
+    original_date = current_anchor.entry.date
+
+    # Update only the balance
+    result = manager.set_current_balance(1500)
+    assert result.success?
+    assert result.changes_made?
+
+    current_anchor.reload
+    assert_equal 1500, current_anchor.entry.amount
+    assert_equal original_date, current_anchor.entry.date # Date should remain the same if on same day
+  end
+
+  test "updates date when called on different day" do
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+
+    # Create initial anchor
+    result = manager.set_current_balance(1000)
+    assert result.success?
+
+    current_anchor = @connected_account.valuations.current_anchor.first
+    original_amount = current_anchor.entry.amount
+
+    # Travel to tomorrow and update with same balance
+    travel_to Date.current + 1.day do
+      result = manager.set_current_balance(1000)
+      assert result.success?
+      assert result.changes_made? # Should be true because date changed
+
+      current_anchor.reload
+      assert_equal original_amount, current_anchor.entry.amount
+      assert_equal Date.current, current_anchor.entry.date # Should be updated to new current date
+    end
+  end
+
+  test "current_balance returns balance from current anchor" do
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+
+    # Create a current anchor
+    manager.set_current_balance(1500)
+
+    # Should return the anchor's balance
+    assert_equal 1500, manager.current_balance
+
+    # Update the anchor
+    manager.set_current_balance(2500)
+
+    # Should return the updated balance
+    assert_equal 2500, manager.current_balance
+  end
+
+  test "current_balance falls back to account balance when no anchor exists" do
+    manager = Account::CurrentBalanceManager.new(@connected_account)
+
+    # When no current anchor exists, should fall back to account.balance
+    assert_equal @connected_account.balance, manager.current_balance
+  end
+end

test/models/account/entry_test.rb

@@ -17,7 +17,7 @@ class EntryTest < ActiveSupport::TestCase
     existing_valuation = entries :valuation
 
     new_valuation = Entry.new \
-      entryable: Valuation.new,
+      entryable: Valuation.new(kind: "reconciliation"),
       account: existing_valuation.account,
       date: existing_valuation.date, # invalid
       currency: existing_valuation.currency,

test/models/account/opening_balance_manager_test.rb

@@ -0,0 +1,252 @@
+require "test_helper"
+
+class Account::OpeningBalanceManagerTest < ActiveSupport::TestCase
+  setup do
+    @depository_account = accounts(:depository)
+    @investment_account = accounts(:investment)
+  end
+
+  test "when no existing anchor, creates new anchor" do
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+
+    assert_difference -> { @depository_account.entries.count } => 1,
+                     -> { @depository_account.valuations.count } => 1 do
+      result = manager.set_opening_balance(
+        balance: 1000,
+        date: 1.year.ago.to_date
+      )
+
+      assert result.success?
+      assert result.changes_made?
+      assert_nil result.error
+    end
+
+    opening_anchor = @depository_account.valuations.opening_anchor.first
+    assert_not_nil opening_anchor
+    assert_equal 1000, opening_anchor.entry.amount
+    assert_equal "opening_anchor", opening_anchor.kind
+
+    entry = opening_anchor.entry
+    assert_equal 1000, entry.amount
+    assert_equal 1.year.ago.to_date, entry.date
+    assert_equal "Opening balance", entry.name
+  end
+
+  test "when no existing anchor, creates with provided balance" do
+    # Test with Depository account (should default to balance)
+    depository_manager = Account::OpeningBalanceManager.new(@depository_account)
+
+    assert_difference -> { @depository_account.valuations.count } => 1 do
+      result = depository_manager.set_opening_balance(balance: 2000)
+      assert result.success?
+      assert result.changes_made?
+    end
+
+    depository_anchor = @depository_account.valuations.opening_anchor.first
+    assert_equal 2000, depository_anchor.entry.amount
+
+    # Test with Investment account (should default to 0)
+    investment_manager = Account::OpeningBalanceManager.new(@investment_account)
+
+    assert_difference -> { @investment_account.valuations.count } => 1 do
+      result = investment_manager.set_opening_balance(balance: 5000)
+      assert result.success?
+      assert result.changes_made?
+    end
+
+    investment_anchor = @investment_account.valuations.opening_anchor.first
+    assert_equal 5000, investment_anchor.entry.amount
+  end
+
+  test "when no existing anchor and no date provided, provides default based on account type" do
+    # Test with recent entry (less than 2 years ago)
+    @depository_account.entries.create!(
+      date: 30.days.ago.to_date,
+      name: "Test transaction",
+      amount: 100,
+      currency: "USD",
+      entryable: Transaction.new
+    )
+
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+
+    assert_difference -> { @depository_account.valuations.count } => 1 do
+      result = manager.set_opening_balance(balance: 1500)
+      assert result.success?
+      assert result.changes_made?
+    end
+
+    opening_anchor = @depository_account.valuations.opening_anchor.first
+    # Default should be MIN(1 day before oldest entry, 2 years ago) = 2 years ago
+    assert_equal 2.years.ago.to_date, opening_anchor.entry.date
+
+    # Test with old entry (more than 2 years ago)
+    loan_account = accounts(:loan)
+    loan_account.entries.create!(
+      date: 3.years.ago.to_date,
+      name: "Old transaction",
+      amount: 100,
+      currency: "USD",
+      entryable: Transaction.new
+    )
+
+    loan_manager = Account::OpeningBalanceManager.new(loan_account)
+
+    assert_difference -> { loan_account.valuations.count } => 1 do
+      result = loan_manager.set_opening_balance(balance: 5000)
+      assert result.success?
+      assert result.changes_made?
+    end
+
+    loan_anchor = loan_account.valuations.opening_anchor.first
+    # Default should be MIN(3 years ago - 1 day, 2 years ago) = 3 years ago - 1 day
+    assert_equal (3.years.ago.to_date - 1.day), loan_anchor.entry.date
+
+    # Test with account that has no entries
+    property_account = accounts(:property)
+    manager_no_entries = Account::OpeningBalanceManager.new(property_account)
+
+    assert_difference -> { property_account.valuations.count } => 1 do
+      result = manager_no_entries.set_opening_balance(balance: 3000)
+      assert result.success?
+      assert result.changes_made?
+    end
+
+    opening_anchor_no_entries = property_account.valuations.opening_anchor.first
+    # Default should be 2 years ago when no entries exist
+    assert_equal 2.years.ago.to_date, opening_anchor_no_entries.entry.date
+  end
+
+  test "updates existing anchor" do
+    # First create an opening anchor
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: 6.months.ago.to_date
+    )
+    assert result.success?
+
+    opening_anchor = @depository_account.valuations.opening_anchor.first
+    original_id = opening_anchor.id
+    original_entry_id = opening_anchor.entry.id
+
+    # Now update it
+    assert_no_difference -> { @depository_account.entries.count } do
+      assert_no_difference -> { @depository_account.valuations.count } do
+        result = manager.set_opening_balance(
+          balance: 2000,
+          date: 8.months.ago.to_date
+        )
+        assert result.success?
+        assert result.changes_made?
+      end
+    end
+
+    opening_anchor.reload
+    assert_equal original_id, opening_anchor.id # Same valuation record
+    assert_equal original_entry_id, opening_anchor.entry.id # Same entry record
+    assert_equal 2000, opening_anchor.entry.amount
+    assert_equal 2000, opening_anchor.entry.amount
+    assert_equal 8.months.ago.to_date, opening_anchor.entry.date
+  end
+
+  test "when existing anchor and no date provided, only update balance" do
+    # First create an opening anchor
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: 3.months.ago.to_date
+    )
+    assert result.success?
+
+    opening_anchor = @depository_account.valuations.opening_anchor.first
+
+    # Update without providing date
+    result = manager.set_opening_balance(balance: 1500)
+    assert result.success?
+    assert result.changes_made?
+
+    opening_anchor.reload
+    assert_equal 1500, opening_anchor.entry.amount
+  end
+
+  test "when existing anchor and updating balance only, preserves original date" do
+    # First create an opening anchor with specific date
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+    original_date = 4.months.ago.to_date
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: original_date
+    )
+    assert result.success?
+
+    opening_anchor = @depository_account.valuations.opening_anchor.first
+
+    # Update without providing date
+    result = manager.set_opening_balance(balance: 2500)
+    assert result.success?
+    assert result.changes_made?
+
+    opening_anchor.reload
+    assert_equal 2500, opening_anchor.entry.amount
+    assert_equal original_date, opening_anchor.entry.date # Should remain unchanged
+  end
+
+  test "when date is equal to or greater than account's oldest entry, returns error result" do
+    # Create an entry with a specific date
+    oldest_date = 60.days.ago.to_date
+    @depository_account.entries.create!(
+      date: oldest_date,
+      name: "Test transaction",
+      amount: 100,
+      currency: "USD",
+      entryable: Transaction.new
+    )
+
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+
+    # Try to set opening balance on the same date as oldest entry
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: oldest_date
+    )
+
+    assert_not result.success?
+    assert_not result.changes_made?
+    assert_equal "Opening balance date must be before the oldest entry date", result.error
+
+    # Try to set opening balance after the oldest entry
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: oldest_date + 1.day
+    )
+
+    assert_not result.success?
+    assert_not result.changes_made?
+    assert_equal "Opening balance date must be before the oldest entry date", result.error
+
+    # Verify no opening anchor was created
+    assert_nil @depository_account.valuations.opening_anchor.first
+  end
+
+  test "when no changes made, returns success with no changes made" do
+    # First create an opening anchor
+    manager = Account::OpeningBalanceManager.new(@depository_account)
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: 2.months.ago.to_date
+    )
+    assert result.success?
+    assert result.changes_made?
+
+    # Try to set the same values
+    result = manager.set_opening_balance(
+      balance: 1000,
+      date: 2.months.ago.to_date
+    )
+
+    assert result.success?
+    assert_not result.changes_made?
+    assert_nil result.error
+  end
+end

test/models/account_import_test.rb

@@ -0,0 +1,92 @@
+require "test_helper"
+
+class AccountImportTest < ActiveSupport::TestCase
+  include ActiveJob::TestHelper, ImportInterfaceTest
+
+  setup do
+    @subject = @import = imports(:account)
+  end
+
+  test "import creates accounts with valuations" do
+    import_csv = <<~CSV
+      type,name,amount,currency
+      depository,Main Checking,1000.00,USD
+      depository,Savings Account,5000.00,USD
+    CSV
+
+    @import.update!(
+      raw_file_str: import_csv,
+      entity_type_col_label: "type",
+      name_col_label: "name",
+      amount_col_label: "amount",
+      currency_col_label: "currency"
+    )
+
+    @import.generate_rows_from_csv
+
+    # Create mappings for account types
+    @import.mappings.create! key: "depository", value: "Depository", type: "Import::AccountTypeMapping"
+
+    @import.reload
+
+    # Store initial counts
+    initial_account_count = Account.count
+    initial_entry_count = Entry.count
+    initial_valuation_count = Valuation.count
+
+    # Perform the import
+    @import.publish
+
+    # Check if import succeeded
+    if @import.failed?
+      fail "Import failed with error: #{@import.error}"
+    end
+
+    assert_equal "complete", @import.status
+
+    # Check the differences
+    assert_equal initial_account_count + 2, Account.count, "Expected 2 new accounts"
+    assert_equal initial_entry_count + 2, Entry.count, "Expected 2 new entries"
+    assert_equal initial_valuation_count + 2, Valuation.count, "Expected 2 new valuations"
+
+    # Verify accounts were created correctly
+    accounts = @import.accounts.order(:name)
+    assert_equal [ "Main Checking", "Savings Account" ], accounts.pluck(:name)
+    assert_equal [ 1000.00, 5000.00 ], accounts.map { |a| a.balance.to_f }
+
+    # Verify valuations were created with correct fields
+    accounts.each do |account|
+      valuation = account.valuations.last
+      assert_not_nil valuation
+      assert_equal "opening_anchor", valuation.kind
+      assert_equal account.balance, valuation.entry.amount
+    end
+  end
+
+  test "column_keys returns expected keys" do
+    assert_equal %i[entity_type name amount currency], @import.column_keys
+  end
+
+  test "required_column_keys returns expected keys" do
+    assert_equal %i[name amount], @import.required_column_keys
+  end
+
+  test "mapping_steps returns account type mapping" do
+    assert_equal [ Import::AccountTypeMapping ], @import.mapping_steps
+  end
+
+  test "dry_run returns expected counts" do
+    @import.rows.create!(
+      entity_type: "depository",
+      name: "Test Account",
+      amount: "1000.00",
+      currency: "USD"
+    )
+
+    assert_equal({ accounts: 1 }, @import.dry_run)
+  end
+
+  test "max_row_count is limited to 50" do
+    assert_equal 50, @import.max_row_count
+  end
+end

test/models/balance/forward_calculator_test.rb

@@ -1,129 +1,349 @@
 require "test_helper"
 
+# The "forward calculator" is used for all **manual** accounts where balance tracking is done through entries and NOT from an external data provider.
 class Balance::ForwardCalculatorTest < ActiveSupport::TestCase
-  include EntriesTestHelper
+  include LedgerTestingHelper
 
-  setup do
-    @account = families(:empty).accounts.create!(
-      name: "Test",
-      balance: 20000,
-      cash_balance: 20000,
-      currency: "USD",
-      accountable: Investment.new
-    )
-  end
-
-  test "balance generation respects user timezone and last generated date is current user date" do
-    # Simulate user in EST timezone
-    Time.use_zone("America/New_York") do
-      # Set current time to 1am UTC on Jan 5, 2025
-      # This would be 8pm EST on Jan 4, 2025 (user's time, and the last date we should generate balances for)
-      travel_to Time.utc(2025, 01, 05, 1, 0, 0)
-
-      # Create a valuation for Jan 3, 2025
-      create_valuation(account: @account, date: "2025-01-03", amount: 17000)
-
-      expected = [ [ "2025-01-02", 0 ], [ "2025-01-03", 17000 ], [ "2025-01-04", 17000 ] ]
-      calculated = Balance::ForwardCalculator.new(@account).calculate
-
-      assert_equal expected, calculated.map { |b| [ b.date.to_s, b.balance ] }
-    end
-  end
+  # ------------------------------------------------------------------------------------------------
+  # General tests for all account types
+  # ------------------------------------------------------------------------------------------------
 
   # When syncing forwards, we don't care about the account balance.  We generate everything based on entries, starting from 0.
   test "no entries sync" do
-    assert_equal 0, @account.balances.count
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: []
+    )
 
-    expected = [ 0, 0 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate
+    assert_equal 0, account.balances.count
 
-    assert_equal expected, calculated.map(&:balance)
+    calculated = Balance::ForwardCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 0, cash_balance: 0 } ]
+      ]
+    )
   end
 
-  test "valuations sync" do
-    create_valuation(account: @account, date: 4.days.ago.to_date, amount: 17000)
-    create_valuation(account: @account, date: 2.days.ago.to_date, amount: 19000)
+  # Our system ensures all manual accounts have an opening anchor (for UX), but we should be able to handle a missing anchor by starting at 0 (i.e. "fresh account with no history")
+  test "account without opening anchor starts at zero balance" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "transaction", date: 2.days.ago.to_date, amount: -1000 }
+      ]
+    )
 
-    expected = [ 0, 17000, 17000, 19000, 19000, 19000 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
+    calculated = Balance::ForwardCalculator.new(account).calculate
 
-    assert_equal expected, calculated
+    # Since we start at 0, this transaction (inflow) simply increases balance from 0 -> 1000
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 3.days.ago.to_date, { balance: 0, cash_balance: 0 } ],
+        [ 2.days.ago.to_date, { balance: 1000, cash_balance: 1000 } ]
+      ]
+    )
   end
 
-  test "transactions sync" do
-    create_transaction(account: @account, date: 4.days.ago.to_date, amount: -500) # income
-    create_transaction(account: @account, date: 2.days.ago.to_date, amount: 100) # expense
+  test "reconciliation valuation sets absolute balance before applying subsequent transactions" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "reconciliation", date: 3.days.ago.to_date, balance: 18000 },
+        { type: "transaction", date: 2.days.ago.to_date, amount: -1000 }
+      ]
+    )
 
-    expected = [ 0, 500, 500, 400, 400, 400 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
+    calculated = Balance::ForwardCalculator.new(account).calculate
 
-    assert_equal expected, calculated
+    # First valuation sets balance to 18000, then transaction increases balance to 19000
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 3.days.ago.to_date, { balance: 18000, cash_balance: 18000 } ],
+        [ 2.days.ago.to_date, { balance: 19000, cash_balance: 19000 } ]
+      ]
+    )
   end
 
-  test "multi-entry sync" do
-    create_transaction(account: @account, date: 8.days.ago.to_date, amount: -5000)
-    create_valuation(account: @account, date: 6.days.ago.to_date, amount: 17000)
-    create_transaction(account: @account, date: 6.days.ago.to_date, amount: -500)
-    create_transaction(account: @account, date: 4.days.ago.to_date, amount: -500)
-    create_valuation(account: @account, date: 3.days.ago.to_date, amount: 17000)
-    create_transaction(account: @account, date: 1.day.ago.to_date, amount: 100)
+  test "cash-only accounts (depository, credit card) use valuations where cash balance equals total balance" do
+    [ Depository, CreditCard ].each do |account_type|
+      account = create_account_with_ledger(
+        account: { type: account_type, balance: 10000, cash_balance: 10000, currency: "USD" },
+        entries: [
+          { type: "opening_anchor", date: 3.days.ago.to_date, balance: 17000 },
+          { type: "reconciliation", date: 2.days.ago.to_date, balance: 18000 }
+        ]
+      )
 
-    expected = [ 0, 5000, 5000, 17000, 17000, 17500, 17000, 17000, 16900, 16900 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
+      calculated = Balance::ForwardCalculator.new(account).calculate
 
-    assert_equal expected, calculated
+      assert_calculated_ledger_balances(
+        calculated_data: calculated,
+        expected_balances: [
+          [ 3.days.ago.to_date, { balance: 17000, cash_balance: 17000 } ],
+          [ 2.days.ago.to_date, { balance: 18000, cash_balance: 18000 } ]
+        ]
+      )
+    end
   end
 
-  test "multi-currency sync" do
-    ExchangeRate.create! date: 1.day.ago.to_date, from_currency: "EUR", to_currency: "USD", rate: 1.2
+  test "non-cash accounts (property, loan) use valuations where cash balance is always zero" do
+    [ Property, Loan ].each do |account_type|
+      account = create_account_with_ledger(
+        account: { type: account_type, balance: 10000, cash_balance: 10000, currency: "USD" },
+        entries: [
+          { type: "opening_anchor", date: 3.days.ago.to_date, balance: 17000 },
+          { type: "reconciliation", date: 2.days.ago.to_date, balance: 18000 }
+        ]
+      )
 
-    create_transaction(account: @account, date: 3.days.ago.to_date, amount: -100, currency: "USD")
-    create_transaction(account: @account, date: 2.days.ago.to_date, amount: -300, currency: "USD")
+      calculated = Balance::ForwardCalculator.new(account).calculate
 
-    # Transaction in different currency than the account's main currency
-    create_transaction(account: @account, date: 1.day.ago.to_date, amount: -500, currency: "EUR") # €500 * 1.2 = $600
-
-    expected = [ 0, 100, 400, 1000, 1000 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
+      assert_calculated_ledger_balances(
+        calculated_data: calculated,
+        expected_balances: [
+          [ 3.days.ago.to_date, { balance: 17000, cash_balance: 0.0 } ],
+          [ 2.days.ago.to_date, { balance: 18000, cash_balance: 0.0 } ]
+        ]
+      )
+    end
   end
 
-  test "holdings and trades sync" do
-    aapl = securities(:aapl)
+  test "mixed accounts (investment) use valuations where cash balance is total minus holdings" do
+    account = create_account_with_ledger(
+      account: { type: Investment, balance: 10000, cash_balance: 10000, currency: "USD" },
+      entries: [
+        { type: "opening_anchor", date: 3.days.ago.to_date, balance: 17000 },
+        { type: "reconciliation", date: 2.days.ago.to_date, balance: 18000 }
+      ]
+    )
 
-    # Account starts at a value of $5000
-    create_valuation(account: @account, date: 2.days.ago.to_date, amount: 5000)
+    # Without holdings, cash balance equals total balance
+    calculated = Balance::ForwardCalculator.new(account).calculate
 
-    # Share purchase reduces cash balance by $1000, but keeps overall balance same
-    create_trade(aapl, account: @account, qty: 10, date: 1.day.ago.to_date, price: 100)
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 3.days.ago.to_date, { balance: 17000, cash_balance: 17000 } ],
+        [ 2.days.ago.to_date, { balance: 18000, cash_balance: 18000 } ]
+      ]
+    )
+  end
 
-    Holding.create!(date: 1.day.ago.to_date, account: @account, security: aapl, qty: 10, price: 100, amount: 1000, currency: "USD")
-    Holding.create!(date: Date.current, account: @account, security: aapl, qty: 10, price: 100, amount: 1000, currency: "USD")
+  # ------------------------------------------------------------------------------------------------
+  # All Cash accounts (Depository, CreditCard)
+  # ------------------------------------------------------------------------------------------------
+
+  test "transactions on depository accounts affect cash balance" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "opening_anchor", date: 5.days.ago.to_date, balance: 20000 },
+        { type: "transaction", date: 4.days.ago.to_date, amount: -500 }, # income
+        { type: "transaction", date: 2.days.ago.to_date, amount: 100 } # expense
+      ]
+    )
+
+    calculated = Balance::ForwardCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 5.days.ago.to_date, { balance: 20000, cash_balance: 20000 } ],
+        [ 4.days.ago.to_date, { balance: 20500, cash_balance: 20500 } ],
+        [ 3.days.ago.to_date, { balance: 20500, cash_balance: 20500 } ],
+        [ 2.days.ago.to_date, { balance: 20400, cash_balance: 20400 } ]
+      ]
+    )
+  end
+
+
+  test "transactions on credit card accounts affect cash balance inversely" do
+    account = create_account_with_ledger(
+      account: { type: CreditCard, balance: 10000, cash_balance: 10000, currency: "USD" },
+      entries: [
+        { type: "opening_anchor", date: 5.days.ago.to_date, balance: 1000 },
+        { type: "transaction", date: 4.days.ago.to_date, amount: -500 }, # CC payment
+        { type: "transaction", date: 2.days.ago.to_date, amount: 100 } # expense
+      ]
+    )
+
+    calculated = Balance::ForwardCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 5.days.ago.to_date, { balance: 1000, cash_balance: 1000 } ],
+        [ 4.days.ago.to_date, { balance: 500, cash_balance: 500 } ],
+        [ 3.days.ago.to_date, { balance: 500, cash_balance: 500 } ],
+        [ 2.days.ago.to_date, { balance: 600, cash_balance: 600 } ]
+      ]
+    )
+  end
+
+  test "depository account with transactions and balance reconciliations" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "opening_anchor", date: 10.days.ago.to_date, balance: 20000 },
+        { type: "transaction", date: 8.days.ago.to_date, amount: -5000 },
+        { type: "reconciliation", date: 6.days.ago.to_date, balance: 17000 },
+        { type: "transaction", date: 6.days.ago.to_date, amount: -500 },
+        { type: "transaction", date: 4.days.ago.to_date, amount: -500 },
+        { type: "reconciliation", date: 3.days.ago.to_date, balance: 17000 },
+        { type: "transaction", date: 1.day.ago.to_date, amount: 100 }
+      ]
+    )
+
+    calculated = Balance::ForwardCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 10.days.ago.to_date, { balance: 20000, cash_balance: 20000 } ],
+        [ 9.days.ago.to_date, { balance: 20000, cash_balance: 20000 } ],
+        [ 8.days.ago.to_date, { balance: 25000, cash_balance: 25000 } ],
+        [ 7.days.ago.to_date, { balance: 25000, cash_balance: 25000 } ],
+        [ 6.days.ago.to_date, { balance: 17000, cash_balance: 17000 } ],
+        [ 5.days.ago.to_date, { balance: 17000, cash_balance: 17000 } ],
+        [ 4.days.ago.to_date, { balance: 17500, cash_balance: 17500 } ],
+        [ 3.days.ago.to_date, { balance: 17000, cash_balance: 17000 } ],
+        [ 2.days.ago.to_date, { balance: 17000, cash_balance: 17000 } ],
+        [ 1.day.ago.to_date, { balance: 16900, cash_balance: 16900 } ]
+      ]
+    )
+  end
+
+  test "accounts with transactions in multiple currencies convert to the account currency" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "opening_anchor", date: 4.days.ago.to_date, balance: 100 },
+        { type: "transaction", date: 3.days.ago.to_date, amount: -100 },
+        { type: "transaction", date: 2.days.ago.to_date, amount: -300 },
+        # Transaction in different currency than the account's main currency
+        { type: "transaction", date: 1.day.ago.to_date, amount: -500, currency: "EUR" } # €500 * 1.2 = $600
+      ],
+      exchange_rates: [
+        { date: 1.day.ago.to_date, from: "EUR", to: "USD", rate: 1.2 }
+      ]
+    )
+
+    calculated = Balance::ForwardCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 4.days.ago.to_date, { balance: 100, cash_balance: 100 } ],
+        [ 3.days.ago.to_date, { balance: 200, cash_balance: 200 } ],
+        [ 2.days.ago.to_date, { balance: 500, cash_balance: 500 } ],
+        [ 1.day.ago.to_date, { balance: 1100, cash_balance: 1100 } ]
+      ]
+    )
+  end
+
+  # A loan is a special case where despite being a "non-cash" account, it is typical to have "payment" transactions that reduce the loan principal (non cash balance)
+  test "loan payment transactions affect non cash balance" do
+    account = create_account_with_ledger(
+      account: { type: Loan, balance: 10000, cash_balance: 0, currency: "USD" },
+      entries: [
+        { type: "opening_anchor", date: 2.days.ago.to_date, balance: 20000 },
+        # "Loan payment" of $2000, which reduces the principal
+        # TODO: We'll eventually need to calculate which portion of the txn was "interest" vs. "principal", but for now we'll just assume it's all principal
+        # since we don't have a first-class way to track interest payments yet.
+        { type: "transaction", date: 1.day.ago.to_date, amount: -2000 }
+      ]
+    )
+
+    calculated = Balance::ForwardCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 2.days.ago.to_date, { balance: 20000, cash_balance: 0 } ],
+        [ 1.day.ago.to_date, { balance: 18000, cash_balance: 0 } ]
+      ]
+    )
+  end
+
+  test "non cash accounts can only use valuations and transactions will be recorded but ignored for balance calculation" do
+    [ Property, Vehicle, OtherAsset, OtherLiability ].each do |account_type|
+      account = create_account_with_ledger(
+        account: { type: account_type, balance: 10000, cash_balance: 10000, currency: "USD" },
+        entries: [
+          { type: "opening_anchor", date: 3.days.ago.to_date, balance: 500000 },
+
+          # Will be ignored for balance calculation due to account type of non-cash
+          { type: "transaction", date: 2.days.ago.to_date, amount: -50000 }
+        ]
+      )
+
+      calculated = Balance::ForwardCalculator.new(account).calculate
+
+      assert_calculated_ledger_balances(
+        calculated_data: calculated,
+        expected_balances: [
+          [ 3.days.ago.to_date, { balance: 500000, cash_balance: 0 } ],
+          [ 2.days.ago.to_date, { balance: 500000, cash_balance: 0 } ]
+        ]
+      )
+    end
+  end
+
+  # ------------------------------------------------------------------------------------------------
+  # Hybrid accounts (Investment, Crypto) - these have both cash and non-cash balance components
+  # ------------------------------------------------------------------------------------------------
+
+  # A transaction increases/decreases cash balance (i.e. "deposits" and "withdrawals")
+  # A trade increases/decreases cash balance (i.e. "buys" and "sells", which consume/add "brokerage cash" and create/destroy "holdings")
+  # A valuation can set both cash and non-cash balances to "override" investment account value.
+  # Holdings are calculated separately and fed into the balance calculator; treated as "non-cash"
+  test "investment account calculates balance from transactions and trades and treats holdings as non-cash, additive to balance" do
+    account = create_account_with_ledger(
+      account: { type: Investment, balance: 10000, cash_balance: 10000, currency: "USD" },
+      entries: [
+        # Account starts with brokerage cash of $5000 and no holdings
+        { type: "opening_anchor", date: 3.days.ago.to_date, balance: 5000 },
+        # Share purchase reduces cash balance by $1000, but keeps overall balance same
+        { type: "trade", date: 1.day.ago.to_date, ticker: "AAPL", qty: 10, price: 100 }
+      ],
+      holdings: [
+        # Holdings calculator will calculate $1000 worth of holdings
+        { date: 1.day.ago.to_date, ticker: "AAPL", qty: 10, price: 100, amount: 1000 },
+        { date: Date.current, ticker: "AAPL", qty: 10, price: 100, amount: 1000 }
+      ]
+    )
 
     # Given constant prices, overall balance (account value) should be constant
     # (the single trade doesn't affect balance; it just alters cash vs. holdings composition)
-    expected = [ 0, 5000, 5000, 5000 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
+    calculated = Balance::ForwardCalculator.new(account).calculate
 
-    assert_equal expected, calculated
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ 3.days.ago.to_date, { balance: 5000, cash_balance: 5000 } ],
+        [ 2.days.ago.to_date, { balance: 5000, cash_balance: 5000 } ],
+        [ 1.day.ago.to_date, { balance: 5000, cash_balance: 4000 } ],
+        [ Date.current, { balance: 5000, cash_balance: 4000 } ]
+      ]
+    )
   end
 
-  # Balance calculator is entirely reliant on HoldingCalculator and respects whatever holding records it creates.
-  test "holdings are additive to total balance" do
-    aapl = securities(:aapl)
+  private
 
-    # Account starts at a value of $5000
-    create_valuation(account: @account, date: 2.days.ago.to_date, amount: 5000)
+    def assert_balances(calculated_data:, expected_balances:)
+      # Sort calculated data by date to ensure consistent ordering
+      sorted_data = calculated_data.sort_by(&:date)
 
-    # Even though there are no trades in the history, the calculator will still add the holdings to the total balance
-    Holding.create!(date: 1.day.ago.to_date, account: @account, security: aapl, qty: 10, price: 100, amount: 1000, currency: "USD")
-    Holding.create!(date: Date.current, account: @account, security: aapl, qty: 10, price: 100, amount: 1000, currency: "USD")
+      # Extract actual values as [date, { balance:, cash_balance: }]
+      actual_balances = sorted_data.map do |b|
+        [ b.date, { balance: b.balance, cash_balance: b.cash_balance } ]
+      end
 
-    # Start at zero, then valuation of $5000, then tack on $1000 of holdings for remaining 2 days
-    expected = [ 0, 5000, 6000, 6000 ]
-    calculated = Balance::ForwardCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
-  end
+      assert_equal expected_balances, actual_balances
+    end
 end

test/models/balance/reverse_calculator_test.rb

@@ -1,142 +1,279 @@
 require "test_helper"
 
 class Balance::ReverseCalculatorTest < ActiveSupport::TestCase
-  include EntriesTestHelper
+  include LedgerTestingHelper
 
-  setup do
-    @account = families(:empty).accounts.create!(
-      name: "Test",
-      balance: 20000,
-      cash_balance: 20000,
-      currency: "USD",
-      accountable: Investment.new
+  # When syncing backwards, we start with the account balance and generate everything from there.
+  test "when missing anchor and no entries, falls back to cached account balance" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: []
+    )
+
+    assert_equal 20000, account.balance
+
+    calculated = Balance::ReverseCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 20000, cash_balance: 20000 } ]
+      ]
     )
   end
 
-  # When syncing backwards, we start with the account balance and generate everything from there.
-  test "no entries sync" do
-    assert_equal 0, @account.balances.count
+  # An artificial constraint we put on the reverse sync because it's confusing in both the code and the UI
+  # to think about how an absolute "Valuation" affects balances when syncing backwards. Furthermore, since
+  # this is typically a Plaid sync, we expect Plaid to provide us the history.
+  # Note: while "reconciliation" valuations don't affect balance, `current_anchor` and `opening_anchor` do.
+  test "reconciliation valuations do not affect balance for reverse syncs" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 20000 },
+        { type: "reconciliation", date: 1.day.ago, balance: 17000 }, # Ignored
+        { type: "reconciliation", date: 2.days.ago, balance: 17000 }, # Ignored
+        { type: "opening_anchor", date: 4.days.ago, balance: 15000 }
+      ]
+    )
 
-    expected = [ @account.balance, @account.balance ]
-    calculated = Balance::ReverseCalculator.new(@account).calculate
+    calculated = Balance::ReverseCalculator.new(account).calculate
 
-    assert_equal expected, calculated.map(&:balance)
+    # The "opening anchor" works slightly differently than most would expect. Since it's an artificial
+    # value provided by the user to set the date/balance of the start of the account, we must assume
+    # that there are "missing" entries following it. Because of this, we cannot "carry forward" this value
+    # like we do for a "forward sync". We simply sync backwards normally, then set the balance on opening
+    # date equal to this anchor. This is not "ideal", but is a constraint put on us since we cannot guarantee
+    # a 100% full entries history.
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 20000, cash_balance: 20000 } ], # Current anchor
+        [ 1.day.ago, { balance: 20000, cash_balance: 20000 } ],
+        [ 2.days.ago, { balance: 20000, cash_balance: 20000 } ],
+        [ 3.days.ago, { balance: 20000, cash_balance: 20000 } ],
+        [ 4.days.ago, { balance: 15000, cash_balance: 15000 } ] # Opening anchor
+      ]
+    )
   end
 
-  test "balance generation respects user timezone and last generated date is current user date" do
-    # Simulate user in EST timezone
-    Time.use_zone("America/New_York") do
-      # Set current time to 1am UTC on Jan 5, 2025
-      # This would be 8pm EST on Jan 4, 2025 (user's time, and the last date we should generate balances for)
-      travel_to Time.utc(2025, 01, 05, 1, 0, 0)
+  # Investment account balances are made of two components: cash and holdings.
+  test "anchors on investment accounts calculate cash balance dynamically based on holdings value" do
+    account = create_account_with_ledger(
+      account: { type: Investment, balance: 20000, cash_balance: 10000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 20000 }, # "Total account value is $20,000 today"
+        { type: "opening_anchor", date: 1.day.ago, balance: 15000 } # "Total account value was $15,000 at the start of the account"
+      ],
+      holdings: [
+        { date: Date.current, ticker: "AAPL", qty: 100, price: 100, amount: 10000 },
+        { date: 1.day.ago, ticker: "AAPL", qty: 100, price: 100, amount: 10000 }
+      ]
+    )
 
-      create_valuation(account: @account, date: "2025-01-03", amount: 17000)
+    calculated = Balance::ReverseCalculator.new(account).calculate
 
-      expected = [ [ "2025-01-02", 17000 ], [ "2025-01-03", 17000 ], [ "2025-01-04", @account.balance ] ]
-      calculated = Balance::ReverseCalculator.new(@account).calculate
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 20000, cash_balance: 10000 } ], # Since $10,000 of holdings, cash has to be $10,000 to reach $20,000 total value
+        [ 1.day.ago, { balance: 15000, cash_balance: 5000 } ] # Since $10,000 of holdings, cash has to be $5,000 to reach $15,000 total value
+      ]
+    )
+  end
 
-      assert_equal expected, calculated.sort_by(&:date).map { |b| [ b.date.to_s, b.balance ] }
+  test "transactions on depository accounts affect cash balance" do
+    account = create_account_with_ledger(
+      account: { type: Depository, balance: 20000, cash_balance: 20000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 20000 },
+        { type: "transaction", date: 4.days.ago, amount: -500 }, # income
+        { type: "transaction", date: 2.days.ago, amount: 100 } # expense
+      ]
+    )
+
+    calculated = Balance::ReverseCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 20000, cash_balance: 20000 } ], # Current balance
+        [ 1.day.ago, { balance: 20000, cash_balance: 20000 } ], # No change
+        [ 2.days.ago, { balance: 20000, cash_balance: 20000 } ], # After expense (+100)
+        [ 3.days.ago, { balance: 20100, cash_balance: 20100 } ], # Before expense
+        [ 4.days.ago, { balance: 20100, cash_balance: 20100 } ], # After income (-500)
+        [ 5.days.ago, { balance: 19600, cash_balance: 19600 } ] # After income (-500)
+      ]
+    )
+  end
+
+  test "transactions on credit card accounts affect cash balance inversely" do
+    account = create_account_with_ledger(
+      account: { type: CreditCard, balance: 2000, cash_balance: 2000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 2000 },
+        { type: "transaction", date: 2.days.ago, amount: 100 }, # expense (increases cash balance)
+        { type: "transaction", date: 4.days.ago, amount: -500 } # CC payment (reduces cash balance)
+      ]
+    )
+
+    calculated = Balance::ReverseCalculator.new(account).calculate
+
+    # Reversed order: showing how we work backwards
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 2000, cash_balance: 2000 } ],  # Current balance
+        [ 1.day.ago, { balance: 2000, cash_balance: 2000 } ], # No change
+        [ 2.days.ago, { balance: 2000, cash_balance: 2000 } ], # After expense (+100)
+        [ 3.days.ago, { balance: 1900, cash_balance: 1900 } ], # Before expense
+        [ 4.days.ago, { balance: 1900, cash_balance: 1900 } ], # After CC payment (-500)
+        [ 5.days.ago, { balance: 2400, cash_balance: 2400 } ]
+      ]
+    )
+  end
+
+  # A loan is a special case where despite being a "non-cash" account, it is typical to have "payment" transactions that reduce the loan principal (non cash balance)
+  test "loan payment transactions affect non cash balance" do
+    account = create_account_with_ledger(
+      account: { type: Loan, balance: 198000, cash_balance: 0, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 198000 },
+        # "Loan payment" of $2000, which reduces the principal
+        # TODO: We'll eventually need to calculate which portion of the txn was "interest" vs. "principal", but for now we'll just assume it's all principal
+        # since we don't have a first-class way to track interest payments yet.
+        { type: "transaction", date: 1.day.ago.to_date, amount: -2000 }
+      ]
+    )
+
+    calculated = Balance::ReverseCalculator.new(account).calculate
+
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 198000, cash_balance: 0 } ],
+        [ 1.day.ago, { balance: 198000, cash_balance: 0 } ],
+        [ 2.days.ago, { balance: 200000, cash_balance: 0 } ]
+      ]
+    )
+  end
+
+  test "non cash accounts can only use valuations and transactions will be recorded but ignored for balance calculation" do
+    [ Property, Vehicle, OtherAsset, OtherLiability ].each do |account_type|
+      account = create_account_with_ledger(
+        account: { type: account_type, balance: 1000, cash_balance: 0, currency: "USD" },
+        entries: [
+          { type: "current_anchor", date: Date.current, balance: 1000 },
+
+          # Will be ignored for balance calculation due to account type of non-cash
+          { type: "transaction", date: 1.day.ago, amount: -100 }
+        ]
+      )
+
+      calculated = Balance::ReverseCalculator.new(account).calculate
+
+      assert_calculated_ledger_balances(
+        calculated_data: calculated,
+        expected_balances: [
+          [ Date.current, { balance: 1000, cash_balance: 0 } ],
+          [ 1.day.ago, { balance: 1000, cash_balance: 0 } ],
+          [ 2.days.ago, { balance: 1000, cash_balance: 0 } ]
+        ]
+      )
     end
   end
 
-  test "valuations sync" do
-    create_valuation(account: @account, date: 4.days.ago.to_date, amount: 17000)
-    create_valuation(account: @account, date: 2.days.ago.to_date, amount: 19000)
-
-    expected = [ 17000, 17000, 19000, 19000, 20000, 20000 ]
-    calculated = Balance::ReverseCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
-  end
-
-  test "transactions sync" do
-    create_transaction(account: @account, date: 4.days.ago.to_date, amount: -500) # income
-    create_transaction(account: @account, date: 2.days.ago.to_date, amount: 100) # expense
-
-    expected = [ 19600, 20100, 20100, 20000, 20000, 20000 ]
-    calculated = Balance::ReverseCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
-  end
-
-  test "multi-entry sync" do
-    create_transaction(account: @account, date: 8.days.ago.to_date, amount: -5000)
-    create_valuation(account: @account, date: 6.days.ago.to_date, amount: 17000)
-    create_transaction(account: @account, date: 6.days.ago.to_date, amount: -500)
-    create_transaction(account: @account, date: 4.days.ago.to_date, amount: -500)
-    create_valuation(account: @account, date: 3.days.ago.to_date, amount: 17000)
-    create_transaction(account: @account, date: 1.day.ago.to_date, amount: 100)
-
-    expected = [ 12000, 17000, 17000, 17000, 16500, 17000, 17000, 20100, 20000, 20000 ]
-    calculated = Balance::ReverseCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
-  end
-
   # When syncing backwards, trades from the past should NOT affect the current balance or previous balances.
   # They should only affect the *cash* component of the historical balances
   test "holdings and trades sync" do
-    aapl = securities(:aapl)
-
     # Account starts with $20,000 total value, $19,000 cash, $1,000 in holdings
-    @account.update!(cash_balance: 19000, balance: 20000)
+    account = create_account_with_ledger(
+      account: { type: Investment, balance: 20000, cash_balance: 19000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 20000 },
+        # Bought 10 AAPL shares 1 day ago, so cash is $19,000, $1,000 in holdings, total value is $20,000
+        { type: "trade", date: 1.day.ago.to_date, ticker: "AAPL", qty: 10, price: 100 }
+      ],
+      holdings: [
+        { date: Date.current, ticker: "AAPL", qty: 10, price: 100, amount: 1000 },
+        { date: 1.day.ago.to_date, ticker: "AAPL", qty: 10, price: 100, amount: 1000 }
+      ]
+    )
 
-    # Bought 10 AAPL shares 1 day ago, so cash is $19,000, $1,000 in holdings, total value is $20,000
-    create_trade(aapl, account: @account, qty: 10, date: 1.day.ago.to_date, price: 100)
-
-    Holding.create!(date: Date.current, account: @account, security: aapl, qty: 10, price: 100, amount: 1000, currency: "USD")
-    Holding.create!(date: 1.day.ago.to_date, account: @account, security: aapl, qty: 10, price: 100, amount: 1000, currency: "USD")
+    calculated = Balance::ReverseCalculator.new(account).calculate
 
     # Given constant prices, overall balance (account value) should be constant
     # (the single trade doesn't affect balance; it just alters cash vs. holdings composition)
-    expected = [ 20000, 20000, 20000 ]
-    calculated = Balance::ReverseCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 20000, cash_balance: 19000 } ],      # Current: $19k cash + $1k holdings (anchor)
+        [ 1.day.ago.to_date, { balance: 20000, cash_balance: 19000 } ], # After trade: $19k cash + $1k holdings
+        [ 2.days.ago.to_date, { balance: 20000, cash_balance: 20000 } ] # At first, account is 100% cash, no holdings (no trades)
+      ]
+    )
   end
 
   # A common scenario with Plaid is they'll give us holding records for today, but no trade history for some of them.
   # This is because they only supply 2 years worth of historical data.  Our system must properly handle this.
   test "properly calculates balances when a holding has no trade history" do
-    aapl = securities(:aapl)
-    msft = securities(:msft)
-
     # Account starts with $20,000 total value, $19,000 cash, $1,000 in holdings ($500 AAPL, $500 MSFT)
-    @account.update!(cash_balance: 19000, balance: 20000)
+    account = create_account_with_ledger(
+      account: { type: Investment, balance: 20000, cash_balance: 19000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 20000 },
+        # A holding *with* trade history (5 shares of AAPL, purchased 1 day ago)
+        { type: "trade", date: 1.day.ago.to_date, ticker: "AAPL", qty: 5, price: 100 }
+      ],
+      holdings: [
+        # AAPL holdings
+        { date: Date.current, ticker: "AAPL", qty: 5, price: 100, amount: 500 },
+        { date: 1.day.ago.to_date, ticker: "AAPL", qty: 5, price: 100, amount: 500 },
+        # MSFT holdings without trade history - Balance calculator doesn't care how the holdings were created. It just reads them and assumes they are accurate.
+        { date: Date.current, ticker: "MSFT", qty: 5, price: 100, amount: 500 },
+        { date: 1.day.ago.to_date, ticker: "MSFT", qty: 5, price: 100, amount: 500 },
+        { date: 2.days.ago.to_date, ticker: "MSFT", qty: 5, price: 100, amount: 500 }
+      ]
+    )
 
-    # A holding *with* trade history (5 shares of AAPL, purchased 1 day ago, results in 2 holdings)
-    Holding.create!(date: Date.current, account: @account, security: aapl, qty: 5, price: 100, amount: 500, currency: "USD")
-    Holding.create!(date: 1.day.ago.to_date, account: @account, security: aapl, qty: 5, price: 100, amount: 500, currency: "USD")
-    create_trade(aapl, account: @account, qty: 5, date: 1.day.ago.to_date, price: 100)
+    calculated = Balance::ReverseCalculator.new(account).calculate
 
-    # A holding *without* trade history (5 shares of MSFT, no trade history, results in 1 holding)
-    # We assume if no history is provided, this holding has existed since beginning of account
-    Holding.create!(date: Date.current, account: @account, security: msft, qty: 5, price: 100, amount: 500, currency: "USD")
-    Holding.create!(date: 1.day.ago.to_date, account: @account, security: msft, qty: 5, price: 100, amount: 500, currency: "USD")
-    Holding.create!(date: 2.days.ago.to_date, account: @account, security: msft, qty: 5, price: 100, amount: 500, currency: "USD")
-
-    expected = [ 20000, 20000, 20000 ]
-    calculated = Balance::ReverseCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        [ Date.current, { balance: 20000, cash_balance: 19000 } ],      # Current: $19k cash + $1k holdings ($500 MSFT, $500 AAPL)
+        [ 1.day.ago.to_date, { balance: 20000, cash_balance: 19000 } ], # After AAPL trade: $19k cash + $1k holdings
+        [ 2.days.ago.to_date, { balance: 20000, cash_balance: 19500 } ] # Before AAPL trade: $19.5k cash + $500 MSFT
+      ]
+    )
   end
 
   test "uses provider reported holdings and cash value on current day" do
-    aapl = securities(:aapl)
-
     # Implied holdings value of $1,000 from provider
-    @account.update!(cash_balance: 19000, balance: 20000)
+    account = create_account_with_ledger(
+      account: { type: Investment, balance: 20000, cash_balance: 19000, currency: "USD" },
+      entries: [
+        { type: "current_anchor", date: Date.current, balance: 20000 },
+        { type: "opening_anchor", date: 2.days.ago, balance: 15000 }
+      ],
+      holdings: [
+        # Create holdings that differ in value from provider ($2,000 vs. the $1,000 reported by provider)
+        { date: Date.current, ticker: "AAPL", qty: 10, price: 100, amount: 2000 },
+        { date: 1.day.ago, ticker: "AAPL", qty: 10, price: 100, amount: 2000 }
+      ]
+    )
 
-    # Create a holding that differs in value from provider ($2,000 vs. the $1,000 reported by provider)
-    Holding.create!(date: Date.current, account: @account, security: aapl, qty: 10, price: 100, amount: 2000, currency: "USD")
-    Holding.create!(date: 1.day.ago.to_date, account: @account, security: aapl, qty: 10, price: 100, amount: 2000, currency: "USD")
+    calculated = Balance::ReverseCalculator.new(account).calculate
 
-    # Today reports the provider value.  Yesterday, provider won't give us any data, so we MUST look at the generated holdings value
-    # to calculate the end balance ($19,000 cash + $2,000 holdings = $21,000 total value)
-    expected = [ 21000, 20000 ]
-
-    calculated = Balance::ReverseCalculator.new(@account).calculate.sort_by(&:date).map(&:balance)
-
-    assert_equal expected, calculated
+    assert_calculated_ledger_balances(
+      calculated_data: calculated,
+      expected_balances: [
+        # No matter what, we force current day equal to the "anchor" balance (what provider gave us), and let "cash" float based on holdings value
+        # This ensures the user sees the same top-line number reported by the provider (even if it creates a discrepancy in the cash balance)
+        [ Date.current, { balance: 20000, cash_balance: 18000 } ],
+        [ 1.day.ago, { balance: 20000, cash_balance: 18000 } ],
+        [ 2.days.ago, { balance: 15000, cash_balance: 15000 } ] # Opening anchor sets absolute balance
+      ]
+    )
   end
 end

test/models/plaid_account/processor_test.rb

@@ -94,10 +94,21 @@ class PlaidAccount::ProcessorTest < ActiveSupport::TestCase
   test "calculates balance using BalanceCalculator for investment accounts" do
     @plaid_account.update!(plaid_type: "investment")
 
-    PlaidAccount::Investments::BalanceCalculator.any_instance.expects(:balance).returns(1000).once
+    # Balance is called twice: once for account.balance and once for set_current_balance
+    PlaidAccount::Investments::BalanceCalculator.any_instance.expects(:balance).returns(1000).twice
     PlaidAccount::Investments::BalanceCalculator.any_instance.expects(:cash_balance).returns(1000).once
 
     PlaidAccount::Processor.new(@plaid_account).process
+
+    # Verify that the balance was set correctly
+    account = @plaid_account.account
+    assert_equal 1000, account.balance
+    assert_equal 1000, account.cash_balance
+
+    # Verify current balance anchor was created with correct value
+    current_anchor = account.valuations.current_anchor.first
+    assert_not_nil current_anchor
+    assert_equal 1000, current_anchor.entry.amount
   end
 
   test "processes credit liability data" do
@@ -142,6 +153,76 @@ class PlaidAccount::ProcessorTest < ActiveSupport::TestCase
     PlaidAccount::Processor.new(@plaid_account).process
   end
 
+  test "creates current balance anchor when processing account" do
+    expect_default_subprocessor_calls
+
+    # Clear out accounts to start fresh
+    Account.destroy_all
+
+    @plaid_account.update!(
+      plaid_id: "test_plaid_id",
+      plaid_type: "depository",
+      plaid_subtype: "checking",
+      current_balance: 1500,
+      available_balance: 1500,
+      currency: "USD",
+      name: "Test Account with Anchor",
+      mask: "1234"
+    )
+
+    assert_difference "Account.count", 1 do
+      assert_difference "Entry.count", 1 do
+        assert_difference "Valuation.count", 1 do
+          PlaidAccount::Processor.new(@plaid_account).process
+        end
+      end
+    end
+
+    account = Account.order(created_at: :desc).first
+    assert_equal 1500, account.balance
+
+    # Verify current balance anchor was created
+    current_anchor = account.valuations.current_anchor.first
+    assert_not_nil current_anchor
+    assert_equal "current_anchor", current_anchor.kind
+    assert_equal 1500, current_anchor.entry.amount
+    assert_equal Date.current, current_anchor.entry.date
+    assert_equal "Current balance", current_anchor.entry.name
+  end
+
+  test "updates existing current balance anchor when reprocessing" do
+    # First process creates the account and anchor
+    expect_default_subprocessor_calls
+    PlaidAccount::Processor.new(@plaid_account).process
+
+    account = @plaid_account.account
+    original_anchor = account.valuations.current_anchor.first
+    assert_not_nil original_anchor
+    original_anchor_id = original_anchor.id
+    original_entry_id = original_anchor.entry.id
+    original_balance = original_anchor.entry.amount
+
+    # Update the plaid account balance
+    @plaid_account.update!(current_balance: 2500)
+
+    # Expect subprocessor calls again for the second processing
+    expect_default_subprocessor_calls
+
+    # Reprocess should update the existing anchor
+    assert_no_difference "Valuation.count" do
+      assert_no_difference "Entry.count" do
+        PlaidAccount::Processor.new(@plaid_account).process
+      end
+    end
+
+    # Verify the anchor was updated
+    original_anchor.reload
+    assert_equal original_anchor_id, original_anchor.id
+    assert_equal original_entry_id, original_anchor.entry.id
+    assert_equal 2500, original_anchor.entry.amount
+    assert_not_equal original_balance, original_anchor.entry.amount
+  end
+
   private
     def expect_investment_product_processor_calls
       PlaidAccount::Investments::TransactionsProcessor.any_instance.expects(:process).once

test/models/valuation/name_test.rb

@@ -17,6 +17,21 @@ class Valuation::NameTest < ActiveSupport::TestCase
     assert_equal "Opening account value", name.to_s
   end
 
+  test "generates opening anchor name for Vehicle" do
+    name = Valuation::Name.new("opening_anchor", "Vehicle")
+    assert_equal "Original purchase price", name.to_s
+  end
+
+  test "generates opening anchor name for Crypto" do
+    name = Valuation::Name.new("opening_anchor", "Crypto")
+    assert_equal "Opening account value", name.to_s
+  end
+
+  test "generates opening anchor name for OtherAsset" do
+    name = Valuation::Name.new("opening_anchor", "OtherAsset")
+    assert_equal "Opening account value", name.to_s
+  end
+
   test "generates opening anchor name for other account types" do
     name = Valuation::Name.new("opening_anchor", "Depository")
     assert_equal "Opening balance", name.to_s
@@ -38,6 +53,21 @@ class Valuation::NameTest < ActiveSupport::TestCase
     assert_equal "Current account value", name.to_s
   end
 
+  test "generates current anchor name for Vehicle" do
+    name = Valuation::Name.new("current_anchor", "Vehicle")
+    assert_equal "Current market value", name.to_s
+  end
+
+  test "generates current anchor name for Crypto" do
+    name = Valuation::Name.new("current_anchor", "Crypto")
+    assert_equal "Current account value", name.to_s
+  end
+
+  test "generates current anchor name for OtherAsset" do
+    name = Valuation::Name.new("current_anchor", "OtherAsset")
+    assert_equal "Current account value", name.to_s
+  end
+
   test "generates current anchor name for other account types" do
     name = Valuation::Name.new("current_anchor", "Depository")
     assert_equal "Current balance", name.to_s
@@ -54,6 +84,21 @@ class Valuation::NameTest < ActiveSupport::TestCase
     assert_equal "Manual value update", name.to_s
   end
 
+  test "generates recon name for Vehicle" do
+    name = Valuation::Name.new("reconciliation", "Vehicle")
+    assert_equal "Manual value update", name.to_s
+  end
+
+  test "generates recon name for Crypto" do
+    name = Valuation::Name.new("reconciliation", "Crypto")
+    assert_equal "Manual value update", name.to_s
+  end
+
+  test "generates recon name for OtherAsset" do
+    name = Valuation::Name.new("reconciliation", "OtherAsset")
+    assert_equal "Manual value update", name.to_s
+  end
+
   test "generates recon name for Loan" do
     name = Valuation::Name.new("reconciliation", "Loan")
     assert_equal "Manual principal update", name.to_s

test/support/entries_test_helper.rb

@@ -15,17 +15,50 @@ module EntriesTestHelper
     Entry.create! entry_defaults.merge(entry_attributes)
   end
 
+  def create_opening_anchor_valuation(account:, balance:, date:)
+    create_valuation(
+      account: account,
+      kind: "opening_anchor",
+      amount: balance,
+      date: date
+    )
+  end
+
+  def create_reconciliation_valuation(account:, balance:, date:)
+    create_valuation(
+      account: account,
+      kind: "reconciliation",
+      amount: balance,
+      date: date
+    )
+  end
+
+  def create_current_anchor_valuation(account:, balance:, date: Date.current)
+    create_valuation(
+      account: account,
+      kind: "current_anchor",
+      amount: balance,
+      date: date
+    )
+  end
+
   def create_valuation(attributes = {})
+    entry_attributes = attributes.except(:kind)
+    valuation_attributes = attributes.slice(:kind)
+
+    account = attributes[:account] || accounts(:depository)
+    amount = attributes[:amount] || 5000
+
     entry_defaults = {
-      account: accounts(:depository),
+      account: account,
       name: "Valuation",
       date: 1.day.ago.to_date,
       currency: "USD",
-      amount: 5000,
-      entryable: Valuation.new
+      amount: amount,
+      entryable: Valuation.new({ kind: "reconciliation" }.merge(valuation_attributes))
     }
 
-    Entry.create! entry_defaults.merge(attributes)
+    Entry.create! entry_defaults.merge(entry_attributes)
   end
 
   def create_trade(security, account:, qty:, date:, price: nil, currency: "USD")

test/support/ledger_testing_helper.rb

@@ -0,0 +1,152 @@
+module LedgerTestingHelper
+  def create_account_with_ledger(account:, entries: [], exchange_rates: [], security_prices: [], holdings: [])
+    # Clear all exchange rates and security prices to ensure clean test environment
+    ExchangeRate.destroy_all
+    Security::Price.destroy_all
+
+    # Create account with specified attributes
+    account_attrs = account.except(:type)
+    account_type = account[:type]
+
+    # Create the account
+    created_account = families(:empty).accounts.create!(
+      name: "Test Account",
+      accountable: account_type.new,
+      **account_attrs
+    )
+
+    # Set up exchange rates if provided
+    exchange_rates.each do |rate_data|
+      ExchangeRate.create!(
+        date: rate_data[:date],
+        from_currency: rate_data[:from],
+        to_currency: rate_data[:to],
+        rate: rate_data[:rate]
+      )
+    end
+
+    # Set up security prices if provided
+    security_prices.each do |price_data|
+      security = Security.find_or_create_by!(ticker: price_data[:ticker]) do |s|
+        s.name = price_data[:ticker]
+      end
+
+      Security::Price.create!(
+        security: security,
+        date: price_data[:date],
+        price: price_data[:price],
+        currency: created_account.currency
+      )
+    end
+
+    # Create entries in the order they were specified
+    entries.each do |entry_data|
+      case entry_data[:type]
+      when "current_anchor", "opening_anchor", "reconciliation"
+        # Create valuation entry
+        created_account.entries.create!(
+          name: "Valuation",
+          date: entry_data[:date],
+          amount: entry_data[:balance],
+          currency: entry_data[:currency] || created_account.currency,
+          entryable: Valuation.new(kind: entry_data[:type])
+        )
+      when "transaction"
+        # Use account currency if not specified
+        currency = entry_data[:currency] || created_account.currency
+
+        created_account.entries.create!(
+          name: "Transaction",
+          date: entry_data[:date],
+          amount: entry_data[:amount],
+          currency: currency,
+          entryable: Transaction.new
+        )
+      when "trade"
+        # Find or create security
+        security = Security.find_or_create_by!(ticker: entry_data[:ticker]) do |s|
+          s.name = entry_data[:ticker]
+        end
+
+        # Use account currency if not specified
+        currency = entry_data[:currency] || created_account.currency
+
+        trade = Trade.new(
+          qty: entry_data[:qty],
+          security: security,
+          price: entry_data[:price],
+          currency: currency
+        )
+
+        created_account.entries.create!(
+          name: "Trade",
+          date: entry_data[:date],
+          amount: entry_data[:qty] * entry_data[:price],
+          currency: currency,
+          entryable: trade
+        )
+      end
+    end
+
+    # Create holdings if provided
+    holdings.each do |holding_data|
+      # Find or create security
+      security = Security.find_or_create_by!(ticker: holding_data[:ticker]) do |s|
+        s.name = holding_data[:ticker]
+      end
+
+      Holding.create!(
+        account: created_account,
+        security: security,
+        date: holding_data[:date],
+        qty: holding_data[:qty],
+        price: holding_data[:price],
+        amount: holding_data[:amount],
+        currency: holding_data[:currency] || created_account.currency
+      )
+    end
+
+    created_account
+  end
+
+  def assert_calculated_ledger_balances(calculated_data:, expected_balances:)
+    # Convert expected balances to a hash for easier lookup
+    expected_hash = expected_balances.to_h do |date, balance_data|
+      [ date.to_date, balance_data ]
+    end
+
+    # Get all unique dates from both calculated and expected data
+    all_dates = (calculated_data.map(&:date) + expected_hash.keys).uniq.sort
+
+    # Check each date
+    all_dates.each do |date|
+      calculated_balance = calculated_data.find { |b| b.date == date }
+      expected = expected_hash[date]
+
+      if expected
+        assert calculated_balance, "Expected balance for #{date} but none was calculated"
+
+        if expected[:balance]
+          assert_equal expected[:balance], calculated_balance.balance.to_d,
+            "Balance mismatch for #{date}"
+        end
+
+        if expected[:cash_balance]
+          assert_equal expected[:cash_balance], calculated_balance.cash_balance.to_d,
+            "Cash balance mismatch for #{date}"
+        end
+      else
+        assert_nil calculated_balance, "Unexpected balance calculated for #{date}"
+      end
+    end
+
+    # Verify we got all expected dates
+    expected_dates = expected_hash.keys.sort
+    calculated_dates = calculated_data.map(&:date).sort
+
+    expected_dates.each do |date|
+      assert_includes calculated_dates, date,
+        "Expected balance for #{date} was not in calculated data"
+    end
+  end
+end