Increase test coverage pre-release (pt 2)

Author: IvanIsCoding

src/cli.rs

@@ -234,3 +234,7 @@ pub struct InputParameters {
     pub greppable: bool,
     pub no_extensions: bool,
 }
+
+#[cfg(test)]
+#[path = "cli_test.rs"]
+mod tests;

src/cli_test.rs

@@ -0,0 +1,70 @@
+use super::*;
+use clap::Parser;
+
+#[test]
+fn test_argument_parse_success() {
+    let arg: Argument = "name:string=value".parse().unwrap();
+
+    assert_eq!(arg.name, "name");
+    assert_eq!(arg.type_name, "string");
+    assert_eq!(arg.value, "value");
+}
+
+#[test]
+fn test_argument_parse_missing_type_separator() {
+    let err = "name=value".parse::<Argument>().unwrap_err();
+
+    assert!(err.contains("Invalid argument format"));
+}
+
+#[test]
+fn test_argument_parse_missing_value_separator() {
+    let err = "name:string".parse::<Argument>().unwrap_err();
+
+    assert!(err.contains("Missing value for argument 'name'"));
+}
+
+#[test]
+fn test_argument_parse_empty_value() {
+    let arg: Argument = "name:string=".parse().unwrap();
+
+    assert_eq!(arg.value, "");
+}
+
+#[test]
+fn test_input_format_defaults_to_json() {
+    let cli = Cli::parse_from(["celq", "this"]);
+
+    assert_eq!(cli.input_format(), InputFormat::Json);
+}
+
+#[test]
+fn test_input_format_xml() {
+    let cli = Cli::parse_from(["celq", "--from-xml", "this"]);
+
+    assert_eq!(cli.input_format(), InputFormat::Xml);
+}
+
+#[test]
+fn test_parse_parallelism_positive() {
+    assert_eq!(parse_parallelism("3").unwrap(), 3);
+}
+
+#[test]
+fn test_parse_parallelism_zero_rejected() {
+    let err = parse_parallelism("0").unwrap_err();
+
+    assert_eq!(err, "parallelism level cannot be 0");
+}
+
+#[test]
+fn test_parse_parallelism_negative_uses_auto() {
+    assert_eq!(parse_parallelism("-4").unwrap(), -1);
+}
+
+#[test]
+fn test_parse_parallelism_invalid() {
+    let err = parse_parallelism("abc").unwrap_err();
+
+    assert_eq!(err, "'abc' is not a valid integer");
+}

src/input_handler_test.rs

@@ -300,3 +300,35 @@ fn test_handle_buffer_custom_root_var() {
     assert_eq!(results[0].0, "42");
     assert!(results[0].1);
 }
+
+#[test]
+fn test_handle_buffer_rejects_zero_parallelism() {
+    let program = Program::compile("this.x").unwrap();
+    let args = BTreeMap::new();
+    let input = r#"{"x": 42}"#;
+    let cursor = Cursor::new(input.as_bytes());
+    let reader = BufReader::new(cursor);
+    let mut params = default_params();
+    params.parallelism = 0;
+
+    let err = handle_buffer(&program, &args, &params, reader)
+        .unwrap_err()
+        .to_string();
+
+    assert!(err.contains("Parallelism level cannot be 0"));
+}
+
+#[test]
+#[cfg(not(feature = "greppable"))]
+fn test_handle_json_greppable_disabled() {
+    let program = Program::compile("this").unwrap();
+    let args = BTreeMap::new();
+    let mut params = default_params();
+    params.greppable = true;
+
+    let err = handle_json(&program, &args, &params, Some(r#"{"x": 42}"#))
+        .unwrap_err()
+        .to_string();
+
+    assert!(err.contains("Binary was compiled without greppable support"));
+}

src/json2cel_test.rs

@@ -257,6 +257,29 @@ fn test_yaml_format_disabled() {
     assert!(vars.is_err());
 }
 
+#[test]
+#[cfg(feature = "from-yaml")]
+fn test_yaml_invalid_input() {
+    let vars = json_to_cel_variables(
+        "{ invalid: [yaml",
+        ROOT_VAR,
+        InputFormat::Yaml,
+        DEFAULT_PARALLELISM,
+    );
+
+    assert!(vars.is_err());
+}
+
+#[test]
+#[cfg(not(feature = "from-xml"))]
+fn test_xml_format_disabled() {
+    let xml_input = r#"<root><value>42</value></root>"#;
+
+    let vars = json_to_cel_variables(xml_input, ROOT_VAR, InputFormat::Xml, DEFAULT_PARALLELISM);
+
+    assert!(vars.is_err());
+}
+
 #[test]
 #[cfg(feature = "from-yaml")]
 fn test_yaml_multi_document_format() {

src/main.rs

@@ -130,3 +130,7 @@ fn compile_expression(expression: Option<&str>, from_file: Option<&PathBuf>) ->
 
     Program::compile(&source).map_err(|e| anyhow::anyhow!(e))
 }
+
+#[cfg(test)]
+#[path = "main_test.rs"]
+mod tests;

src/main_test.rs

@@ -0,0 +1,43 @@
+use super::*;
+use tempfile::NamedTempFile;
+
+#[test]
+fn test_compile_expression_inline() {
+    let result = compile_expression(Some("1 + 2"), None);
+
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_compile_expression_from_file() {
+    let file = NamedTempFile::new().unwrap();
+    fs::write(file.path(), "1 + 2").unwrap();
+
+    let result = compile_expression(None, Some(&file.path().to_path_buf()));
+
+    assert!(result.is_ok());
+}
+
+#[test]
+fn test_compile_expression_missing_expression() {
+    let err = compile_expression(None, None).unwrap_err().to_string();
+
+    assert!(err.contains("missing CEL expression"));
+}
+
+#[test]
+fn test_compile_expression_missing_file() {
+    let path = PathBuf::from("/definitely/missing/celq-expression.txt");
+    let err = compile_expression(None, Some(&path))
+        .unwrap_err()
+        .to_string();
+
+    assert!(err.contains("failed to read expression file"));
+}
+
+#[test]
+fn test_compile_expression_invalid_source() {
+    let err = compile_expression(Some("("), None).unwrap_err().to_string();
+
+    assert!(!err.is_empty());
+}