Add and update tests

Author: hiqua

src/merge.rs

@@ -5,10 +5,55 @@ use chrono::{DateTime, Local};
 mod tests {
     use crate::merge::{are_compatible, Interval};
 
+    use crate::merge::merge_strictly_compatible_lifelapses;
+    use crate::parse::{get_life_chunk, LifeChunk, LifeLapse, TimedLifeChunk};
     use chrono::{Date, Local, TimeZone};
+    use time::Duration;
+
+    fn create_lifelapse(start_h: u32, duration_h: i64) -> LifeLapse {
+        let start = Local.ymd(2020, 12, 1).and_hms(start_h, 0, 0);
+        let mut ll = LifeLapse::new(start);
+        let lc = get_life_chunk(&format!("{} 0 test", duration_h));
+        let tlc = TimedLifeChunk {
+            start,
+            life_chunk: lc,
+        };
+        ll.extend(vec![tlc]);
+        ll
+    }
+
+    #[test]
+    fn merge_strictly_compatible_lifelapses_contiguous_inputs_returns_single_merged_lapse() {
+        let ll1 = create_lifelapse(10, 1); // 10-11
+        let ll2 = create_lifelapse(11, 1); // 11-12
+
+        let merged = merge_strictly_compatible_lifelapses(vec![ll1, ll2]);
+        assert_eq!(merged.len(), 1);
+        assert_eq!(merged[0].tokens_as_ref().len(), 2);
+    }
+
+    #[test]
+    fn merge_strictly_compatible_lifelapses_inputs_with_gap_returns_separate_lapses() {
+        let ll1 = create_lifelapse(10, 1); // 10-11
+        let ll2 = create_lifelapse(12, 1); // 12-13
+
+        let merged = merge_strictly_compatible_lifelapses(vec![ll1, ll2]);
+        assert_eq!(merged.len(), 2);
+    }
 
     #[test]
-    fn are_compatible_1() {
+    fn merge_strictly_compatible_lifelapses_overlapping_inputs_returns_separate_lapses() {
+        // This function assumes input is sorted and strictly compatible means end == start
+        // If they overlap, is_right_before will be false
+        let ll1 = create_lifelapse(10, 2); // 10-12
+        let ll2 = create_lifelapse(11, 1); // 11-12
+
+        let merged = merge_strictly_compatible_lifelapses(vec![ll1, ll2]);
+        assert_eq!(merged.len(), 2);
+    }
+
+    #[test]
+    fn are_compatible_disjoint_intervals_returns_true() {
         let i1 = Interval {
             start: Local.ymd(2020, 12, 1).and_hms(14, 0, 0),
             end: Local.ymd(2020, 12, 1).and_hms(16, 0, 0),
@@ -20,7 +65,7 @@ mod tests {
         assert!(are_compatible(vec![&i1, &i2]));
     }
     #[test]
-    fn are_compatible_2() {
+    fn are_compatible_three_intervals_with_overlap_returns_false() {
         let i1 = Interval {
             start: Local.ymd(2020, 12, 1).and_hms(14, 0, 0),
             end: Local.ymd(2020, 12, 1).and_hms(20, 0, 0),
@@ -35,6 +80,47 @@ mod tests {
         };
         assert!(!are_compatible(vec![&i3, &i1, &i2]));
     }
+    #[test]
+    fn are_compatible_two_overlapping_intervals_returns_false() {
+        let i1 = Interval {
+            start: Local.ymd(2020, 12, 1).and_hms(14, 0, 0),
+            end: Local.ymd(2020, 12, 1).and_hms(16, 0, 0),
+        };
+        let i2 = Interval {
+            start: Local.ymd(2020, 12, 1).and_hms(15, 0, 0),
+            end: Local.ymd(2020, 12, 1).and_hms(17, 0, 0),
+        };
+        assert!(!are_compatible(vec![&i1, &i2]));
+    }
+
+    #[test]
+    fn are_compatible_touching_intervals_returns_true() {
+        let i1 = Interval {
+            start: Local.ymd(2020, 12, 1).and_hms(14, 0, 0),
+            end: Local.ymd(2020, 12, 1).and_hms(16, 0, 0),
+        };
+        let i2 = Interval {
+            start: Local.ymd(2020, 12, 1).and_hms(16, 0, 0),
+            end: Local.ymd(2020, 12, 1).and_hms(18, 0, 0),
+        };
+        // Touching intervals are compatible in this logic (end == start is allowed)
+        // The check is `if i1.end > i2.start { return false; }`
+        assert!(are_compatible(vec![&i1, &i2]));
+    }
+
+    #[test]
+    fn are_compatible_empty_input_returns_true() {
+        assert!(are_compatible(vec![]));
+    }
+
+    #[test]
+    fn are_compatible_single_interval_returns_true() {
+        let i1 = Interval {
+            start: Local.ymd(2020, 12, 1).and_hms(14, 0, 0),
+            end: Local.ymd(2020, 12, 1).and_hms(16, 0, 0),
+        };
+        assert!(are_compatible(vec![&i1]));
+    }
 }
 
 struct Interval {

src/parse.rs

@@ -31,7 +31,7 @@ mod tests {
     use crate::parse::{get_life_chunk, parse_date, process_line, LifeChunk, LineParseResult};
 
     #[test]
-    fn parsing_1() {
+    fn parsing_1_valid_datetime_string_returns_datetime() {
         let dt = Local.ymd(2014, 11, 28).and_hms(12, 0, 0);
         assert_eq!(
             Local
@@ -42,24 +42,24 @@ mod tests {
     }
 
     #[test]
-    fn test_parse_date_custom_format() {
+    fn parse_date_custom_format_returns_datetime() {
         let dt = Local.ymd(2023, 10, 26).and_hms(14, 30, 0);
         assert_eq!(parse_date("2023-10-26 14h30"), Some(dt));
     }
 
     #[test]
-    fn test_parse_date_invalid_string() {
+    fn parse_date_invalid_string_returns_none() {
         assert_eq!(parse_date("invalid-date-string"), None);
     }
 
     #[test]
-    fn test_parse_date_empty_string() {
+    fn parse_date_empty_string_returns_none() {
         assert_eq!(parse_date(""), None);
     }
 
     // Tests for get_life_chunk
     #[test]
-    fn test_get_life_chunk_full_input() {
+    fn get_life_chunk_full_input_returns_populated_lifechunk() {
         let line = "1 30 Meeting with team @Work @Q2";
         let lc = get_life_chunk(line);
         assert_eq!(lc.description, "Meeting with team");
@@ -71,7 +71,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_life_chunk_missing_duration() {
+    fn get_life_chunk_missing_duration_returns_zero_duration() {
         let line = "그냥 프로젝트 작업 @Dev"; // "Just working on a project @Dev"
         let lc = get_life_chunk(line);
         assert_eq!(lc.description, "작업"); // Adjusted for current behavior
@@ -83,7 +83,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_life_chunk_missing_categories() {
+    fn get_life_chunk_missing_categories_returns_empty_categories() {
         let line = "2 0 Quick break";
         let lc = get_life_chunk(line);
         assert_eq!(lc.description, "Quick break");
@@ -95,7 +95,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_life_chunk_user_quadrant() {
+    fn get_life_chunk_user_quadrant_returns_parsed_quadrant() {
         let line = "0 45 Planning session @Q1";
         let lc = get_life_chunk(line);
         assert_eq!(lc.description, "Planning session");
@@ -107,7 +107,7 @@ mod tests {
     }
 
     #[test]
-    fn test_get_life_chunk_default_quadrant() {
+    fn get_life_chunk_no_quadrant_returns_default_quadrant() {
         let line = "3 0 Reading a book @Leisure";
         let lc = get_life_chunk(line);
         assert_eq!(lc.description, "Reading a book");
@@ -120,7 +120,7 @@ mod tests {
 
     // Tests for process_line
     #[test]
-    fn test_process_line_date() {
+    fn process_line_date_string_returns_date_result() {
         let line = "2024-03-10 10:00";
         let expected_date = Local.ymd(2024, 3, 10).and_hms(10, 0, 0);
         match process_line(line) {
@@ -130,7 +130,7 @@ mod tests {
     }
 
     #[test]
-    fn test_process_line_life_chunk() {
+    fn process_line_life_chunk_string_returns_lc_result() {
         let line = "1 0 Coding @Dev";
         match process_line(line) {
             LineParseResult::Lc { life_chunk: lc } => {
@@ -146,7 +146,7 @@ mod tests {
     }
 
     #[test]
-    fn test_process_line_comment() {
+    fn process_line_comment_string_returns_lc_result_with_zero_duration() {
         let line = "# This is a comment";
         match process_line(line) {
             LineParseResult::Lc { life_chunk: lc } => {
@@ -164,7 +164,7 @@ mod tests {
     }
 
     #[test]
-    fn test_process_line_empty_string() {
+    fn process_line_empty_string_returns_empty_lc_result() {
         let line = "";
         match process_line(line) {
             LineParseResult::Lc { life_chunk: lc } => {
@@ -178,6 +178,53 @@ mod tests {
             _ => panic!("Expected LineParseResult::Lc for an empty line"),
         }
     }
+    #[test]
+    fn get_all_life_lapses_single_file_returns_parsed_lapses() {
+        use crate::config::Config;
+        use crate::parse::get_all_life_lapses;
+
+        let lines = vec![vec![
+            "2020-12-01 10:00".to_string(),
+            "1 0 Task 1 @work".to_string(),
+            "2 0 Task 2 @home".to_string(),
+        ]];
+        let config = Config::default();
+        let (start, lapses) = get_all_life_lapses(lines, &config);
+
+        assert_eq!(start, Local.ymd(2020, 12, 1).and_hms(10, 0, 0));
+        assert_eq!(lapses.len(), 1);
+        assert_eq!(lapses[0].tokens_as_ref().len(), 2);
+    }
+
+    #[test]
+    fn get_all_life_lapses_multiple_files_returns_merged_lapses() {
+        use crate::config::Config;
+        use crate::parse::get_all_life_lapses;
+
+        let lines = vec![
+            vec!["2020-12-01 10:00".to_string(), "1 0 Task 1".to_string()],
+            vec!["2020-12-01 11:00".to_string(), "1 0 Task 2".to_string()],
+        ];
+        let config = Config::default();
+        let (start, lapses) = get_all_life_lapses(lines, &config);
+
+        // Start time should be the min of all start times
+        assert_eq!(start, Local.ymd(2020, 12, 1).and_hms(10, 0, 0));
+        // They should be merged if compatible
+        // 10:00 + 1h = 11:00. Second file starts at 11:00.
+        // They are compatible and touching.
+        assert_eq!(lapses.len(), 1);
+        assert_eq!(lapses[0].tokens_as_ref().len(), 2);
+    }
+
+    #[test]
+    fn get_life_chunk_extra_spaces_returns_correct_description() {
+        let line = "1  0   Task  with   spaces   @work";
+        let lc = get_life_chunk(line);
+        assert_eq!(lc.description, "Task with spaces");
+        assert_eq!(lc.duration, Duration::hours(1));
+        assert_eq!(lc.categories, vec!["@work".to_string()]);
+    }
 }
 
 /// A continuous series of life chunks.
@@ -400,7 +447,9 @@ fn parse_date(s: &str) -> Option<Timestamp> {
 
 pub(crate) fn get_life_chunk(line: &str) -> LifeChunk {
     // Made pub(crate)
-    let mut tokens = line.split(|c: char| c == ',' || c.is_whitespace());
+    let mut tokens = line
+        .split(|c: char| c == ',' || c.is_whitespace())
+        .filter(|s| !s.is_empty());
 
     let mut parse_token_as_duration = |parse_as: fn(i64) -> Duration| {
         tokens