Skip to content

armgit / maybe

Public Imported from GitHub
0

The personal finance app for everyone

Add auto-update strategies for current balance on manual accounts (#2460)

Zach Gollwitzer3eea5a98910a
diff --git a/app/controllers/concerns/accountable_resource.rb b/app/controllers/concerns/accountable_resource.rb
index 9daa0ae2..a508764d 100644
--- a/app/controllers/concerns/accountable_resource.rb
+++ b/app/controllers/concerns/accountable_resource.rb
@@ -45,12 +45,13 @@ module AccountableResource
def update
# Handle balance update if provided
if account_params[:balance].present?
- result = @account.update_balance(balance: account_params[:balance], currency: account_params[:currency])
+ result = @account.set_current_balance(account_params[:balance].to_d)
unless result.success?
@error_message = result.error_message
render :edit, status: :unprocessable_entity
return
end
+ @account.sync_later
end
# Update remaining account attributes
diff --git a/app/controllers/properties_controller.rb b/app/controllers/properties_controller.rb
index 8b2ec062..7a1db5de 100644
--- a/app/controllers/properties_controller.rb
+++ b/app/controllers/properties_controller.rb
@@ -37,10 +37,10 @@ class PropertiesController < ApplicationController
end
def update_balances
- result = @account.update_balance(balance: balance_params[:balance], currency: balance_params[:currency])
+ result = @account.set_current_balance(balance_params[:balance].to_d)
if result.success?
- @success_message = result.updated? ? "Balance updated successfully." : "No changes made. Account is already up to date."
+ @success_message = "Balance updated successfully."
if @account.active?
render :balances
diff --git a/app/models/account.rb b/app/models/account.rb
index 684736ce..6a21c3e3 100644
--- a/app/models/account.rb
+++ b/app/models/account.rb
@@ -114,11 +114,6 @@ class Account < ApplicationRecord
.order(amount: :desc)
end
-
- def update_balance(balance:, date: Date.current, currency: nil, notes: nil, existing_valuation_id: nil)
- Account::BalanceUpdater.new(self, balance:, currency:, date:, notes:, existing_valuation_id:).update
- end
-
def start_date
first_entry_date = entries.minimum(:date) || Date.current
first_entry_date - 1.day
@@ -146,4 +141,23 @@ class Account < ApplicationRecord
def long_subtype_label
accountable_class.long_subtype_label_for(subtype) || accountable_class.display_name
end
+
+ # The balance type determines which "component" of balance is being tracked.
+ # This is primarily used for balance related calculations and updates.
+ #
+ # "Cash" = "Liquid"
+ # "Non-cash" = "Illiquid"
+ # "Investment" = A mix of both, including brokerage cash (liquid) and holdings (illiquid)
+ def balance_type
+ case accountable_type
+ when "Depository", "CreditCard"
+ :cash
+ when "Property", "Vehicle", "OtherAsset", "Loan", "OtherLiability"
+ :non_cash
+ when "Investment", "Crypto"
+ :investment
+ else
+ raise "Unknown account type: #{accountable_type}"
+ end
+ end
end
diff --git a/app/models/account/anchorable.rb b/app/models/account/anchorable.rb
index 750fb067..bb797c85 100644
--- a/app/models/account/anchorable.rb
+++ b/app/models/account/anchorable.rb
@@ -10,7 +10,9 @@ module Account::Anchorable
end
def set_opening_anchor_balance(**opts)
- opening_balance_manager.set_opening_balance(**opts)
+ result = opening_balance_manager.set_opening_balance(**opts)
+ sync_later if result.success?
+ result
end
def opening_anchor_date
@@ -25,8 +27,10 @@ module Account::Anchorable
opening_balance_manager.has_opening_anchor?
end
- def set_current_anchor_balance(balance)
- current_balance_manager.set_current_balance(balance)
+ def set_current_balance(balance)
+ result = current_balance_manager.set_current_balance(balance)
+ sync_later if result.success?
+ result
end
def current_anchor_balance
diff --git a/app/models/account/balance_updater.rb b/app/models/account/balance_updater.rb
deleted file mode 100644
index 1c1b1556..00000000
--- a/app/models/account/balance_updater.rb
+++ /dev/null
@@ -1,53 +0,0 @@
-class Account::BalanceUpdater
- def initialize(account, balance:, currency: nil, date: Date.current, notes: nil, existing_valuation_id: nil)
- @account = account
- @balance = balance.to_d
- @currency = currency
- @date = date.to_date
- @notes = notes
- @existing_valuation_id = existing_valuation_id
- end
-
- def update
- return Result.new(success?: true, updated?: false) unless requires_update?
-
- Account.transaction do
- if date == Date.current
- account.balance = balance
- account.currency = currency if currency.present?
- account.save!
- end
-
- valuation_entry = if existing_valuation_id
- account.entries.find(existing_valuation_id)
- else
- account.entries.valuations.find_or_initialize_by(date: date) do |entry|
- entry.entryable = Valuation.new(kind: "reconciliation")
- end
- end
-
- valuation_entry.date = date
- valuation_entry.amount = balance
- valuation_entry.currency = currency if currency.present?
- valuation_entry.name = Valuation.build_reconciliation_name(account.accountable_type)
- valuation_entry.notes = notes if notes.present?
- valuation_entry.save!
- end
-
- account.sync_later
-
- Result.new(success?: true, updated?: true)
- rescue => e
- message = Rails.env.development? ? e.message : "Unable to update account values. Please try again."
- Result.new(success?: false, updated?: false, error_message: message)
- end
-
- private
- attr_reader :account, :balance, :currency, :date, :notes, :existing_valuation_id
-
- Result = Struct.new(:success?, :updated?, :error_message)
-
- def requires_update?
- date != Date.current || account.balance != balance || account.currency != currency
- end
-end
diff --git a/app/models/account/current_balance_manager.rb b/app/models/account/current_balance_manager.rb
index 24303213..2b1ba630 100644
--- a/app/models/account/current_balance_manager.rb
+++ b/app/models/account/current_balance_manager.rb
@@ -31,22 +31,77 @@ class Account::CurrentBalanceManager
end
def set_current_balance(balance)
- # A current balance anchor implies there is an external data source that will keep it updated. Since manual accounts
- # are tracked by the user, a current balance anchor is not appropriate.
- raise InvalidOperation, "Manual accounts cannot set current balance anchor. Set opening balance or use a reconciliation instead." if account.manual?
-
- if current_anchor_valuation
- changes_made = update_current_anchor(balance)
- Result.new(success?: true, changes_made?: changes_made, error: nil)
+ if account.linked?
+ result = set_current_balance_for_linked_account(balance)
else
- create_current_anchor(balance)
- Result.new(success?: true, changes_made?: true, error: nil)
+ result = set_current_balance_for_manual_account(balance)
end
+
+ # Update cache field so changes appear immediately to the user
+ account.update!(balance: balance)
+
+ result
+ rescue => e
+ Result.new(success?: false, changes_made?: false, error: e.message)
end
private
attr_reader :account
+ def opening_balance_manager
+ @opening_balance_manager ||= Account::OpeningBalanceManager.new(account)
+ end
+
+ def reconciliation_manager
+ @reconciliation_manager ||= Account::ReconciliationManager.new(account)
+ end
+
+ # Manual accounts do not manage the `current_anchor` valuation (otherwise, user would need to continually update it, which is bad UX)
+ # Instead, we use a combination of "auto-update strategies" to set the current balance according to the user's intent.
+ #
+ # The "auto-update strategies" are:
+ # 1. Value tracking - If the account has a reconciliation already, we assume they are tracking the account value primarily with reconciliations, so we append a new one
+ # 2. Transaction adjustment - If the account doesn't have recons, we assume user is tracking with transactions, so we adjust the opening balance with a delta until it
+ # gets us to the desired balance. This ensures we don't append unnecessary reconciliations to the account, which "reset" the value from that
+ # date forward (not user's intent).
+ #
+ # For more documentation on these auto-update strategies, see the test cases.
+ def set_current_balance_for_manual_account(balance)
+ # If we're dealing with a cash account that has no reconciliations, use "Transaction adjustment" strategy (update opening balance to "back in" to the desired current balance)
+ if account.balance_type == :cash && account.valuations.reconciliation.empty?
+ adjust_opening_balance_with_delta(new_balance: balance, old_balance: account.balance)
+ else
+ existing_reconciliation = account.entries.valuations.find_by(date: Date.current)
+
+ result = reconciliation_manager.reconcile_balance(balance: balance, date: Date.current, existing_valuation_entry: existing_reconciliation)
+
+ # Normalize to expected result format
+ Result.new(success?: result.success?, changes_made?: true, error: result.error_message)
+ end
+ end
+
+ def adjust_opening_balance_with_delta(new_balance:, old_balance:)
+ delta = new_balance - old_balance
+
+ result = opening_balance_manager.set_opening_balance(balance: account.opening_anchor_balance + delta)
+
+ # Normalize to expected result format
+ Result.new(success?: result.success?, changes_made?: true, error: result.error)
+ end
+
+ # Linked accounts manage "current balance" via the special `current_anchor` valuation.
+ # This is NOT a user-facing feature, and is primarily used in "processors" while syncing
+ # linked account data (e.g. via Plaid)
+ def set_current_balance_for_linked_account(balance)
+ if current_anchor_valuation
+ changes_made = update_current_anchor(balance)
+ Result.new(success?: true, changes_made?: changes_made, error: nil)
+ else
+ create_current_anchor(balance)
+ Result.new(success?: true, changes_made?: true, error: nil)
+ end
+ end
+
def current_anchor_valuation
@current_anchor_valuation ||= account.valuations.current_anchor.includes(:entry).first
end
diff --git a/app/models/account/reconcileable.rb b/app/models/account/reconcileable.rb
index bad855a9..b8805236 100644
--- a/app/models/account/reconcileable.rb
+++ b/app/models/account/reconcileable.rb
@@ -2,11 +2,15 @@ module Account::Reconcileable
extend ActiveSupport::Concern
def create_reconciliation(balance:, date:, dry_run: false)
- reconciliation_manager.reconcile_balance(balance: balance, date: date, dry_run: dry_run)
+ result = reconciliation_manager.reconcile_balance(balance: balance, date: date, dry_run: dry_run)
+ sync_later if result.success?
+ result
end
def update_reconciliation(existing_valuation_entry, balance:, date:, dry_run: false)
- reconciliation_manager.reconcile_balance(balance: balance, date: date, existing_valuation_entry: existing_valuation_entry, dry_run: dry_run)
+ result = reconciliation_manager.reconcile_balance(balance: balance, date: date, existing_valuation_entry: existing_valuation_entry, dry_run: dry_run)
+ sync_later if result.success?
+ result
end
private
diff --git a/app/models/account/reconciliation_manager.rb b/app/models/account/reconciliation_manager.rb
index e1300143..aac821b2 100644
--- a/app/models/account/reconciliation_manager.rb
+++ b/app/models/account/reconciliation_manager.rb
@@ -12,7 +12,6 @@ class Account::ReconciliationManager
unless dry_run
prepared_valuation.save!
- account.sync_later
end
ReconciliationResult.new(
diff --git a/app/models/balance/base_calculator.rb b/app/models/balance/base_calculator.rb
index 3360bcec..92ef5d3e 100644
--- a/app/models/balance/base_calculator.rb
+++ b/app/models/balance/base_calculator.rb
@@ -20,9 +20,9 @@ class Balance::BaseCalculator
end
def derive_cash_balance_on_date_from_total(total_balance:, date:)
- if balance_type == :investment
+ if account.balance_type == :investment
total_balance - holdings_value_for_date(date)
- elsif balance_type == :cash
+ elsif account.balance_type == :cash
total_balance
else
0
@@ -32,7 +32,7 @@ class Balance::BaseCalculator
def derive_cash_balance(cash_balance, date)
entries = sync_cache.get_entries(date)
- if balance_type == :non_cash
+ if account.balance_type == :non_cash
0
else
cash_balance + signed_entry_flows(entries)
@@ -42,9 +42,9 @@ class Balance::BaseCalculator
def derive_non_cash_balance(non_cash_balance, date, direction: :forward)
entries = sync_cache.get_entries(date)
# Loans are a special case (loan payment reducing principal, which is non-cash)
- if balance_type == :non_cash && account.accountable_type == "Loan"
+ if account.balance_type == :non_cash && account.accountable_type == "Loan"
non_cash_balance + signed_entry_flows(entries)
- elsif balance_type == :investment
+ elsif account.balance_type == :investment
# For reverse calculations, we need the previous day's holdings
target_date = direction == :forward ? date : date.prev_day
holdings_value_for_date(target_date)
@@ -57,19 +57,6 @@ class Balance::BaseCalculator
raise NotImplementedError, "Directional calculators must implement this method"
end
- def balance_type
- case account.accountable_type
- when "Depository", "CreditCard"
- :cash
- when "Property", "Vehicle", "OtherAsset", "Loan", "OtherLiability"
- :non_cash
- when "Investment", "Crypto"
- :investment
- else
- raise "Unknown account type: #{account.accountable_type}"
- end
- end
-
def build_balance(date:, cash_balance:, non_cash_balance:)
Balance.new(
account_id: account.id,
diff --git a/app/models/plaid_account/processor.rb b/app/models/plaid_account/processor.rb
index 5b16f90d..b42bdf3b 100644
--- a/app/models/plaid_account/processor.rb
+++ b/app/models/plaid_account/processor.rb
@@ -57,7 +57,7 @@ class PlaidAccount::Processor
# to properly track the holdings vs. cash breakdown, but for now we're only tracking
# the total balance in the current anchor. The cash_balance field on the account model
# is still being used for the breakdown.
- account.set_current_anchor_balance(balance_calculator.balance)
+ account.set_current_balance(balance_calculator.balance)
end
end
diff --git a/test/controllers/properties_controller_test.rb b/test/controllers/properties_controller_test.rb
index b5f1305f..34f76734 100644
--- a/test/controllers/properties_controller_test.rb
+++ b/test/controllers/properties_controller_test.rb
@@ -71,10 +71,6 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
test "updates balances tab" do
original_balance = @account.balance
- # Mock the update_balance method to return a successful result
- Account::BalanceUpdater::Result.any_instance.stubs(:success?).returns(true)
- Account::BalanceUpdater::Result.any_instance.stubs(:updated?).returns(true)
-
patch update_balances_property_path(@account), params: {
account: {
balance: 600000,
@@ -116,9 +112,7 @@ class PropertiesControllerTest < ActionDispatch::IntegrationTest
end
test "balances update handles validation errors" do
- # Mock update_balance to return a failure result
- Account::BalanceUpdater::Result.any_instance.stubs(:success?).returns(false)
- Account::BalanceUpdater::Result.any_instance.stubs(:error_message).returns("Invalid balance")
+ Account.any_instance.stubs(:set_current_balance).returns(OpenStruct.new(success?: false, error_message: "Invalid balance"))
patch update_balances_property_path(@account), params: {
account: {
diff --git a/test/models/account/current_balance_manager_test.rb b/test/models/account/current_balance_manager_test.rb
index d48eb927..0d7b914b 100644
--- a/test/models/account/current_balance_manager_test.rb
+++ b/test/models/account/current_balance_manager_test.rb
@@ -2,15 +2,185 @@ 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
+ @family = families(:empty)
+ @linked_account = accounts(:connected)
end
- test "when no existing anchor, creates new anchor" do
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ # -------------------------------------------------------------------------------------------------
+ # Manual account current balance management
+ #
+ # Manual accounts do not manage `current_anchor` valuations and have "auto-update strategies" to set the current balance.
+ # -------------------------------------------------------------------------------------------------
- assert_difference -> { @connected_account.entries.count } => 1,
- -> { @connected_account.valuations.count } => 1 do
+ test "when one or more reconciliations exist, append new reconciliation to represent the current balance" do
+ account = @family.accounts.create!(
+ name: "Test",
+ balance: 1000,
+ cash_balance: 1000,
+ currency: "USD",
+ accountable: Depository.new
+ )
+
+ # A reconciliation tells us that the user is tracking this account's value with balance-only updates
+ account.entries.create!(
+ date: 30.days.ago.to_date,
+ name: "First manual recon valuation",
+ amount: 1200,
+ currency: "USD",
+ entryable: Valuation.new(kind: "reconciliation")
+ )
+
+ manager = Account::CurrentBalanceManager.new(account)
+
+ assert_equal 1, account.valuations.count
+
+ # Here, we assume user is once again "overriding" the balance to 1400
+ manager.set_current_balance(1400)
+
+ today_valuation = account.entries.valuations.find_by(date: Date.current)
+
+ assert_equal 2, account.valuations.count
+ assert_equal 1400, today_valuation.amount
+
+ assert_equal 1400, account.balance
+ end
+
+ test "all manual non cash accounts append reconciliations for current balance updates" do
+ [ Property, Vehicle, OtherAsset, Loan, OtherLiability ].each do |account_type|
+ account = @family.accounts.create!(
+ name: "Test",
+ balance: 1000,
+ cash_balance: 1000,
+ currency: "USD",
+ accountable: account_type.new
+ )
+
+ manager = Account::CurrentBalanceManager.new(account)
+
+ assert_equal 0, account.valuations.count
+
+ manager.set_current_balance(1400)
+
+ assert_equal 1, account.valuations.count
+
+ today_valuation = account.entries.valuations.find_by(date: Date.current)
+
+ assert_equal 1400, today_valuation.amount
+ assert_equal 1400, account.balance
+ end
+ end
+
+ # Scope: Depository, CreditCard only (i.e. all-cash accounts)
+ #
+ # If a user has an opening balance (valuation) for their manual *Depository* or *CreditCard* account and has 1+ transactions, the intent of
+ # "updating current balance" typically means that their start balance is incorrect. We follow that user intent
+ # by default and find the delta required, and update the opening balance so that the timeline reflects this current balance
+ #
+ # The purpose of this is so we're not cluttering up their timeline with "balance reconciliations" that reset the balance
+ # on the current date. Our goal is to keep the timeline with as few "Valuations" as possible.
+ #
+ # If we ever build a UI that gives user options, this test expectation may require some updates, but for now this
+ # is the least surprising outcome.
+ test "when no reconciliations exist on cash accounts, adjust opening balance with delta until it gets us to the desired balance" do
+ account = @family.accounts.create!(
+ name: "Test",
+ balance: 900, # the balance after opening valuation + transaction have "synced" (1000 - 100 = 900)
+ cash_balance: 900,
+ currency: "USD",
+ accountable: Depository.new
+ )
+
+ account.entries.create!(
+ date: 1.year.ago.to_date,
+ name: "Test opening valuation",
+ amount: 1000,
+ currency: "USD",
+ entryable: Valuation.new(kind: "opening_anchor")
+ )
+
+ account.entries.create!(
+ date: 10.days.ago.to_date,
+ name: "Test expense transaction",
+ amount: 100,
+ currency: "USD",
+ entryable: Transaction.new
+ )
+
+ # What we're asserting here:
+ # 1. User creates the account with an opening balance of 1000
+ # 2. User creates a transaction of 100, which then reduces the balance to 900 (the current balance value on account above)
+ # 3. User requests "current balance update" back to 1000, which was their intention
+ # 4. We adjust the opening balance by the delta (100) to 1100, which is the new opening balance, so that the transaction
+ # of 100 reduces it down to 1000, which is the current balance they intended.
+ assert_equal 1, account.valuations.count
+ assert_equal 1, account.transactions.count
+
+ # No new valuation is appended; we're just adjusting the opening valuation anchor
+ assert_no_difference "account.entries.count" do
+ manager = Account::CurrentBalanceManager.new(account)
+ manager.set_current_balance(1000)
+ end
+
+ opening_valuation = account.valuations.find_by(kind: "opening_anchor")
+
+ assert_equal 1100, opening_valuation.entry.amount
+ assert_equal 1000, account.balance
+ end
+
+ # (SEE ABOVE TEST FOR MORE DETAILED EXPLANATION)
+ # Same assertions as the test above, but Credit Card accounts are liabilities, which means expenses increase balance; not decrease
+ test "when no reconciliations exist on credit card accounts, adjust opening balance with delta until it gets us to the desired balance" do
+ account = @family.accounts.create!(
+ name: "Test",
+ balance: 1100, # the balance after opening valuation + transaction have "synced" (1000 + 100 = 1100) (expenses increase balance)
+ cash_balance: 1100,
+ currency: "USD",
+ accountable: CreditCard.new
+ )
+
+ account.entries.create!(
+ date: 1.year.ago.to_date,
+ name: "Test opening valuation",
+ amount: 1000,
+ currency: "USD",
+ entryable: Valuation.new(kind: "opening_anchor")
+ )
+
+ account.entries.create!(
+ date: 10.days.ago.to_date,
+ name: "Test expense transaction",
+ amount: 100,
+ currency: "USD",
+ entryable: Transaction.new
+ )
+
+ assert_equal 1, account.valuations.count
+ assert_equal 1, account.transactions.count
+
+ assert_no_difference "account.entries.count" do
+ manager = Account::CurrentBalanceManager.new(account)
+ manager.set_current_balance(1000)
+ end
+
+ opening_valuation = account.valuations.find_by(kind: "opening_anchor")
+
+ assert_equal 900, opening_valuation.entry.amount
+ assert_equal 1000, account.balance
+ end
+
+ # -------------------------------------------------------------------------------------------------
+ # Linked account current balance management
+ #
+ # Linked accounts manage "current balance" via the special `current_anchor` valuation.
+ # This is NOT a user-facing feature, and is primarily used in "processors" while syncing
+ # linked account data (e.g. via Plaid)
+ # -------------------------------------------------------------------------------------------------
+
+ test "when no existing anchor for linked account, creates new anchor" do
+ manager = Account::CurrentBalanceManager.new(@linked_account)
+
+ assert_difference -> { @linked_account.entries.count } => 1,
+ -> { @linked_account.valuations.count } => 1 do
result = manager.set_current_balance(1000)
assert result.success?
@@ -18,7 +188,7 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
assert_nil result.error
end
- current_anchor = @connected_account.valuations.current_anchor.first
+ current_anchor = @linked_account.valuations.current_anchor.first
assert_not_nil current_anchor
assert_equal 1000, current_anchor.entry.amount
assert_equal "current_anchor", current_anchor.kind
@@ -27,23 +197,25 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
assert_equal 1000, entry.amount
assert_equal Date.current, entry.date
assert_equal "Current balance", entry.name # Depository type returns "Current balance"
+
+ assert_equal 1000, @linked_account.balance
end
- test "updates existing anchor" do
+ test "updates existing anchor for linked account" do
# First create a current anchor
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ manager = Account::CurrentBalanceManager.new(@linked_account)
result = manager.set_current_balance(1000)
assert result.success?
- current_anchor = @connected_account.valuations.current_anchor.first
+ current_anchor = @linked_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
+ assert_no_difference -> { @linked_account.entries.count } do
+ assert_no_difference -> { @linked_account.valuations.count } do
result = manager.set_current_balance(2000)
assert result.success?
assert result.changes_made?
@@ -56,24 +228,13 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
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
+ assert_equal 2000, @linked_account.balance
end
test "when no changes made, returns success with no changes made" do
# First create a current anchor
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ manager = Account::CurrentBalanceManager.new(@linked_account)
result = manager.set_current_balance(1000)
assert result.success?
assert result.changes_made?
@@ -84,16 +245,18 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
assert result.success?
assert_not result.changes_made?
assert_nil result.error
+
+ assert_equal 1000, @linked_account.balance
end
test "updates only amount when balance changes" do
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ manager = Account::CurrentBalanceManager.new(@linked_account)
# Create initial anchor
result = manager.set_current_balance(1000)
assert result.success?
- current_anchor = @connected_account.valuations.current_anchor.first
+ current_anchor = @linked_account.valuations.current_anchor.first
original_date = current_anchor.entry.date
# Update only the balance
@@ -104,16 +267,18 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
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
+
+ assert_equal 1500, @linked_account.balance
end
test "updates date when called on different day" do
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ manager = Account::CurrentBalanceManager.new(@linked_account)
# Create initial anchor
result = manager.set_current_balance(1000)
assert result.success?
- current_anchor = @connected_account.valuations.current_anchor.first
+ current_anchor = @linked_account.valuations.current_anchor.first
original_amount = current_anchor.entry.amount
# Travel to tomorrow and update with same balance
@@ -126,10 +291,12 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
assert_equal original_amount, current_anchor.entry.amount
assert_equal Date.current, current_anchor.entry.date # Should be updated to new current date
end
+
+ assert_equal 1000, @linked_account.balance
end
test "current_balance returns balance from current anchor" do
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ manager = Account::CurrentBalanceManager.new(@linked_account)
# Create a current anchor
manager.set_current_balance(1500)
@@ -142,12 +309,16 @@ class Account::CurrentBalanceManagerTest < ActiveSupport::TestCase
# Should return the updated balance
assert_equal 2500, manager.current_balance
+
+ assert_equal 2500, @linked_account.balance
end
test "current_balance falls back to account balance when no anchor exists" do
- manager = Account::CurrentBalanceManager.new(@connected_account)
+ manager = Account::CurrentBalanceManager.new(@linked_account)
# When no current anchor exists, should fall back to account.balance
- assert_equal @connected_account.balance, manager.current_balance
+ assert_equal @linked_account.balance, manager.current_balance
+
+ assert_equal @linked_account.balance, @linked_account.balance
end
end
diff --git a/test/models/account/reconciliation_manager_test.rb b/test/models/account/reconciliation_manager_test.rb
index 0e7a39a9..794c2cc5 100644
--- a/test/models/account/reconciliation_manager_test.rb
+++ b/test/models/account/reconciliation_manager_test.rb
@@ -88,7 +88,7 @@ class Account::ReconciliationManagerTest < ActiveSupport::TestCase
end
end
- test "dry run does not persist or sync account" do
+ test "dry run does not persist account" do
@account.balances.create!(date: Date.current, balance: 1000, cash_balance: 500, currency: @account.currency)
assert_no_difference "Valuation.count" do
@@ -96,7 +96,6 @@ class Account::ReconciliationManagerTest < ActiveSupport::TestCase
end
assert_difference "Valuation.count", 1 do
- @account.expects(:sync_later).once
@manager.reconcile_balance(balance: 1200, date: Date.current)
end
end