Docker/Maybe
Docker/Maybe
1
0
Fork 0
mirror of https://github.com/maybe-finance/maybe.git synced 2025-07-24 15:49:39 +02:00
Code Issues Releases Activity Actions 1

Add the ability to "rollup" values in a time series (#554)

Browse source 
* Clean up time series models

* Add value group rollup class for summarizing hierarchical data

* Integrate new classes

* Update UI to use new patterns

* Update D3 charts to expect new data format

* Clean up account model

* More cleanup

* Money improvements

* Use new money fields

* Remove invalid fixture data to avoid orphaned accountables

* Update time series to work better with collections

* Fix tests and UI bugs
This commit is contained in:
Zach Gollwitzer 2024-03-19 09:10:40 -04:00 • committed by GitHub
parent 0a8518506c
commit f904d9d062
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
34 changed files with 687 additions and 391 deletions
Download patch file Download diff file Expand all files Collapse all files

102
test/models/family_test.rb
View file

@ -65,26 +65,18 @@ class FamilyTest < ActiveSupport::TestCase
liability_series = @family.snapshot[:liability_series]
net_worth_series = @family.snapshot[:net_worth_series]
assert_equal expected_snapshots.count, asset_series.data.count
assert_equal expected_snapshots.count, liability_series.data.count
assert_equal expected_snapshots.count, net_worth_series.data.count
assert_equal expected_snapshots.count, asset_series.values.count
assert_equal expected_snapshots.count, liability_series.values.count
assert_equal expected_snapshots.count, net_worth_series.values.count
expected_snapshots.each_with_index do |row, index|
expected = {
date: row["date"],
assets: row["assets"].to_d,
liabilities: row["liabilities"].to_d,
net_worth: row["net_worth"].to_d
}
expected_assets = TimeSeries::Value.new(date: row["date"], value: Money.new(row["assets"].to_d))
expected_liabilities = TimeSeries::Value.new(date: row["date"], value: Money.new(row["liabilities"].to_d))
expected_net_worth = TimeSeries::Value.new(date: row["date"], value: Money.new(row["net_worth"].to_d))
actual = {
date: asset_series.data[index][:date],
assets: asset_series.data[index][:value].amount,
liabilities: liability_series.data[index][:value].amount,
net_worth: net_worth_series.data[index][:value].amount
}
assert_equal expected, actual
assert_equal expected_assets, asset_series.values[index]
assert_equal expected_liabilities, liability_series.values[index]
assert_equal expected_net_worth, net_worth_series.values[index]
end
end
@ -103,80 +95,4 @@ class FamilyTest < ActiveSupport::TestCase
assert_equal liabilities_before - disabled_cc.balance, @family.liabilities
assert_equal net_worth_before - disabled_checking.balance + disabled_cc.balance, @family.net_worth
end
test "calculates balances by type" do
verify_balances_by_type(
period: Period.all,
expected_asset_total: BigDecimal("25550"),
expected_liability_total: BigDecimal("1000"),
expected_asset_groups: {
"Account::OtherAsset" => { end_balance: BigDecimal("550"), start_balance: BigDecimal("400"), allocation: 2.15 },
"Account::Depository" => { end_balance: BigDecimal("25000"), start_balance: BigDecimal("25250"), allocation: 97.85 }
},
expected_liability_groups: {
"Account::Credit" => { end_balance: BigDecimal("1000"), start_balance: BigDecimal("1040"), allocation: 100 }
}
)
end
test "calculates balances by type with a date range filter" do
verify_balances_by_type(
period: Period.new(name: "custom", date_range: 7.days.ago.to_date..2.days.ago.to_date),
expected_asset_total: BigDecimal("26050"),
expected_liability_total: BigDecimal("1000"),
expected_asset_groups: {
"Account::OtherAsset" => { end_balance: BigDecimal("550"), start_balance: BigDecimal("700"), allocation: 2.11 },
"Account::Depository" => { end_balance: BigDecimal("25500"), start_balance: BigDecimal("24510"), allocation: 97.89 }
},
expected_liability_groups: {
"Account::Credit" => { end_balance: BigDecimal("1000"), start_balance: BigDecimal("990"), allocation: 100 }
}
)
end
test "calculates balances by type with disabled account" do
disabled_checking = accounts(:checking).update!(is_active: false)
verify_balances_by_type(
period: Period.all,
expected_asset_total: BigDecimal("20550"),
expected_liability_total: BigDecimal("1000"),
expected_asset_groups: {
"Account::OtherAsset" => { end_balance: BigDecimal("550"), start_balance: BigDecimal("400"), allocation: 2.68 },
"Account::Depository" => { end_balance: BigDecimal("20000"), start_balance: BigDecimal("21250"), allocation: 97.32 }
},
expected_liability_groups: {
"Account::Credit" => { end_balance: BigDecimal("1000"), start_balance: BigDecimal("1040"), allocation: 100 }
}
)
end
private
def verify_balances_by_type(period:, expected_asset_total:, expected_liability_total:, expected_asset_groups:, expected_liability_groups:)
result = @family.accounts.by_group(period)
asset_total = result[:asset][:total]
liability_total = result[:liability][:total]
assert_equal expected_asset_total, asset_total
assert_equal expected_liability_total, liability_total
asset_groups = result[:asset][:groups]
liability_groups = result[:liability][:groups]
assert_equal expected_asset_groups.keys, asset_groups.keys
expected_asset_groups.each do |type, expected_values|
assert_equal expected_values[:end_balance], asset_groups[type][:end_balance]
assert_equal expected_values[:start_balance], asset_groups[type][:start_balance]
assert_equal expected_values[:allocation], asset_groups[type][:allocation]
end
assert_equal expected_liability_groups.keys, liability_groups.keys
expected_liability_groups.each do |type, expected_values|
assert_equal expected_values[:end_balance], liability_groups[type][:end_balance]
assert_equal expected_values[:start_balance], liability_groups[type][:start_balance]
assert_equal expected_values[:allocation], liability_groups[type][:allocation]
end
end
end