datasynth-eval 2.0.0

Evaluation framework for synthetic financial data quality and coherence
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171

//! Integration tests for BalanceSheetEvaluator.
//!
//! Validates the balance sheet equation (Assets = Liabilities + Equity + Net Income)
//! across balanced snapshots, imbalanced snapshots, multi-period scenarios,
//! and tolerance edge cases.

use datasynth_eval::{AccountType, BalanceSheetEvaluator, BalanceSnapshot};
use rust_decimal_macros::dec;
use std::collections::HashMap;

/// Helper: create a balanced snapshot where
/// Assets(1000) = Liabilities(600) + Equity(400) + NetIncome(0).
fn make_balanced_snapshot(company: &str, year: u16, period: u8) -> BalanceSnapshot {
    let mut balances = HashMap::new();
    balances.insert(AccountType::Asset, dec!(1000));
    balances.insert(AccountType::Liability, dec!(600));
    balances.insert(AccountType::Equity, dec!(400));
    // Revenue = Expense => NetIncome = 0, so equation holds
    balances.insert(AccountType::Revenue, dec!(200));
    balances.insert(AccountType::Expense, dec!(200));

    BalanceSnapshot {
        company_code: company.to_string(),
        fiscal_year: year,
        fiscal_period: period,
        balances,
    }
}

#[test]
fn test_balanced_snapshot() {
    let evaluator = BalanceSheetEvaluator::default();
    let snapshot = make_balanced_snapshot("C001", 2024, 1);
    let result = evaluator
        .evaluate(&[snapshot])
        .expect("evaluation should succeed");

    assert!(
        result.equation_balanced,
        "Snapshot with Assets=L+E+NI should be balanced"
    );
    assert_eq!(result.periods_evaluated, 1);
    assert_eq!(result.periods_imbalanced, 0);
    assert_eq!(result.companies_evaluated, 1);
    assert_eq!(result.max_imbalance, dec!(0));

    let period = &result.period_results[0];
    assert!(period.is_balanced);
    assert_eq!(period.imbalance, dec!(0));
    assert_eq!(period.total_assets, dec!(1000));
    assert_eq!(period.total_liabilities, dec!(600));
    assert_eq!(period.total_equity, dec!(400));
    assert_eq!(period.net_income, dec!(0));
}

#[test]
fn test_imbalanced_snapshot() {
    let evaluator = BalanceSheetEvaluator::default(); // tolerance = 0.01
    let mut balances = HashMap::new();
    balances.insert(AccountType::Asset, dec!(1000));
    balances.insert(AccountType::Liability, dec!(600));
    balances.insert(AccountType::Equity, dec!(300)); // Missing 100 to balance

    let snapshot = BalanceSnapshot {
        company_code: "C001".to_string(),
        fiscal_year: 2024,
        fiscal_period: 1,
        balances,
    };

    let result = evaluator
        .evaluate(&[snapshot])
        .expect("evaluation should succeed");

    assert!(
        !result.equation_balanced,
        "Snapshot with Assets != L+E should be imbalanced"
    );
    assert_eq!(result.periods_imbalanced, 1);
    assert_eq!(result.max_imbalance, dec!(100));

    let period = &result.period_results[0];
    assert!(!period.is_balanced);
    assert_eq!(period.imbalance, dec!(100));
}

#[test]
fn test_multiple_periods() {
    let evaluator = BalanceSheetEvaluator::default();
    let snapshots = vec![
        make_balanced_snapshot("C001", 2024, 1),
        make_balanced_snapshot("C001", 2024, 2),
        make_balanced_snapshot("C001", 2024, 3),
    ];

    let result = evaluator
        .evaluate(&snapshots)
        .expect("evaluation should succeed");

    assert!(result.equation_balanced);
    assert_eq!(result.periods_evaluated, 3);
    assert_eq!(result.periods_imbalanced, 0);
    assert_eq!(result.companies_evaluated, 1);

    for (i, period) in result.period_results.iter().enumerate() {
        assert!(period.is_balanced, "Period {} should be balanced", i + 1);
    }
}

#[test]
fn test_tolerance_within_threshold() {
    // Default tolerance is 0.01. An imbalance of 0.005 should pass.
    let evaluator = BalanceSheetEvaluator::default();
    let mut balances = HashMap::new();
    balances.insert(AccountType::Asset, dec!(1000.005));
    balances.insert(AccountType::Liability, dec!(600));
    balances.insert(AccountType::Equity, dec!(400));
    // Net income = 0, so imbalance = 1000.005 - (600 + 400 + 0) = 0.005

    let snapshot = BalanceSnapshot {
        company_code: "C001".to_string(),
        fiscal_year: 2024,
        fiscal_period: 1,
        balances,
    };

    let result = evaluator
        .evaluate(&[snapshot])
        .expect("evaluation should succeed");

    assert!(
        result.equation_balanced,
        "Imbalance of 0.005 should be within default tolerance of 0.01"
    );
    assert_eq!(result.periods_imbalanced, 0);
    // max_imbalance should be 0.005
    assert_eq!(result.max_imbalance, dec!(0.005));
}

#[test]
fn test_tolerance_exceeded() {
    // Default tolerance is 0.01. An imbalance of 0.05 should fail.
    let evaluator = BalanceSheetEvaluator::default();
    let mut balances = HashMap::new();
    balances.insert(AccountType::Asset, dec!(1000.05));
    balances.insert(AccountType::Liability, dec!(600));
    balances.insert(AccountType::Equity, dec!(400));
    // Net income = 0, so imbalance = 1000.05 - (600 + 400 + 0) = 0.05

    let snapshot = BalanceSnapshot {
        company_code: "C001".to_string(),
        fiscal_year: 2024,
        fiscal_period: 1,
        balances,
    };

    let result = evaluator
        .evaluate(&[snapshot])
        .expect("evaluation should succeed");

    assert!(
        !result.equation_balanced,
        "Imbalance of 0.05 should exceed default tolerance of 0.01"
    );
    assert_eq!(result.periods_imbalanced, 1);
    assert_eq!(result.max_imbalance, dec!(0.05));

    let period = &result.period_results[0];
    assert!(!period.is_balanced);
    assert_eq!(period.imbalance, dec!(0.05));
}