tktax_burst/

lib.rs

// ---------------- [ File: tktax-burst/src/lib.rs ]
#[macro_use] mod imports; use imports::*;

x!{build_date_windows}
x!{bursts}
x!{collect_daily_totals}
x!{merge_overlapping_burst_windows}
x!{print_merged_bursts}
x!{print_transaction_lines}

#[cfg(test)]
#[disable]
mod test_heavy_bursts {
    use super::*;
    use chrono::NaiveDate;

    fn ma(amount: f64) -> MonetaryAmount {
        MonetaryAmount::from(amount)
    }

    #[test]
    fn test_collect_daily_totals() {
        // Build some mock transactions
        let txns = vec![
            mock_transaction("2025-01-01", 10.0),
            mock_transaction("2025-01-01", 5.0),
            mock_transaction("2025-01-02", 20.0),
            mock_transaction("2025-01-03", -5.0),
        ];
        let daily = collect_daily_totals(&txns);
        assert_eq!(daily[&nd("2025-01-01")], ma(15.0));
        assert_eq!(daily[&nd("2025-01-02")], ma(20.0));
        assert_eq!(daily[&nd("2025-01-03")], ma(-5.0));
    }

    // -------------- Mock Helpers -----------------

    fn nd(s: &str) -> NaiveDate {
        NaiveDate::parse_from_str(s, "%Y-%m-%d").unwrap()
    }

    fn mock_transaction(date_str: &str, amt: f64) -> Transaction {
        // Here you might build a minimal Transaction with the provided date and amount
        Transaction::new(nd(date_str), ma(amt), "mock desc")
    }

    //-------------------------------------------------------------------------
    // 2) Fake or Mock Transaction + Account for Testing
    //
    //    In a real codebase, you'd use your actual Transaction/Account
    //    structs. The only requirement here is that we can produce a slice
    //    of Transaction objects, each with a transaction_date() and amount().
    //-------------------------------------------------------------------------

    #[derive(Clone)]
    struct MockTransaction {
        date: NaiveDate,
        amt:  MonetaryAmount,
    }

    impl MockTransaction {
        pub fn new(date: NaiveDate, amt: MonetaryAmount) -> Self {
            Self { date, amt }
        }
    }

    // Minimal trait or direct methods to satisfy what's needed by collect_daily_totals:
    impl MockTransaction {
        pub fn transaction_date(&self) -> &NaiveDate {
            &self.date
        }
        pub fn amount(&self) -> MonetaryAmount {
            self.amt
        }
    }

    // Minimal "Account" that implements `txns() -> &[Transaction]` for testing
    struct MockAccount {
        txns: Vec<MockTransaction>,
    }

    impl MockAccount {
        pub fn new(txns: Vec<MockTransaction>) -> Self {
            Self { txns }
        }
        pub fn txns(&self) -> &[MockTransaction] {
            &self.txns
        }

        // Let’s mock total_transaction_amount_within_dates
        // by just summing any transaction in [start_date, end_date].
        pub fn total_transaction_amount_within_dates(
            &self, 
            start_date: NaiveDate, 
            end_date: NaiveDate
        ) -> MonetaryAmount 
        {
            let mut total = MonetaryAmount::zero();
            for tx in &self.txns {
                let d = tx.transaction_date();
                if *d >= start_date && *d <= end_date {
                    total += tx.amount();
                }
            }
            total
        }

        // Similarly for transactions_within_dates
        pub fn transactions_within_dates(
            &self, 
            start_date: NaiveDate, 
            end_date: NaiveDate
        ) -> Vec<MockTransaction> 
        {
            self.txns
                .iter()
                .filter(|tx| {
                    let d = tx.transaction_date();
                    *d >= start_date && *d <= end_date
                })
                .cloned()
                .collect()
        }
    }

