findates 0.1.4

Financial date arithmetic: business day calendars, day count conventions, and schedule generation.
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

// Integration tests for calendar-related functionality.
// These tests validate business day determination, schedule generation, and business day counting
// based on calendar rules (weekends, holidays) and adjustment conventions.

use chrono::{Datelike, NaiveDate, Weekday};
use findates::algebra;
use findates::calendar;
use findates::calendar::Calendar;
use findates::conventions::AdjustRule;

// ============================================================================
// Business Day Tests
// ============================================================================

#[test]
fn is_business_day_test() {
    let mut basic_cal = calendar::basic_calendar();

    // Sunday should not be a business day
    let sunday = NaiveDate::from_isoywd_opt(2015, 10, Weekday::Sun);
    assert!(!algebra::is_business_day(&sunday.unwrap(), &basic_cal));

    // Monday should be a business day
    let monday = NaiveDate::from_isoywd_opt(2015, 10, Weekday::Mon);
    assert!(algebra::is_business_day(&monday.unwrap(), &basic_cal));

    // Christmas should be a business day before being added to holidays
    let christmas_day = NaiveDate::from_ymd_opt(2023, 12, 25).unwrap();
    assert!(algebra::is_business_day(&christmas_day, &basic_cal));

    // After adding to calendar, Christmas should not be a business day
    basic_cal.add_holidays([christmas_day]);
    assert!(!algebra::is_business_day(&christmas_day, &basic_cal));
}

#[test]
fn convenience_constructors_work_in_business_day_logic() {
    let xmas = NaiveDate::from_ymd_opt(2024, 12, 25).unwrap();
    let boxing_day = NaiveDate::from_ymd_opt(2024, 12, 26).unwrap();
    let saturday = NaiveDate::from_ymd_opt(2024, 12, 28).unwrap();

    let mut cal = Calendar::with_weekends([Weekday::Sat, Weekday::Sun]);
    cal.add_holidays(vec![xmas, xmas, boxing_day]);

    let holiday_only = Calendar::with_holidays([xmas, boxing_day].into_iter().take(1));

    assert!(!algebra::is_business_day(&xmas, &cal));
    assert!(!algebra::is_business_day(&saturday, &cal));
    assert!(holiday_only.get_holidays().contains(&xmas));
    assert_eq!(holiday_only.get_holidays().len(), 1);
    assert_eq!(
        algebra::adjust(&xmas, Some(&cal), Some(AdjustRule::Following)),
        NaiveDate::from_ymd_opt(2024, 12, 27).unwrap()
    );
}

// ============================================================================
// Business Day Schedule Tests
// ============================================================================

#[test]
fn schedule_test() {
    let mut test_schedule: Vec<NaiveDate> = [].to_vec();
    let hol = NaiveDate::from_ymd_opt(2023, 9, 22).unwrap();

    // Create test vector with all the dates
    for i in 2..31 {
        let dt = NaiveDate::from_ymd_opt(2023, 9, i).unwrap();
        // Exclude weekends
        if dt.weekday() != Weekday::Sat && dt.weekday() != Weekday::Sun && dt != hol {
            test_schedule.push(dt);
        }
    }

    let mut cal = calendar::basic_calendar();
    cal.add_holidays([hol]);

    let start_date: NaiveDate = NaiveDate::from_ymd_opt(2023, 9, 2).unwrap();
    let end_date: NaiveDate = NaiveDate::from_ymd_opt(2023, 9, 30).unwrap();
    let res: Vec<NaiveDate> =
        algebra::bus_day_schedule(&start_date, &end_date, &cal, Some(AdjustRule::ModFollowing));

    assert_eq!(test_schedule, res);
}

#[test]
fn bus_days_between_test() {
    let mut test_schedule: Vec<NaiveDate> = [].to_vec();
    let hol: NaiveDate = NaiveDate::from_ymd_opt(2023, 9, 22).unwrap();

    // Create test vector with all the dates
    for i in 1..29 {
        let dt = NaiveDate::from_ymd_opt(2023, 9, i).unwrap();
        // Exclude weekends
        if dt.weekday() != Weekday::Sat && dt.weekday() != Weekday::Sun && dt != hol {
            test_schedule.push(dt);
        }
    }

    let mut cal = calendar::basic_calendar();
    cal.add_holidays([hol]);

    let start_date: NaiveDate = NaiveDate::from_ymd_opt(2023, 9, 1).unwrap();
    let end_date: NaiveDate = NaiveDate::from_ymd_opt(2023, 9, 29).unwrap();
    let res: u64 =
        algebra::business_days_between(&start_date, &end_date, &cal, Some(AdjustRule::Preceding));

    assert_eq!(test_schedule.len() as u64, res);
}

// ============================================================================
// Edge Case Tests
// ============================================================================

#[test]
fn bus_day_schedule_single_day_test() {
    // start == end: the schedule should contain exactly that one business day.
    let cal = calendar::basic_calendar();
    let monday = NaiveDate::from_ymd_opt(2024, 3, 18).unwrap();
    let result = algebra::bus_day_schedule(&monday, &monday, &cal, None);
    assert_eq!(result, vec![monday]);
}

#[test]
fn business_days_between_same_day_test() {
    let cal = calendar::basic_calendar();
    let monday = NaiveDate::from_ymd_opt(2024, 3, 18).unwrap();
    // Same day: zero business days between (end excluded).
    assert_eq!(
        algebra::business_days_between(&monday, &monday, &cal, None),
        0
    );
}

#[test]
fn bus_day_schedule_holiday_gap_test() {
    // A week with Christmas (Wednesday) and Boxing Day (Thursday) as holidays.
    let mut cal = calendar::basic_calendar();
    let xmas = NaiveDate::from_ymd_opt(2024, 12, 25).unwrap();
    let boxing_day = NaiveDate::from_ymd_opt(2024, 12, 26).unwrap();
    cal.add_holidays([xmas, boxing_day]);

    let start = NaiveDate::from_ymd_opt(2024, 12, 23).unwrap(); // Monday
    let end = NaiveDate::from_ymd_opt(2024, 12, 27).unwrap(); // Friday
    let days = algebra::bus_day_schedule(&start, &end, &cal, None);
    // Mon 23, Tue 24, Fri 27 — Wed/Thu are holidays
    assert_eq!(
        days,
        vec![
            NaiveDate::from_ymd_opt(2024, 12, 23).unwrap(),
            NaiveDate::from_ymd_opt(2024, 12, 24).unwrap(),
            NaiveDate::from_ymd_opt(2024, 12, 27).unwrap(),
        ]
    );
}

#[test]
fn calendar_default_is_empty_test() {
    let cal = calendar::Calendar::default();
    assert!(cal.get_holidays().is_empty());
    assert!(cal.get_weekend().is_empty());
}