date_component 0.4.8

the missed date_component with chrono. calculate date interval with chrono.
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

use chrono::prelude::*;
use date_component::date_component::*;

#[test]
fn test_month_length_edge_cases() {
    // Test from January 31 to February 28 (non-leap year)
    let from = Utc.with_ymd_and_hms(2023, 1, 31, 0, 0, 0).unwrap();
    let to = Utc.with_ymd_and_hms(2023, 2, 28, 0, 0, 0).unwrap();
    let diff = calculate(&from, &to);

    // This should not crash and should give reasonable results
    println!("Jan 31 to Feb 28, 2023: {:?}", diff);
    assert!(diff.month >= 0);
    assert!(diff.day >= 0);
    assert!(!diff.invert);
}

#[test]
fn test_month_length_edge_cases_leap_year() {
    // Test from January 31 to February 29 (leap year)
    let from = Utc.with_ymd_and_hms(2024, 1, 31, 0, 0, 0).unwrap();
    let to = Utc.with_ymd_and_hms(2024, 2, 29, 0, 0, 0).unwrap();
    let diff = calculate(&from, &to);

    println!("Jan 31 to Feb 29, 2024: {:?}", diff);
    assert!(diff.month >= 0);
    assert!(diff.day >= 0);
    assert!(!diff.invert);
}

#[test]
fn test_negative_duration_edge_case() {
    // Test a case that might cause issues with negative duration
    let from = Utc.with_ymd_and_hms(2023, 12, 31, 23, 59, 59).unwrap();
    let to = Utc.with_ymd_and_hms(2023, 1, 1, 0, 0, 0).unwrap();
    let diff = calculate(&from, &to);

    println!("Dec 31 23:59:59 to Jan 1 00:00:00: {:?}", diff);
    assert!(diff.invert); // Should be inverted since going backwards
    assert!(diff.year >= 0 || diff.month >= 0 || diff.day >= 0); // Should have some positive time difference
}

#[test]
fn test_complex_date_arithmetic() {
    // Test a complex case that might reveal arithmetic bugs
    let from = Utc.with_ymd_and_hms(2020, 2, 29, 12, 30, 45).unwrap(); // Leap day
    let to = Utc.with_ymd_and_hms(2021, 3, 31, 14, 45, 30).unwrap();
    let diff = calculate(&from, &to);

    println!("Complex leap year calculation: {:?}", diff);

    // Basic sanity checks
    assert!(diff.year >= 0);
    assert!(diff.month >= 0);
    assert!(diff.day >= 0);
    assert!(diff.hour >= 0);
    assert!(diff.minute >= 0);
    assert!(diff.second >= 0);
    assert!(!diff.invert);

    // The total should be consistent with the components
    let total_seconds = diff.interval_seconds;
    assert!(total_seconds > 0);
}

#[test]
fn test_dst_boundary_arithmetic() {
    // Test around DST boundaries to check for arithmetic consistency
    use chrono_tz::America::Los_Angeles;

    // Spring forward: 2023-03-12 02:00 becomes 03:00
    let before_spring = Los_Angeles.with_ymd_and_hms(2023, 3, 12, 1, 30, 0).unwrap();
    let after_spring = Los_Angeles.with_ymd_and_hms(2023, 3, 12, 3, 30, 0).unwrap();
    let diff = calculate(&before_spring, &after_spring);

    println!("DST spring forward: {:?}", diff);

    // Should handle DST transition gracefully
    assert!(diff.interval_hours > 0);
    assert!(!diff.invert);
}

#[test]
fn test_zero_difference() {
    // Test when from and to are exactly the same
    let dt = Utc.with_ymd_and_hms(2023, 6, 15, 12, 30, 45).unwrap();
    let diff = calculate(&dt, &dt);

    assert_eq!(diff.year, 0);
    assert_eq!(diff.month, 0);
    assert_eq!(diff.day, 0);
    assert_eq!(diff.hour, 0);
    assert_eq!(diff.minute, 0);
    assert_eq!(diff.second, 0);
    assert_eq!(diff.interval_seconds, 0);
    assert!(!diff.invert);
}

#[test]
fn test_very_small_differences() {
    // Test with very small time differences
    let from = Utc.with_ymd_and_hms(2023, 6, 15, 12, 30, 45).unwrap();
    let to = Utc.with_ymd_and_hms(2023, 6, 15, 12, 30, 46).unwrap(); // 1 second difference
    let diff = calculate(&from, &to);

    assert_eq!(diff.year, 0);
    assert_eq!(diff.month, 0);
    assert_eq!(diff.day, 0);
    assert_eq!(diff.hour, 0);
    assert_eq!(diff.minute, 0);
    assert_eq!(diff.second, 1);
    assert_eq!(diff.interval_seconds, 1);
    assert!(!diff.invert);
}

#[test]
fn test_year_boundary_consistency() {
    // Test consistency across year boundaries
    let from = Utc.with_ymd_and_hms(2022, 12, 31, 23, 59, 59).unwrap();
    let to = Utc.with_ymd_and_hms(2023, 1, 1, 0, 0, 1).unwrap();
    let diff = calculate(&from, &to);

    println!("Year boundary: {:?}", diff);

    // Should be 2 seconds total
    assert_eq!(diff.interval_seconds, 2);
    assert_eq!(diff.second, 2);

    // FIXED: These should now be correct after the consistency check fix
    assert_eq!(diff.day, 0);
    assert_eq!(diff.modulo_days, 0);

    assert!(!diff.invert);
}

#[test]
fn test_bug_small_time_differences() {
    // Test that small time differences don't incorrectly calculate days
    let from = Utc.with_ymd_and_hms(2023, 1, 1, 23, 59, 59).unwrap();
    let to = Utc.with_ymd_and_hms(2023, 1, 2, 0, 0, 1).unwrap();
    let diff = calculate(&from, &to);

    println!("Small time diff across day boundary: {:?}", diff);

    // This is a 2 second difference, but crosses midnight
    assert_eq!(diff.interval_seconds, 2);

    // FIXED: Should now correctly calculate 0 days for small time differences
    assert_eq!(diff.day, 0);
}