    // Implement the same trait we used for an actual Account,
    // by hooking to the logic for "fake" transactions.
    impl FindHeavyTransactionBursts for MockAccount {
        fn print_heavy_bursts(&self, top_n: usize, window_size: usize) {
            // we can just copy in or call the same method from the real code 
            let heaviest_bursts = self.find_heaviest_bursts(window_size);
            let top_n_bursts = heaviest_bursts.into_iter().take(top_n).collect::<Vec<_>>();
            let merged_bursts = merge_overlapping_burst_windows(top_n_bursts);

            println!(
                "Top {} heaviest bursts of activity (calculated with possible overlap using a {}-day window):", 
                merged_bursts.len(), 
                window_size
            );

            for (i, &(start_date, end_date)) in merged_bursts.iter().enumerate() {
                let total = self.total_transaction_amount_within_dates(start_date, end_date);
                println!();
                println!("Burst {}) {} to {}: {}", i + 1, start_date, end_date, total);

                let relevant = self.transactions_within_dates(start_date, end_date);
                for tx in relevant {
                    println!("  {}  {}", tx.transaction_date(), tx.amount());
                }
            }
            println!();
        }

        fn find_heaviest_bursts(&self, window_size: usize) 
            -> Vec<(NaiveDate, NaiveDate, MonetaryAmount)>
        {
            // identical logic as in your main code, but referencing our mock:
            let daily_totals = collect_daily_totals(self.txns());
            let mut windows = build_date_windows(&daily_totals, window_size);
            sort_windows_desc(&mut windows);
            windows
        }
    }

    //-------------------------------------------------------------------------
    // 3) Test Each Subroutine
    //-------------------------------------------------------------------------
    #[test]
    fn test_collect_daily_totals_basic() {
        let txns = vec![
            MockTransaction::new(nd("2025-01-01"), ma(10.0)),
            MockTransaction::new(nd("2025-01-01"), ma(5.0)),
            MockTransaction::new(nd("2025-01-02"), ma(20.0)),
            MockTransaction::new(nd("2025-01-03"), ma(-5.0)),
        ];
        let daily = collect_daily_totals(&txns);
        assert_eq!(daily[&nd("2025-01-01")], ma(15.0));
        assert_eq!(daily[&nd("2025-01-02")], ma(20.0));
        assert_eq!(daily[&nd("2025-01-03")], ma(-5.0));
    }

    #[test]
    fn test_collect_daily_totals_empty() {
        let txns: Vec<MockTransaction> = vec![];
        let daily = collect_daily_totals(&txns);
        assert!(daily.is_empty());
    }

    #[test]
    fn test_build_date_windows() {
        // day1=10, day2=20 => window_size=2 => 
        // for day1 => total = day1+day2=30
        // for day2 => total = day2=20 (no day3 entry)
        let mut daily = HashMap::new();
        daily.insert(nd("2025-01-01"), ma(10.0));
        daily.insert(nd("2025-01-02"), ma(20.0));
        let windows = build_date_windows(&daily, 2);

        assert_eq!(windows.len(), 2);
        // We can check explicitly:
        assert!(windows.contains(&(nd("2025-01-01"), nd("2025-01-02"), ma(30.0))));
        assert!(windows.contains(&(nd("2025-01-02"), nd("2025-01-03"), ma(20.0))));
    }

    #[test]
    fn test_build_date_windows_single_day_window() {
        // If window_size=1, each “window” is just that day’s total.
        let mut daily = HashMap::new();
        daily.insert(nd("2025-01-01"), ma(10.0));
        daily.insert(nd("2025-01-02"), ma(20.0));
        let windows = build_date_windows(&daily, 1);
        assert_eq!(windows.len(), 2);

        // day1 => start=1/1, end=1/1 => total=10
        // day2 => start=1/2, end=1/2 => total=20
        assert!(windows.contains(&(nd("2025-01-01"), nd("2025-01-01"), ma(10.0))));
        assert!(windows.contains(&(nd("2025-01-02"), nd("2025-01-02"), ma(20.0))));
    }

