swaitsandClaude Opus 5.5
ee7e205f5c
check / check (push) Waiting to run
- core: asset tags (generated PREFIX-0001 or the human's own; unique ignoring case; never reused by another asset) and serial numbers (rules.md B-24); a journaled link from an asset to the entry that acquired it (posted, unreversed, debiting the cost account); fixed_asset_register(as_of), reconciled to the GL (unposted depreciation, unregistered cost) - store: asset.tagged, asset.serial_set, asset.acquisition_linked journaled, replayed, projected (schema v9); differs_from now also compares control roles and tag history - config: [books] asset_tag_prefix, default the company's initials without legal-form words - import: Avery 5160/8160 label sheets with QR codes (geometry vendored from Avery, docs/spec/sources/avery-5160.md); the register as XLSX and PDF - mcp: register_asset tags (and links) automatically; books.label_asset, books.asset_labels; asset tools take a tag; books.show asset / assets page / register report; export fixed_asset_register (json, csv, xlsx, pdf) and in the CPA package - viewer: Assets page (register, reconciliation), asset page (identity, schedule posted vs not, entries, documents), Fixed asset register report, global search by tag/serial/description, journal text, needs-attention items - fix: verify compared snapshot amounts as strings; a zero total summed in hash-map order could print "0" or "0.00", so agreeing books failed verify at random. Now by value (regression test) - tests: spec-blind suites for tags, register, prefix, store, MCP; label and register PDF/XLSX tests; viewer tests Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01GWVo7x3UHw5kwCUaWxiejX
615 lines
21 KiB
Rust
615 lines
21 KiB
Rust
//! Fixed assets in the viewer: the register and each asset's schedule are
|
|
//! ledger-core's numbers exactly; what's posted comes from the journal;
|
|
//! search, books.show, the journal, and "Needs attention" know assets.
|
|
|
|
use chrono::{Datelike, Days, Months, NaiveDate};
|
|
use egui_kittest::Harness;
|
|
use ledger_core::{
|
|
AccountType, AssetId, Currency, EntryId, Money, NewAsset, Side, depreciation_schedule,
|
|
fixed_asset_register,
|
|
};
|
|
use ledger_gui::books::Books;
|
|
use ledger_gui::nav::{ReportKind, Route};
|
|
use ledger_gui::pages::assets::{MonthStatus, notices, schedule};
|
|
use ledger_gui::pages::journal::describe;
|
|
use ledger_gui::{App, Source, attention, data, fmt, palette};
|
|
use ledger_store::Store;
|
|
use ledger_store::viewer::ViewerTarget;
|
|
use proptest::prelude::*;
|
|
use rust_decimal::Decimal;
|
|
use std::path::{Path, PathBuf};
|
|
use std::sync::atomic::{AtomicUsize, Ordering};
|
|
|
|
static DIRS: AtomicUsize = AtomicUsize::new(0);
|
|
|
|
struct TempDir(PathBuf);
|
|
|
|
impl TempDir {
|
|
fn new(tag: &str) -> TempDir {
|
|
let n = DIRS.fetch_add(1, Ordering::Relaxed);
|
|
let d = std::env::temp_dir().join(format!(
|
|
"ledger-gui-assets-{tag}-{}-{n}",
|
|
std::process::id()
|
|
));
|
|
let _ = std::fs::remove_dir_all(&d);
|
|
std::fs::create_dir_all(&d).unwrap();
|
|
TempDir(d)
|
|
}
|
|
}
|
|
|
|
impl Drop for TempDir {
|
|
fn drop(&mut self) {
|
|
let _ = std::fs::remove_dir_all(&self.0);
|
|
}
|
|
}
|
|
|
|
fn d(y: i32, m: u32, day: u32) -> NaiveDate {
|
|
NaiveDate::from_ymd_opt(y, m, day).unwrap()
|
|
}
|
|
|
|
fn usd(cents: i64) -> Money {
|
|
Money::new(Decimal::new(cents, 2), Currency::USD)
|
|
}
|
|
|
|
fn load(dir: &Path, today: NaiveDate) -> Books {
|
|
data::load_once(&Source {
|
|
data_dir: dir.join("books-data"),
|
|
books_toml: None,
|
|
today: Some(today),
|
|
})
|
|
.unwrap()
|
|
}
|
|
|
|
struct Fixture {
|
|
_dir: TempDir,
|
|
books: Books,
|
|
/// The store's own ledger (the oracle's input), reopened from disk.
|
|
oracle: ledger_core::Ledger,
|
|
laptop: AssetId,
|
|
monitor: AssetId,
|
|
old: AssetId,
|
|
laptop_purchase: EntryId,
|
|
}
|
|
|
|
const TODAY: (i32, u32, u32) = (2026, 10, 15);
|
|
|
|
fn today() -> NaiveDate {
|
|
d(TODAY.0, TODAY.1, TODAY.2)
|
|
}
|
|
|
|
/// A laptop (tagged, serial, depreciation through July), a monitor (no
|
|
/// tag, through August), and an old laptop retagged, its serial cleared,
|
|
/// and sold in June.
|
|
fn fixture(tag: &str) -> Fixture {
|
|
let dir = TempDir::new(tag);
|
|
let data = dir.0.join("books-data");
|
|
let mut s = Store::create(&data, Currency::USD).unwrap();
|
|
let cash = s
|
|
.add_account("1000", "Checking", AccountType::Asset, None, false)
|
|
.unwrap();
|
|
let equip = s
|
|
.add_account("1500", "Equipment", AccountType::Asset, None, false)
|
|
.unwrap();
|
|
let accum = s
|
|
.add_account(
|
|
"1510",
|
|
"Accumulated Depreciation",
|
|
AccountType::Asset,
|
|
None,
|
|
false,
|
|
)
|
|
.unwrap();
|
|
let capital = s
|
|
.add_account("3000", "Capital", AccountType::Equity, None, false)
|
|
.unwrap();
|
|
let dep = s
|
|
.add_account("6500", "Depreciation", AccountType::Expense, None, false)
|
|
.unwrap();
|
|
let gain = s
|
|
.add_account("7000", "Gain on sale", AccountType::Revenue, None, false)
|
|
.unwrap();
|
|
let buy = |s: &mut Store, date, what: &str, cents| {
|
|
let e = s.create_entry(date, what).unwrap();
|
|
s.add_line(e, equip, Side::Debit, usd(cents)).unwrap();
|
|
s.add_line(e, cash, Side::Credit, usd(cents)).unwrap();
|
|
s.post_entry(e).unwrap();
|
|
e
|
|
};
|
|
let e = s.create_entry(d(2026, 1, 1), "Owner contribution").unwrap();
|
|
s.add_line(e, cash, Side::Debit, usd(1_000_000)).unwrap();
|
|
s.add_line(e, capital, Side::Credit, usd(1_000_000))
|
|
.unwrap();
|
|
s.post_entry(e).unwrap();
|
|
let register = |s: &mut Store, what: &str, date, cents, salvage, months| {
|
|
s.register_asset(NewAsset {
|
|
description: what.into(),
|
|
purchase_date: date,
|
|
cost: usd(cents),
|
|
salvage_value: usd(salvage),
|
|
useful_life_months: months,
|
|
cost_account: equip,
|
|
accum_depr_account: accum,
|
|
expense_account: dep,
|
|
})
|
|
.unwrap()
|
|
};
|
|
let laptop_purchase = buy(&mut s, d(2026, 1, 10), "Laptop", 300_000);
|
|
let laptop = register(&mut s, "Laptop", d(2026, 1, 10), 300_000, 0, 36);
|
|
buy(&mut s, d(2026, 2, 1), "Monitor", 120_000);
|
|
let monitor = register(&mut s, "Monitor", d(2026, 2, 1), 120_000, 0, 12);
|
|
buy(&mut s, d(2026, 1, 1), "Old laptop", 60_000);
|
|
let old = register(&mut s, "Old laptop", d(2026, 1, 1), 60_000, 10_000, 24);
|
|
s.set_asset_tag(laptop, "WL-0001").unwrap();
|
|
s.set_asset_serial(laptop, Some("SN-123")).unwrap();
|
|
s.set_asset_tag(old, "OLD-1").unwrap();
|
|
s.set_asset_tag(old, "WL-0009").unwrap();
|
|
s.set_asset_serial(old, Some("X1")).unwrap();
|
|
s.set_asset_serial(old, None).unwrap();
|
|
for m in 1..=7 {
|
|
s.run_depreciation(laptop, &format!("2026-{m:02}")).unwrap();
|
|
}
|
|
for m in 2..=8 {
|
|
s.run_depreciation(monitor, &format!("2026-{m:02}"))
|
|
.unwrap();
|
|
}
|
|
for m in 1..=3 {
|
|
s.run_depreciation(old, &format!("2026-{m:02}")).unwrap();
|
|
}
|
|
s.dispose_asset(old, d(2026, 6, 30), usd(30_000), cash, gain)
|
|
.unwrap();
|
|
drop(s);
|
|
let oracle = Store::open(&data).unwrap().ledger().clone();
|
|
Fixture {
|
|
books: load(&dir.0, today()),
|
|
_dir: dir,
|
|
oracle,
|
|
laptop,
|
|
monitor,
|
|
old,
|
|
laptop_purchase,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn the_register_is_ledger_cores_register() {
|
|
let f = fixture("register");
|
|
let b = &f.books;
|
|
for as_of in [
|
|
d(2025, 12, 31),
|
|
d(2026, 1, 10),
|
|
d(2026, 3, 31),
|
|
d(2026, 6, 29),
|
|
d(2026, 6, 30),
|
|
d(2026, 7, 31),
|
|
d(2026, 9, 30),
|
|
today(),
|
|
d(2030, 1, 1),
|
|
] {
|
|
let mine = b.asset_register(as_of);
|
|
let oracle = fixed_asset_register(&f.oracle, as_of);
|
|
assert_eq!(mine, oracle, "register on {as_of}");
|
|
}
|
|
let r = b.asset_register(today());
|
|
assert_eq!(r.rows.len(), 3);
|
|
let old = r.rows.iter().find(|x| x.asset_id == f.old).unwrap();
|
|
assert_eq!(
|
|
old.disposed,
|
|
Some((d(2026, 6, 30), Decimal::new(30_000, 2)))
|
|
);
|
|
assert_eq!(
|
|
ledger_gui::pages::assets::status_text(old.disposed),
|
|
"Disposed Jun 30, 2026 for $300.00"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn depreciation_due_is_the_register_through_the_last_finished_month() {
|
|
let f = fixture("due");
|
|
let b = &f.books;
|
|
let due = b.depreciation_due(today());
|
|
assert_eq!(due.through, d(2026, 9, 30));
|
|
assert_eq!(
|
|
due.amount,
|
|
fixed_asset_register(&f.oracle, d(2026, 9, 30)).unposted_depreciation()
|
|
);
|
|
assert_eq!(due.periods, vec!["2026-08", "2026-09"]);
|
|
// Independently: the laptop's August and September, the monitor's
|
|
// September, straight from the schedules.
|
|
let sched = |id| depreciation_schedule(f.oracle.get_asset(id).unwrap(), d(2026, 9, 30));
|
|
let month = |id, p: &str| {
|
|
sched(id)
|
|
.into_iter()
|
|
.find(|l| l.period == p)
|
|
.unwrap()
|
|
.amount
|
|
};
|
|
assert_eq!(
|
|
due.amount,
|
|
month(f.laptop, "2026-08") + month(f.laptop, "2026-09") + month(f.monitor, "2026-09")
|
|
);
|
|
// A month's last day counts that month as finished.
|
|
assert_eq!(b.depreciation_due(d(2026, 7, 31)).through, d(2026, 7, 31));
|
|
assert_eq!(
|
|
b.depreciation_due(d(2026, 7, 31)).periods,
|
|
Vec::<String>::new()
|
|
);
|
|
|
|
// The notices name the due amount exactly, and the month under way.
|
|
let r = b.asset_register(today());
|
|
let n = notices(b, &r);
|
|
assert!(n[0].problem);
|
|
assert!(
|
|
n[0].text.contains(&format!(
|
|
"Depreciation not yet posted through Sep 30, 2026: {}",
|
|
fmt::dollars(due.amount)
|
|
)),
|
|
"{:?}",
|
|
n[0].text
|
|
);
|
|
assert!(n[0].text.contains("ask the bookkeeper to run depreciation"));
|
|
let accruing = r.unposted_depreciation() - due.amount;
|
|
assert!(accruing > Decimal::ZERO);
|
|
assert!(n[1].text.contains(&fmt::dollars(accruing)));
|
|
assert!(!n[1].problem);
|
|
}
|
|
|
|
#[test]
|
|
fn an_assets_schedule_and_trail() {
|
|
let f = fixture("schedule");
|
|
let b = &f.books;
|
|
let lines = schedule(b, f.laptop);
|
|
let asset = f.oracle.get_asset(f.laptop).unwrap();
|
|
let oracle = depreciation_schedule(asset, NaiveDate::MAX);
|
|
assert_eq!(
|
|
oracle.len(),
|
|
37,
|
|
"36 months from Jan 10: 37 calendar months"
|
|
);
|
|
assert_eq!(
|
|
lines.iter().map(|(l, _)| l.clone()).collect::<Vec<_>>(),
|
|
oracle
|
|
);
|
|
let trail = b.asset_trail(f.laptop);
|
|
for (l, st) in &lines {
|
|
let want = match l.period.as_str() {
|
|
p if p <= "2026-07" => MonthStatus::Posted(trail.depreciation[p].0),
|
|
"2026-08" | "2026-09" => MonthStatus::Due,
|
|
"2026-10" => MonthStatus::ThisMonth,
|
|
_ => MonthStatus::Scheduled,
|
|
};
|
|
assert_eq!(*st, want, "{}", l.period);
|
|
}
|
|
// Posted amounts are the schedule's, and the purchase is found.
|
|
for (period, (_, amount)) in &trail.depreciation {
|
|
let l = oracle.iter().find(|l| &l.period == period).unwrap();
|
|
assert_eq!(*amount, l.amount);
|
|
}
|
|
assert_eq!(trail.purchase_entry, Some(f.laptop_purchase));
|
|
assert_eq!(b.entry_assets.get(&f.laptop_purchase), Some(&f.laptop));
|
|
assert_eq!(trail.entries().len(), 1 + 7);
|
|
// The sold laptop: its disposal entry, and a final depreciation.
|
|
let old = b.asset_trail(f.old);
|
|
let disposal = old.disposal_entry.expect("disposal entry");
|
|
assert_eq!(b.entry(disposal).unwrap().origin, "Asset disposal");
|
|
assert!(old.depreciation.contains_key("2026-06"));
|
|
assert_eq!(b.entry_assets.get(&disposal), Some(&f.old));
|
|
assert_eq!(b.asset_label(f.laptop), "WL-0001 Laptop");
|
|
assert_eq!(b.asset_label(f.monitor), "Monitor");
|
|
}
|
|
|
|
#[test]
|
|
fn search_finds_assets_by_tag_serial_and_description() {
|
|
let f = fixture("search");
|
|
let b = &f.books;
|
|
for q in ["WL-0001", "wl-0001", " Wl-0001 "] {
|
|
let items = palette::search(b, q);
|
|
assert_eq!(items[0].route, Route::Asset(f.laptop), "{q}");
|
|
assert_eq!(items[0].score, 2000);
|
|
}
|
|
let first_asset = |q: &str| {
|
|
palette::search(b, q)
|
|
.into_iter()
|
|
.find(|i| matches!(i.route, Route::Asset(_)))
|
|
.map(|i| i.route)
|
|
};
|
|
assert_eq!(first_asset("sn-123"), Some(Route::Asset(f.laptop)));
|
|
assert_eq!(
|
|
palette::search(b, "SN-123")[0].route,
|
|
Route::Asset(f.laptop)
|
|
);
|
|
assert_eq!(first_asset("monitor"), Some(Route::Asset(f.monitor)));
|
|
assert_eq!(first_asset("wl-0009"), Some(Route::Asset(f.old)));
|
|
// Everything else still found as before.
|
|
assert!(
|
|
palette::search(b, "checking")
|
|
.iter()
|
|
.any(|i| matches!(i.route, Route::Account(_)))
|
|
);
|
|
assert!(
|
|
palette::search(b, "")
|
|
.iter()
|
|
.any(|i| i.route == Route::Assets)
|
|
);
|
|
assert!(
|
|
palette::search(b, "fixed asset register")
|
|
.iter()
|
|
.any(|i| i.route == Route::Reports(ReportKind::FixedAssetRegister))
|
|
);
|
|
assert_eq!(
|
|
palette::describe(b, &Route::Asset(f.laptop)),
|
|
"WL-0001 Laptop"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn journal_text_for_asset_events() {
|
|
let f = fixture("journal");
|
|
let b = &f.books;
|
|
let texts: Vec<(String, Option<Route>, Option<Route>)> = b
|
|
.journal
|
|
.iter()
|
|
.filter(|l| l.line_type.starts_with("asset."))
|
|
.filter_map(|l| describe(b, l))
|
|
.map(|e| (e.text, e.route, e.also))
|
|
.collect();
|
|
let has = |t: &str, route: Option<Route>| {
|
|
assert!(
|
|
texts.iter().any(|(x, r, _)| x == t && *r == route),
|
|
"no {t:?} ({route:?}) in {texts:#?}"
|
|
);
|
|
};
|
|
has("Registered asset Laptop", Some(Route::Asset(f.laptop)));
|
|
has("Tagged Laptop WL-0001", Some(Route::Asset(f.laptop)));
|
|
has(
|
|
"Retagged Old laptop from OLD-1 to WL-0009",
|
|
Some(Route::Asset(f.old)),
|
|
);
|
|
has(
|
|
"Serial number of Laptop set to SN-123",
|
|
Some(Route::Asset(f.laptop)),
|
|
);
|
|
has(
|
|
"Serial number of Old laptop cleared",
|
|
Some(Route::Asset(f.old)),
|
|
);
|
|
let disposal = b.asset_trail(f.old).disposal_entry;
|
|
has(
|
|
"Disposed Old laptop on 2026-06-30 for $300.00",
|
|
disposal.map(Route::Entry),
|
|
);
|
|
let (jan, _) = b.asset_trail(f.laptop).depreciation["2026-01"];
|
|
let dep = texts
|
|
.iter()
|
|
.find(|(x, _, _)| x.starts_with("Depreciation posted: Laptop 2026-01"))
|
|
.expect("depreciation text");
|
|
assert_eq!(dep.1, Some(Route::Entry(jan)));
|
|
assert_eq!(dep.2, Some(Route::Asset(f.laptop)));
|
|
}
|
|
|
|
#[test]
|
|
fn attention_asks_for_depreciation_and_tags() {
|
|
let f = fixture("attention");
|
|
let b = &f.books;
|
|
let items = attention::find(b);
|
|
let due = b.depreciation_due(today());
|
|
let dep = items
|
|
.iter()
|
|
.find(|a| a.title == "Depreciation not posted through Sep 30, 2026")
|
|
.expect("depreciation item");
|
|
assert_eq!(dep.target, Some(Route::Assets));
|
|
assert!(dep.prompt.starts_with("In wanderbooks,"));
|
|
assert!(
|
|
dep.prompt
|
|
.contains("books.run_depreciation for 2026-08, 2026-09")
|
|
);
|
|
assert!(dep.prompt.contains(&fmt::dollars(due.amount)));
|
|
let tag = items
|
|
.iter()
|
|
.find(|a| a.title == "No tag: Monitor")
|
|
.expect("tag item");
|
|
assert_eq!(tag.target, Some(Route::Asset(f.monitor)));
|
|
assert!(tag.prompt.contains("books.label_asset"));
|
|
// Tagged, disposed, and agreeing assets ask for nothing.
|
|
assert!(
|
|
!items
|
|
.iter()
|
|
.any(|a| a.title.contains("Laptop") && a.title.starts_with("No tag"))
|
|
);
|
|
assert!(!items.iter().any(|a| a.title.contains("not in the")));
|
|
for a in &items {
|
|
assert!(a.prompt.contains("wanderbooks"), "{:?}", a.prompt);
|
|
}
|
|
|
|
// Caught up and labeled: nothing about assets.
|
|
let data = f._dir.0.join("books-data");
|
|
let mut s = Store::open(&data).unwrap();
|
|
s.run_depreciation(f.laptop, "2026-08").unwrap();
|
|
s.run_depreciation(f.laptop, "2026-09").unwrap();
|
|
s.run_depreciation(f.monitor, "2026-09").unwrap();
|
|
s.set_asset_tag(f.monitor, "WL-0002").unwrap();
|
|
drop(s);
|
|
let b = load(&f._dir.0, today());
|
|
let titles: Vec<String> = attention::find(&b).into_iter().map(|a| a.title).collect();
|
|
assert!(
|
|
!titles
|
|
.iter()
|
|
.any(|t| t.contains("Depreciation") || t.starts_with("No tag")),
|
|
"{titles:?}"
|
|
);
|
|
assert_eq!(b.depreciation_due(today()).amount, Decimal::ZERO);
|
|
}
|
|
|
|
#[test]
|
|
fn unregistered_equipment_is_flagged() {
|
|
let f = fixture("unregistered");
|
|
let data = f._dir.0.join("books-data");
|
|
let mut s = Store::open(&data).unwrap();
|
|
let equip = s.ledger().chart().find_by_code("1500").unwrap().id;
|
|
let cash = s.ledger().chart().find_by_code("1000").unwrap().id;
|
|
let e = s.create_entry(d(2026, 9, 2), "Printer").unwrap();
|
|
s.add_line(e, equip, Side::Debit, usd(45_000)).unwrap();
|
|
s.add_line(e, cash, Side::Credit, usd(45_000)).unwrap();
|
|
s.post_entry(e).unwrap();
|
|
drop(s);
|
|
let b = load(&f._dir.0, today());
|
|
let r = b.asset_register(today());
|
|
assert_eq!(r.unregistered_cost(), Decimal::new(45_000, 2));
|
|
assert!(
|
|
notices(&b, &r)
|
|
.iter()
|
|
.any(|n| n.problem && n.text.starts_with("$450.00 in the asset cost accounts"))
|
|
);
|
|
assert!(
|
|
attention::find(&b)
|
|
.iter()
|
|
.any(|a| a.title == "$450.00 of equipment not in the asset register")
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn books_show_opens_assets() {
|
|
let f = fixture("show");
|
|
let laptop = f.laptop;
|
|
let books = f.books;
|
|
let mut h = Harness::builder()
|
|
.with_size(egui::vec2(1440.0, 920.0))
|
|
.build_eframe(|cc| App::with_books(&cc.egui_ctx, books, false, Route::Overview));
|
|
h.state_mut().show(ViewerTarget::Page {
|
|
page: "assets".into(),
|
|
});
|
|
h.run_steps(2);
|
|
assert_eq!(h.state_mut().route(), &Route::Assets);
|
|
h.state_mut().show(ViewerTarget::Asset { asset_id: laptop });
|
|
h.run_steps(2);
|
|
assert_eq!(h.state_mut().route(), &Route::Asset(laptop));
|
|
h.state_mut().show(ViewerTarget::Report {
|
|
report: "fixed_asset_register".into(),
|
|
start: None,
|
|
end: Some("2026-06-30".into()),
|
|
columns: None,
|
|
compare: None,
|
|
});
|
|
h.run_steps(2);
|
|
assert_eq!(
|
|
h.state_mut().route(),
|
|
&Route::Reports(ReportKind::FixedAssetRegister)
|
|
);
|
|
assert!(matches!(
|
|
h.state_mut().state_mut().reports.range,
|
|
ledger_gui::pages::reports::Range::Custom(_, e) if e == d(2026, 6, 30)
|
|
));
|
|
// An unknown asset is ignored, not a crash.
|
|
h.state_mut().show(ViewerTarget::Asset { asset_id: 999 });
|
|
h.run_steps(1);
|
|
assert_eq!(
|
|
h.state_mut().route(),
|
|
&Route::Reports(ReportKind::FixedAssetRegister)
|
|
);
|
|
}
|
|
|
|
/// The asset pages render at every width without panicking, and with no
|
|
/// assets at all.
|
|
#[test]
|
|
fn asset_pages_render() {
|
|
let f = fixture("render");
|
|
let routes = [
|
|
Route::Assets,
|
|
Route::Asset(f.laptop),
|
|
Route::Asset(f.monitor),
|
|
Route::Asset(f.old),
|
|
Route::Asset(999),
|
|
Route::Reports(ReportKind::FixedAssetRegister),
|
|
];
|
|
for width in [420.0, 900.0, 1440.0] {
|
|
for route in &routes {
|
|
let books = load(&f._dir.0, today());
|
|
let mut h = Harness::builder()
|
|
.with_size(egui::vec2(width, 900.0))
|
|
.build_eframe(|cc| App::with_books(&cc.egui_ctx, books, true, route.clone()));
|
|
h.run_steps(3);
|
|
}
|
|
}
|
|
let empty = TempDir::new("empty");
|
|
drop(Store::create(&empty.0.join("books-data"), Currency::USD).unwrap());
|
|
for route in [
|
|
Route::Assets,
|
|
Route::Reports(ReportKind::FixedAssetRegister),
|
|
] {
|
|
let books = load(&empty.0, today());
|
|
let mut h = Harness::builder()
|
|
.with_size(egui::vec2(1280.0, 800.0))
|
|
.build_eframe(|cc| App::with_books(&cc.egui_ctx, books, false, route.clone()));
|
|
h.run_steps(3);
|
|
}
|
|
}
|
|
|
|
proptest! {
|
|
#![proptest_config(ProptestConfig::with_cases(12))]
|
|
|
|
/// On random assets with depreciation run for random months, the
|
|
/// register on any date is ledger-core's, and what's due is the
|
|
/// register through the last finished month.
|
|
#[test]
|
|
fn register_and_due_match_the_oracle(
|
|
assets in proptest::collection::vec(
|
|
(0u64..400, 1i64..2_000_000, 0i64..50, 1u32..60, 0u32..30),
|
|
1..5,
|
|
),
|
|
today_off in 0u64..900,
|
|
probe in 0u64..1200,
|
|
) {
|
|
let dir = TempDir::new("prop");
|
|
let data = dir.0.join("books-data");
|
|
let mut s = Store::create(&data, Currency::USD).unwrap();
|
|
let cash = s.add_account("1000", "Checking", AccountType::Asset, None, false).unwrap();
|
|
let equip = s.add_account("1500", "Equipment", AccountType::Asset, None, false).unwrap();
|
|
let accum = s.add_account("1510", "Accumulated", AccountType::Asset, None, false).unwrap();
|
|
let dep = s.add_account("6500", "Depreciation", AccountType::Expense, None, false).unwrap();
|
|
let base = d(2025, 1, 1);
|
|
for (i, (off, cents, salvage_pct, months, run)) in assets.iter().enumerate() {
|
|
let date = base + Days::new(*off);
|
|
let e = s.create_entry(date, &format!("Buy {i}")).unwrap();
|
|
s.add_line(e, equip, Side::Debit, usd(*cents)).unwrap();
|
|
s.add_line(e, cash, Side::Credit, usd(*cents)).unwrap();
|
|
s.post_entry(e).unwrap();
|
|
let id = s.register_asset(NewAsset {
|
|
description: format!("Asset {i}"),
|
|
purchase_date: date,
|
|
cost: usd(*cents),
|
|
salvage_value: usd(cents * salvage_pct / 100),
|
|
useful_life_months: *months,
|
|
cost_account: equip,
|
|
accum_depr_account: accum,
|
|
expense_account: dep,
|
|
}).unwrap();
|
|
// Depreciation for the first `run` months of its life.
|
|
for k in 0..*run {
|
|
let m = date.with_day0(0).unwrap() + Months::new(k);
|
|
let _ = s.run_depreciation(id, &m.format("%Y-%m").to_string());
|
|
}
|
|
}
|
|
drop(s);
|
|
let oracle = Store::open(&data).unwrap().ledger().clone();
|
|
let today = base + Days::new(today_off);
|
|
let b = load(&dir.0, today);
|
|
let at = base + Days::new(probe);
|
|
prop_assert_eq!(b.asset_register(at), fixed_asset_register(&oracle, at));
|
|
let due = b.depreciation_due(today);
|
|
prop_assert!(due.through <= today);
|
|
prop_assert_eq!(due.through.succ_opt().unwrap().day0(), 0);
|
|
prop_assert!(today - due.through < chrono::TimeDelta::days(32));
|
|
prop_assert_eq!(
|
|
due.amount,
|
|
fixed_asset_register(&oracle, due.through).unposted_depreciation()
|
|
);
|
|
// Every period listed is unposted and in some schedule.
|
|
for p in &due.periods {
|
|
let found = b.ledger.registered_assets().any(|a| {
|
|
depreciation_schedule(a, due.through).iter().any(|l| &l.period == p)
|
|
&& !b.asset_trail(a.id).depreciation.contains_key(p)
|
|
});
|
|
prop_assert!(found, "{} listed but not due", p);
|
|
}
|
|
}
|
|
}
|