test: add unit tests for generator logic

generator/Cargo.toml

@@ -16,3 +16,6 @@ serde_json = "1"
 toml = "0.8"
 anyhow = "1"
 chrono = "0.4"
+
+[dev-dependencies]
+tempfile = "3"

generator/src/cli.rs

@@ -32,6 +32,75 @@ pub fn parse_args(args: &[String]) -> Result<(PathBuf, PathBuf)> {
     Ok((defs_dir, gen_dir))
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    fn args(slice: &[&str]) -> Vec<String> {
+        slice.iter().map(|s| s.to_string()).collect()
+    }
+
+    #[test]
+    fn defaults_when_no_args() {
+        let (defs, gen) = parse_args(&args(&["bin"])).unwrap();
+        assert_eq!(defs, PathBuf::from("fixtures/definitions"));
+        assert_eq!(gen, PathBuf::from("fixtures/generated"));
+    }
+
+    #[test]
+    fn long_flags() {
+        let (defs, gen) =
+            parse_args(&args(&["bin", "--definitions", "/tmp/defs", "--output", "/tmp/out"]))
+                .unwrap();
+        assert_eq!(defs, PathBuf::from("/tmp/defs"));
+        assert_eq!(gen, PathBuf::from("/tmp/out"));
+    }
+
+    #[test]
+    fn short_flags() {
+        let (defs, gen) =
+            parse_args(&args(&["bin", "-d", "my/defs", "-o", "my/out"])).unwrap();
+        assert_eq!(defs, PathBuf::from("my/defs"));
+        assert_eq!(gen, PathBuf::from("my/out"));
+    }
+
+    #[test]
+    fn only_definitions_flag() {
+        let (defs, gen) = parse_args(&args(&["bin", "-d", "custom"])).unwrap();
+        assert_eq!(defs, PathBuf::from("custom"));
+        assert_eq!(gen, PathBuf::from("fixtures/generated"));
+    }
+
+    #[test]
+    fn only_output_flag() {
+        let (defs, gen) = parse_args(&args(&["bin", "-o", "custom"])).unwrap();
+        assert_eq!(defs, PathBuf::from("fixtures/definitions"));
+        assert_eq!(gen, PathBuf::from("custom"));
+    }
+
+    #[test]
+    fn missing_definitions_value() {
+        let result = parse_args(&args(&["bin", "--definitions"]));
+        assert!(result.is_err());
+        let msg = result.unwrap_err().to_string();
+        assert!(msg.contains("missing value"), "unexpected error: {msg}");
+    }
+
+    #[test]
+    fn missing_output_value() {
+        let result = parse_args(&args(&["bin", "--output"]));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn unknown_argument() {
+        let result = parse_args(&args(&["bin", "--foo"]));
+        assert!(result.is_err());
+        let msg = result.unwrap_err().to_string();
+        assert!(msg.contains("unknown argument"), "unexpected error: {msg}");
+    }
+}
+
 fn print_help() {
     println!(
         "generate-fixtures {}

generator/src/rng.rs

@@ -66,3 +66,80 @@ pub fn rand_time(rng: &mut Rng, now: i64) -> Time {
     let offset = days * 86400 + hours * 3600 + mins * 60;
     Time::new(now - offset, 0)
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn deterministic_sequence() {
+        let mut a = Rng::new(123);
+        let mut b = Rng::new(123);
+        let vals_a: Vec<usize> = (0..20).map(|_| a.usize(1000)).collect();
+        let vals_b: Vec<usize> = (0..20).map(|_| b.usize(1000)).collect();
+        assert_eq!(vals_a, vals_b);
+    }
+
+    #[test]
+    fn different_seeds_differ() {
+        let mut a = Rng::new(1);
+        let mut b = Rng::new(2);
+        let vals_a: Vec<usize> = (0..10).map(|_| a.usize(1000)).collect();
+        let vals_b: Vec<usize> = (0..10).map(|_| b.usize(1000)).collect();
+        assert_ne!(vals_a, vals_b);
+    }
+
+    #[test]
+    fn usize_within_range() {
+        let mut rng = Rng::new(42);
+        for _ in 0..200 {
+            let v = rng.usize(10);
+            assert!(v < 10, "got {v}, expected < 10");
+        }
+    }
+
+    #[test]
+    fn pick_returns_item_from_slice() {
+        let items = &["a", "b", "c"];
+        let mut rng = Rng::new(99);
+        for _ in 0..50 {
+            let picked = rng.pick(items);
+            assert!(items.contains(&picked));
+        }
+    }
+
+    #[test]
+    fn rand_message_format() {
+        let mut rng = Rng::new(42);
+        let msg = rand_message(&mut rng, "core");
+        // Must match pattern: type(scope)[!]: word word
+        assert!(msg.contains("(core)"), "missing scope in: {msg}");
+        assert!(msg.contains(": "), "missing colon-space in: {msg}");
+
+        let colon_pos = msg.find(": ").unwrap();
+        let prefix = &msg[..colon_pos];
+        // prefix is like "feat(core)" or "fix(core)!"
+        let paren = prefix.find('(').unwrap();
+        let type_part = &prefix[..paren];
+        assert!(
+            COMMIT_TYPES.contains(&type_part),
+            "unknown commit type '{type_part}' in: {msg}"
+        );
+
+        let body = &msg[colon_pos + 2..];
+        let words: Vec<&str> = body.split_whitespace().collect();
+        assert_eq!(words.len(), 2, "expected two words in body, got: {body}");
+        assert!(WORDS_A.contains(&words[0]), "unknown word_a '{}'", words[0]);
+        assert!(WORDS_B.contains(&words[1]), "unknown word_b '{}'", words[1]);
+    }
+
+    #[test]
+    fn rand_time_is_in_the_past() {
+        let mut rng = Rng::new(42);
+        let now = 1_700_000_000i64;
+        for _ in 0..50 {
+            let t = rand_time(&mut rng, now);
+            assert!(t.seconds() <= now);
+        }
+    }
+}