    #[test]
    fn test_sort_windows_desc() {
        let mut windows = vec![
            (nd("2025-01-01"), nd("2025-01-01"), ma(10.0)),
            (nd("2025-01-02"), nd("2025-01-02"), ma(50.0)),
            (nd("2025-01-03"), nd("2025-01-03"), ma(20.0)),
        ];
        sort_windows_desc(&mut windows);
        // Should become [ (1/2 => 50.0), (1/3 => 20.0), (1/1 => 10.0) ]
        assert_eq!(windows[0].2, ma(50.0));
        assert_eq!(windows[1].2, ma(20.0));
        assert_eq!(windows[2].2, ma(10.0));
    }

    #[test]
    fn test_merge_overlapping_burst_windows() {
        let input = vec![
            (nd("2025-01-01"), nd("2025-01-03"), ma(30.0)),
            (nd("2025-01-02"), nd("2025-01-05"), ma(40.0)),
            (nd("2025-02-01"), nd("2025-02-01"), ma(10.0)),
        ];
        let merged = merge_overlapping_burst_windows(input);
        // The first two overlap => merged => [1/1..1/5], third is separate
        assert_eq!(merged.len(), 2);
        assert_eq!(merged[0], (nd("2025-01-01"), nd("2025-01-05")));
        assert_eq!(merged[1], (nd("2025-02-01"), nd("2025-02-01")));
    }

    //-------------------------------------------------------------------------
    // 4) Test the Trait Methods on a Realistic “Account”-like structure
    //-------------------------------------------------------------------------

    #[test]
    fn test_find_heaviest_bursts_empty_account() {
        let acc = MockAccount::new(vec![]);
        // Should produce no windows
        let windows = acc.find_heaviest_bursts(7);
        assert!(windows.is_empty());
    }

    #[test]
    fn test_find_heaviest_bursts_basic() {
        // Day1=10, Day2=20, Day3=30 => with 2-day windows:
        // day1 => [d1..d2]=30, day2=> [d2..d3]=50, day3=> [d3..d4]=30
        let txns = vec![
            MockTransaction::new(nd("2025-01-01"), ma(10.0)),
            MockTransaction::new(nd("2025-01-02"), ma(20.0)),
            MockTransaction::new(nd("2025-01-03"), ma(30.0)),
        ];
        let acc = MockAccount::new(txns);
        let windows = acc.find_heaviest_bursts(2);
        // Should be sorted desc => top window = day2..day3 => 50
        assert_eq!(windows[0], (nd("2025-01-02"), nd("2025-01-03"), ma(50.0)));
    }

    #[test]
    fn test_print_heavy_bursts_basic() {
        // We'll capture stdout to test what gets printed
        // This approach uses "cargo test -- --nocapture" to see the actual output
        // or we can parse the captured string for specific lines.
        let txns = vec![
            MockTransaction::new(nd("2025-01-01"), ma(100.0)),
            MockTransaction::new(nd("2025-01-02"), ma(50.0)),
            MockTransaction::new(nd("2025-01-10"), ma(200.0)),
        ];
        let acc = MockAccount::new(txns);

        // We'll do a 3-day window, top 2 bursts
        let output = capture_stdout(|| {
            acc.print_heavy_bursts(2, 3);
        });

        // In that 3-day window, "2025-01-10..2025-01-12" => 200.0
        // "2025-01-01..2025-01-03" => 150.0
        // So these should appear in the printed text.
        assert!(output.contains("Top 2 heaviest bursts of activity"));
        assert!(output.contains("Burst 1) 2025-01-10 to 2025-01-12:  $200.00"));
        assert!(output.contains("Burst 2) 2025-01-01 to 2025-01-03:  $150.00"));
    }

    //-------------------------------------------------------------------------
    // 6) Optional: Utility for capturing stdout in tests
    //    Adapted from common patterns or from "assert_cmd" crate usage
    //-------------------------------------------------------------------------
    fn capture_stdout<F: FnOnce()>(f: F) -> String {
        use std::io::{self, Read, Write};
        let backup = io::stdout();
        let mut writer = io::Cursor::new(Vec::new());
        io::set_print(Some(Box::new(&mut writer)));
        f();
        io::set_print(None);

        let bytes = writer.into_inner();
        String::from_utf8(bytes).unwrap_or_default()
    }
}