636 lines
21 KiB
Rust
636 lines
21 KiB
Rust
//! Invariant tests: the gates every change must pass.
|
|
//!
|
|
//! These are not example tests. They encode the accounting laws the engine
|
|
//! exists to uphold: entries balance, posted entries are immutable, the trial
|
|
//! balance balances, and the accounting equation holds. A feature that breaks
|
|
//! any of these is not a feature.
|
|
//!
|
|
//! Plus the golden test: the canonical fixture company's reports must match
|
|
//! `golden/fixture_company.json` byte-for-value. That file is the seed of the
|
|
//! semantic oracle (see `docs/oracle.md`).
|
|
|
|
use chrono::NaiveDate;
|
|
use ledger_core::reports::{balance_sheet, profit_and_loss, snapshot, trial_balance};
|
|
use ledger_core::{
|
|
AccountId, AccountType, Currency, EntryStatus, Ledger, LedgerError, Money, Side,
|
|
};
|
|
use rust_decimal::Decimal;
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Fixture: a tiny service company, January 2026.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
fn date(day: u32) -> NaiveDate {
|
|
NaiveDate::from_ymd_opt(2026, 1, day).unwrap()
|
|
}
|
|
|
|
fn usd(amount: u64) -> Money {
|
|
Money::new(Decimal::from(amount), Currency::USD)
|
|
}
|
|
|
|
/// Post a balanced entry in one call. Panics on programmer error: fixtures
|
|
/// must be valid by construction.
|
|
fn post(ledger: &mut Ledger, date: NaiveDate, description: &str, lines: &[(AccountId, Side, u64)]) {
|
|
let id = ledger.create_entry(date, description);
|
|
for (account, side, amount) in lines {
|
|
ledger.add_line(id, *account, *side, usd(*amount)).unwrap();
|
|
}
|
|
ledger.post_entry(id).unwrap();
|
|
}
|
|
|
|
struct Company {
|
|
ledger: Ledger,
|
|
cash: AccountId,
|
|
ar: AccountId,
|
|
equipment: AccountId,
|
|
_ap: AccountId,
|
|
equity: AccountId,
|
|
revenue: AccountId,
|
|
rent: AccountId,
|
|
}
|
|
|
|
fn fixture_company() -> Company {
|
|
let mut ledger = Ledger::new(Currency::USD);
|
|
let cash = ledger
|
|
.add_account("1000", "Cash", AccountType::Asset, None, false)
|
|
.unwrap();
|
|
let ar = ledger
|
|
.add_account(
|
|
"1200",
|
|
"Accounts Receivable",
|
|
AccountType::Asset,
|
|
None,
|
|
false,
|
|
)
|
|
.unwrap();
|
|
let equipment = ledger
|
|
.add_account("1500", "Equipment", AccountType::Asset, None, false)
|
|
.unwrap();
|
|
let ap = ledger
|
|
.add_account(
|
|
"2000",
|
|
"Accounts Payable",
|
|
AccountType::Liability,
|
|
None,
|
|
false,
|
|
)
|
|
.unwrap();
|
|
let equity = ledger
|
|
.add_account("3000", "Owner's Equity", AccountType::Equity, None, false)
|
|
.unwrap();
|
|
let revenue = ledger
|
|
.add_account("4000", "Service Revenue", AccountType::Revenue, None, false)
|
|
.unwrap();
|
|
let rent = ledger
|
|
.add_account("6000", "Rent Expense", AccountType::Expense, None, false)
|
|
.unwrap();
|
|
|
|
// Owner invests $10,000 cash.
|
|
post(
|
|
&mut ledger,
|
|
date(2),
|
|
"Owner investment",
|
|
&[(cash, Side::Debit, 10_000), (equity, Side::Credit, 10_000)],
|
|
);
|
|
// Buy equipment for $2,500 cash.
|
|
post(
|
|
&mut ledger,
|
|
date(5),
|
|
"Buy equipment",
|
|
&[(equipment, Side::Debit, 2_500), (cash, Side::Credit, 2_500)],
|
|
);
|
|
// Bill a client $4,000.
|
|
post(
|
|
&mut ledger,
|
|
date(10),
|
|
"Invoice client",
|
|
&[(ar, Side::Debit, 4_000), (revenue, Side::Credit, 4_000)],
|
|
);
|
|
// Pay January rent, $800.
|
|
post(
|
|
&mut ledger,
|
|
date(15),
|
|
"January rent",
|
|
&[(rent, Side::Debit, 800), (cash, Side::Credit, 800)],
|
|
);
|
|
// Collect $1,500 of receivables.
|
|
post(
|
|
&mut ledger,
|
|
date(20),
|
|
"Client payment",
|
|
&[(cash, Side::Debit, 1_500), (ar, Side::Credit, 1_500)],
|
|
);
|
|
|
|
Company {
|
|
ledger,
|
|
cash,
|
|
ar,
|
|
equipment,
|
|
_ap: ap,
|
|
equity,
|
|
revenue,
|
|
rent,
|
|
}
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Validation: the engine refuses bad entries.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn unbalanced_entry_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "Bad entry");
|
|
ledger.add_line(id, c.cash, Side::Debit, usd(100)).unwrap();
|
|
ledger
|
|
.add_line(id, c.equity, Side::Credit, usd(99))
|
|
.unwrap();
|
|
let err = ledger.post_entry(id).unwrap_err();
|
|
assert_eq!(
|
|
err,
|
|
LedgerError::UnbalancedEntry {
|
|
debits: Decimal::from(100),
|
|
credits: Decimal::from(99),
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn single_line_entry_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "One line");
|
|
ledger.add_line(id, c.cash, Side::Debit, usd(100)).unwrap();
|
|
assert_eq!(ledger.post_entry(id).unwrap_err(), LedgerError::TooFewLines);
|
|
}
|
|
|
|
#[test]
|
|
fn zero_amount_line_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "Zero line");
|
|
ledger.add_line(id, c.cash, Side::Debit, usd(100)).unwrap();
|
|
ledger.add_line(id, c.cash, Side::Debit, usd(0)).unwrap();
|
|
ledger
|
|
.add_line(id, c.equity, Side::Credit, usd(100))
|
|
.unwrap();
|
|
assert_eq!(
|
|
ledger.post_entry(id).unwrap_err(),
|
|
LedgerError::ZeroAmountLine
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unknown_account_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "Ghost account");
|
|
ledger.add_line(id, c.cash, Side::Debit, usd(100)).unwrap();
|
|
ledger
|
|
.add_line(id, 999_999, Side::Credit, usd(100))
|
|
.unwrap();
|
|
assert_eq!(
|
|
ledger.post_entry(id).unwrap_err(),
|
|
LedgerError::UnknownAccount(999_999)
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn placeholder_account_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let header = ledger
|
|
.add_account("100", "Assets header", AccountType::Asset, None, true)
|
|
.unwrap();
|
|
let id = ledger.create_entry(date(21), "Post to header");
|
|
ledger.add_line(id, header, Side::Debit, usd(100)).unwrap();
|
|
ledger
|
|
.add_line(id, c.equity, Side::Credit, usd(100))
|
|
.unwrap();
|
|
assert_eq!(
|
|
ledger.post_entry(id).unwrap_err(),
|
|
LedgerError::PlaceholderAccount("100".to_string())
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn foreign_currency_line_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "Euro line");
|
|
let eur = Money::new(Decimal::from(100), Currency::EUR);
|
|
let err = ledger.add_line(id, c.cash, Side::Debit, eur).unwrap_err();
|
|
assert_eq!(
|
|
err,
|
|
LedgerError::CurrencyMismatch {
|
|
expected: "USD".to_string(),
|
|
found: "EUR".to_string(),
|
|
}
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn duplicate_account_code_is_rejected() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let err = ledger
|
|
.add_account("1000", "Cash again", AccountType::Asset, None, false)
|
|
.unwrap_err();
|
|
assert_eq!(err, LedgerError::DuplicateAccountCode("1000".to_string()));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Immutability: posted entries can only be corrected by reversal.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn posted_entry_is_immutable() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "To post");
|
|
ledger.add_line(id, c.cash, Side::Debit, usd(50)).unwrap();
|
|
ledger
|
|
.add_line(id, c.equity, Side::Credit, usd(50))
|
|
.unwrap();
|
|
ledger.post_entry(id).unwrap();
|
|
|
|
// Cannot add lines after posting.
|
|
assert_eq!(
|
|
ledger
|
|
.add_line(id, c.cash, Side::Debit, usd(1))
|
|
.unwrap_err(),
|
|
LedgerError::PostedEntryImmutable
|
|
);
|
|
// Cannot post twice.
|
|
assert_eq!(
|
|
ledger.post_entry(id).unwrap_err(),
|
|
LedgerError::EntryAlreadyPosted(id)
|
|
);
|
|
assert_eq!(ledger.get_entry(id).unwrap().status(), EntryStatus::Posted);
|
|
}
|
|
|
|
#[test]
|
|
fn reversal_nets_to_zero_and_links_back() {
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let id = ledger.create_entry(date(21), "Mistake");
|
|
ledger.add_line(id, c.rent, Side::Debit, usd(500)).unwrap();
|
|
ledger.add_line(id, c.cash, Side::Credit, usd(500)).unwrap();
|
|
ledger.post_entry(id).unwrap();
|
|
assert_eq!(ledger.account_movement(c.rent), Decimal::from(1300));
|
|
|
|
let rev = ledger
|
|
.reverse_entry(id, date(22), "Reverse mistake")
|
|
.unwrap();
|
|
let rev_entry = ledger.get_entry(rev).unwrap();
|
|
assert_eq!(rev_entry.reversal_of(), Some(id));
|
|
assert_eq!(rev_entry.status(), EntryStatus::Posted);
|
|
|
|
// The mistake and its reversal cancel exactly: back to fixture values.
|
|
assert_eq!(ledger.account_movement(c.rent), Decimal::from(800));
|
|
assert_eq!(ledger.account_movement(c.cash), Decimal::from(8200));
|
|
// And the books still balance everywhere.
|
|
assert!(trial_balance(&ledger).balanced());
|
|
assert!(balance_sheet(&ledger).unwrap().balanced());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Reports: the accounting laws hold.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn trial_balance_balances() {
|
|
let c = fixture_company();
|
|
let tb = trial_balance(&c.ledger);
|
|
assert!(tb.balanced());
|
|
assert_eq!(tb.total_debits, Decimal::from(14_000));
|
|
assert_eq!(tb.total_credits, Decimal::from(14_000));
|
|
// Six accounts with non-zero balances, sorted by code.
|
|
let codes: Vec<_> = tb.lines.iter().map(|l| l.code.as_str()).collect();
|
|
assert_eq!(codes, vec!["1000", "1200", "1500", "3000", "4000", "6000"]);
|
|
}
|
|
|
|
#[test]
|
|
fn accounting_equation_holds() {
|
|
let c = fixture_company();
|
|
let bs = balance_sheet(&c.ledger).unwrap();
|
|
assert!(bs.balanced());
|
|
assert_eq!(bs.assets, Decimal::from(13_200));
|
|
assert_eq!(bs.liabilities, Decimal::ZERO);
|
|
// Equity = owner's capital 10,000 + net income 3,200.
|
|
assert_eq!(bs.equity, Decimal::from(13_200));
|
|
assert_eq!(bs.current_earnings, Decimal::from(3_200));
|
|
}
|
|
|
|
#[test]
|
|
fn profit_and_loss_is_correct() {
|
|
let c = fixture_company();
|
|
let pl = profit_and_loss(&c.ledger).unwrap();
|
|
assert_eq!(pl.revenue, Decimal::from(4_000));
|
|
assert_eq!(pl.expenses, Decimal::from(800));
|
|
assert_eq!(pl.net_income(), Decimal::from(3_200));
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Property-ish test: random balanced journals preserve every invariant.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
/// Tiny deterministic PRNG. No dependencies, reproducible seeds.
|
|
struct Lcg(u64);
|
|
|
|
impl Lcg {
|
|
fn next(&mut self, bound: u64) -> u64 {
|
|
self.0 = self
|
|
.0
|
|
.wrapping_mul(6364136223846793005)
|
|
.wrapping_add(1442695040888963407);
|
|
(self.0 >> 33) % bound
|
|
}
|
|
}
|
|
|
|
/// Split `total` into `parts` positive whole-unit pieces.
|
|
fn split_total(rng: &mut Lcg, total: u64, parts: usize) -> Vec<u64> {
|
|
assert!(total >= parts as u64 && parts >= 1);
|
|
let mut cuts = vec![0u64, total];
|
|
while cuts.len() < parts + 1 {
|
|
let c = rng.next(total - 1) + 1; // 1..total
|
|
if !cuts.contains(&c) {
|
|
cuts.push(c);
|
|
}
|
|
}
|
|
cuts.sort_unstable();
|
|
cuts.windows(2).map(|w| w[1] - w[0]).collect()
|
|
}
|
|
|
|
#[test]
|
|
fn random_balanced_journals_preserve_invariants() {
|
|
let mut rng = Lcg(0x1234_5678_9abc_def0);
|
|
let c = fixture_company();
|
|
let mut ledger = c.ledger;
|
|
let accounts = [
|
|
c.cash,
|
|
c.ar,
|
|
c.equipment,
|
|
c._ap,
|
|
c.equity,
|
|
c.revenue,
|
|
c.rent,
|
|
];
|
|
|
|
for i in 0..300u32 {
|
|
let total = rng.next(100_000) + 100;
|
|
let nd = (rng.next(3) + 1) as usize;
|
|
let nc = (rng.next(3) + 1) as usize;
|
|
let id = ledger.create_entry(date(21), &format!("random {i}"));
|
|
for part in split_total(&mut rng, total, nd) {
|
|
let acct = accounts[rng.next(accounts.len() as u64) as usize];
|
|
ledger.add_line(id, acct, Side::Debit, usd(part)).unwrap();
|
|
}
|
|
for part in split_total(&mut rng, total, nc) {
|
|
let acct = accounts[rng.next(accounts.len() as u64) as usize];
|
|
ledger.add_line(id, acct, Side::Credit, usd(part)).unwrap();
|
|
}
|
|
ledger.post_entry(id).unwrap();
|
|
}
|
|
|
|
// Every invariant still holds after 300 random balanced entries.
|
|
let tb = trial_balance(&ledger);
|
|
assert!(tb.balanced());
|
|
assert!(balance_sheet(&ledger).unwrap().balanced());
|
|
|
|
// Conservation: the sum of all account movements is exactly zero.
|
|
let mut sum = Decimal::ZERO;
|
|
for a in accounts {
|
|
sum += ledger.account_movement(a);
|
|
}
|
|
assert!(sum.is_zero());
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Golden test: the oracle seed.
|
|
// ---------------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn golden_fixture_company_reports() {
|
|
let c = fixture_company();
|
|
let snap = snapshot(&c.ledger).unwrap();
|
|
let golden: serde_json::Value =
|
|
serde_json::from_str(include_str!("golden/fixture_company.json")).unwrap();
|
|
assert_eq!(snap, golden);
|
|
}
|
|
|
|
#[test]
|
|
fn parent_account_validation() {
|
|
let mut ledger = Ledger::new(Currency::USD);
|
|
// Unknown parent is rejected.
|
|
let err = ledger
|
|
.add_account("1100", "Child", AccountType::Asset, Some(999), false)
|
|
.unwrap_err();
|
|
assert_eq!(err, LedgerError::UnknownParentAccount(999));
|
|
// A real parent works, and the child records it.
|
|
let parent = ledger
|
|
.add_account("1000", "Parent", AccountType::Asset, None, true)
|
|
.unwrap();
|
|
let child = ledger
|
|
.add_account("1100", "Child", AccountType::Asset, Some(parent), false)
|
|
.unwrap();
|
|
assert_eq!(ledger.chart().get(child).unwrap().parent, Some(parent));
|
|
// Chart accessors report honestly.
|
|
assert!(Ledger::new(Currency::USD).chart().is_empty());
|
|
assert!(!ledger.chart().is_empty());
|
|
assert_eq!(ledger.chart().len(), 2);
|
|
assert!(ledger.chart().find_by_code("1000").is_some());
|
|
assert!(ledger.chart().find_by_code("nope").is_none());
|
|
}
|
|
|
|
#[test]
|
|
fn account_type_balance_sheet_predicate() {
|
|
assert!(AccountType::Asset.is_balance_sheet());
|
|
assert!(AccountType::Liability.is_balance_sheet());
|
|
assert!(AccountType::Equity.is_balance_sheet());
|
|
assert!(!AccountType::Revenue.is_balance_sheet());
|
|
assert!(!AccountType::Expense.is_balance_sheet());
|
|
}
|
|
|
|
#[test]
|
|
fn entry_movements_sum_to_zero() {
|
|
let mut c = fixture_company();
|
|
let cash = c.cash;
|
|
let revenue = c.revenue;
|
|
let id = c.ledger.create_entry(date(15), "sale");
|
|
c.ledger.add_line(id, cash, Side::Debit, usd(1000)).unwrap();
|
|
c.ledger
|
|
.add_line(id, revenue, Side::Credit, usd(1000))
|
|
.unwrap();
|
|
c.ledger.post_entry(id).unwrap();
|
|
let entry = c.ledger.get_entry(id).unwrap();
|
|
let m = entry.movements();
|
|
assert_eq!(m[&cash], Decimal::new(100000, 2));
|
|
assert_eq!(m[&revenue], Decimal::new(-100000, 2));
|
|
let total: Decimal = m.values().copied().sum();
|
|
assert_eq!(total, Decimal::ZERO);
|
|
}
|
|
|
|
// ---------------------------------------------------------------------------
|
|
// Cash flow statement (indirect method).
|
|
// ---------------------------------------------------------------------------
|
|
|
|
use ledger_core::NewAsset;
|
|
use ledger_core::reports::{CashFlowParams, cash_flow};
|
|
|
|
fn cash_flow_params(cash: AccountId) -> CashFlowParams {
|
|
CashFlowParams {
|
|
start: date(1),
|
|
end: date(31),
|
|
cash_accounts: vec![cash],
|
|
financing_accounts: vec![],
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn cash_flow_reconciles_to_change_in_cash() {
|
|
let c = fixture_company();
|
|
let cf = cash_flow(&c.ledger, &cash_flow_params(c.cash)).unwrap();
|
|
|
|
// The three sections must sum to the net change in cash. This is the
|
|
// accounting law the statement exists to uphold.
|
|
let sections = cf.cash_from_operations + cf.cash_from_investing + cf.cash_from_financing;
|
|
assert_eq!(sections, cf.net_change_in_cash);
|
|
assert_eq!(cf.cash_ending - cf.cash_beginning, cf.net_change_in_cash);
|
|
|
|
// Hand-computed from the fixture:
|
|
// Cash: +10,000 (invest) - 2,500 (equipment) - 800 (rent) + 1,500 (collect)
|
|
// = 8,200. Beginning 0.
|
|
assert_eq!(cf.cash_beginning, Decimal::ZERO);
|
|
assert_eq!(cf.cash_ending, Decimal::new(820000, 2));
|
|
assert_eq!(cf.net_change_in_cash, Decimal::new(820000, 2));
|
|
|
|
// Net income: 4,000 revenue - 800 rent = 3,200.
|
|
assert_eq!(cf.net_income, Decimal::new(320000, 2));
|
|
// No depreciation: the fixture's equipment is not a registered asset.
|
|
assert_eq!(cf.depreciation, Decimal::ZERO);
|
|
|
|
// Operating: 3,200 net income
|
|
// - 2,500 increase in AR (4,000 billed - 1,500 collected)
|
|
// - 2,500 equipment purchase (not a registered asset: working capital)
|
|
// + 10,000 owner investment is equity -> financing, not operating.
|
|
// Financing: +10,000 owner contribution.
|
|
// => operating = 3,200 - 2,500 - 2,500 = -1,800
|
|
// => investing = 0, financing = 10,000. Sum = 8,200. Reconciles.
|
|
assert_eq!(cf.cash_from_operations, Decimal::new(-180000, 2));
|
|
assert_eq!(cf.cash_from_investing, Decimal::ZERO);
|
|
assert_eq!(cf.cash_from_financing, Decimal::new(1000000, 2));
|
|
}
|
|
|
|
#[test]
|
|
fn cash_flow_with_registered_asset_and_disposal() {
|
|
let mut ledger = Ledger::new(Currency::USD);
|
|
let cash = ledger
|
|
.add_account("1000", "Cash", AccountType::Asset, None, false)
|
|
.unwrap();
|
|
let cost = ledger
|
|
.add_account("1500", "Equipment at cost", AccountType::Asset, None, false)
|
|
.unwrap();
|
|
let accum = ledger
|
|
.add_account(
|
|
"1501",
|
|
"Accum. depr. — equip.",
|
|
AccountType::Asset,
|
|
None,
|
|
false,
|
|
)
|
|
.unwrap();
|
|
let depr_exp = ledger
|
|
.add_account(
|
|
"6000",
|
|
"Depreciation expense",
|
|
AccountType::Expense,
|
|
None,
|
|
false,
|
|
)
|
|
.unwrap();
|
|
let revenue = ledger
|
|
.add_account("4000", "Service Revenue", AccountType::Revenue, None, false)
|
|
.unwrap();
|
|
let gain = ledger
|
|
.add_account("4100", "Gain on sale", AccountType::Revenue, None, false)
|
|
.unwrap();
|
|
let equity = ledger
|
|
.add_account("3000", "Owner's Equity", AccountType::Equity, None, false)
|
|
.unwrap();
|
|
|
|
// Owner invests $100,000.
|
|
post(
|
|
&mut ledger,
|
|
date(2),
|
|
"Owner investment",
|
|
&[
|
|
(cash, Side::Debit, 100_000),
|
|
(equity, Side::Credit, 100_000),
|
|
],
|
|
);
|
|
// Register a $60,000 van, 60-month life, bought Jan 15.
|
|
let asset = ledger
|
|
.register_asset(NewAsset {
|
|
description: "Van".to_string(),
|
|
purchase_date: NaiveDate::from_ymd_opt(2026, 1, 15).unwrap(),
|
|
cost: usd(60_000),
|
|
salvage_value: usd(0),
|
|
useful_life_months: 60,
|
|
cost_account: cost,
|
|
accum_depr_account: accum,
|
|
expense_account: depr_exp,
|
|
})
|
|
.unwrap();
|
|
// Buy the van for cash.
|
|
post(
|
|
&mut ledger,
|
|
date(15),
|
|
"Buy van",
|
|
&[(cost, Side::Debit, 60_000), (cash, Side::Credit, 60_000)],
|
|
);
|
|
// January depreciation: $1,000 * 17/31 = $548.39.
|
|
post(
|
|
&mut ledger,
|
|
date(31),
|
|
"January depreciation",
|
|
&[(depr_exp, Side::Debit, 548), (accum, Side::Credit, 548)],
|
|
);
|
|
// Sell the van Jan 31 for $59,600 cash. Book value 60,000 - 548 = 59,452.
|
|
// Gain = 59,600 - 59,452 = 148.
|
|
// Note: amounts are whole dollars here to keep the fixture simple.
|
|
let _ = asset;
|
|
post(
|
|
&mut ledger,
|
|
date(31),
|
|
"Sell van",
|
|
&[
|
|
(cash, Side::Debit, 59_600),
|
|
(accum, Side::Debit, 548),
|
|
(cost, Side::Credit, 60_000),
|
|
(gain, Side::Credit, 148),
|
|
],
|
|
);
|
|
|
|
let cf = cash_flow(&ledger, &cash_flow_params(cash)).unwrap();
|
|
|
|
// Reconciliation is the law.
|
|
let sections = cf.cash_from_operations + cf.cash_from_investing + cf.cash_from_financing;
|
|
assert_eq!(sections, cf.net_change_in_cash);
|
|
|
|
// Cash: 100,000 - 60,000 + 59,600 = 99,600.
|
|
assert_eq!(cf.cash_ending, Decimal::new(9960000, 2));
|
|
// Net income: 148 gain - 548 depreciation = -400.
|
|
assert_eq!(cf.net_income, Decimal::new(-40000, 2));
|
|
// Depreciation added back: 548.
|
|
assert_eq!(cf.depreciation, Decimal::new(54800, 2));
|
|
// Operating: -400 + 548 - 148 (gain removed) = 0.
|
|
assert_eq!(cf.cash_from_operations, Decimal::ZERO);
|
|
// Investing: -60,000 purchase + 59,600 proceeds = -400.
|
|
assert_eq!(cf.cash_from_investing, Decimal::new(-40000, 2));
|
|
// Financing: +100,000 owner investment.
|
|
assert_eq!(cf.cash_from_financing, Decimal::new(10000000, 2));
|
|
// Sum: 0 - 400 + 100,000 = 99,600. Matches cash.
|
|
}
|