Fix test references: move to integration tests and use crate name

Author: d-oit

crates/cli/src/lib.rs

@@ -8,6 +8,4 @@ pub mod production_handlers;
 pub mod report_handlers;
 pub mod scan_handlers;
 pub mod stack_presets;
-#[cfg(test)]
-pub mod tests;
 pub mod utils;

crates/cli/src/main.rs

@@ -12,8 +12,6 @@ mod production_handlers;
 mod report_handlers;
 mod scan_handlers;
 mod stack_presets;
-#[cfg(test)]
-mod tests;
 mod utils;
 
 // Import the CLI definitions and command handlers

crates/cli/tests/tests.rs

@@ -0,0 +1,123 @@
+use code_guardian_cli::cli_definitions::{Cli, StackPreset};
+use clap::Parser;
+use std::path::PathBuf;
+
+#[cfg(test)]
+#[test]
+fn test_cli_help_generation() {
+    use clap::CommandFactory;
+    let mut cli = Cli::command();
+    let help_output = cli.render_help();
+
+    // Verify the CLI help contains our new commands
+    assert!(help_output.to_string().contains("production-check"));
+    assert!(help_output.to_string().contains("pre-commit"));
+    assert!(help_output.to_string().contains("ci-gate"));
+    assert!(help_output.to_string().contains("lang"));
+    assert!(help_output.to_string().contains("stack"));
+    assert!(help_output.to_string().contains("watch"));
+}
+
+#[cfg(test)]
+#[test]
+fn test_cli_description() {
+    use clap::CommandFactory;
+    let cli = Cli::command();
+    let about = cli.get_about().unwrap().to_string();
+
+    // Verify the CLI description mentions key features
+    assert!(about.contains("Multi-language"));
+    assert!(about.contains("production readiness"));
+    assert!(about.contains("code quality"));
+    // The about text is: "Multi-language code analysis tool for production readiness and code quality"
+}
+
+#[cfg(test)]
+#[test]
+fn test_stack_preset_variants() {
+    // Test that all stack presets are properly defined
+    let web_preset = StackPreset::Web {
+        path: PathBuf::from("."),
+        production: false,
+    };
+    let backend_preset = StackPreset::Backend {
+        path: PathBuf::from("."),
+        production: false,
+    };
+    let fullstack_preset = StackPreset::Fullstack {
+        path: PathBuf::from("."),
+        production: false,
+    };
+    let mobile_preset = StackPreset::Mobile {
+        path: PathBuf::from("."),
+        production: false,
+    };
+    let systems_preset = StackPreset::Systems {
+        path: PathBuf::from("."),
+        production: false,
+    };
+
+    // Basic validation that variants exist
+    match web_preset {
+        StackPreset::Web { .. } => (),
+        _ => panic!("Web preset should match"),
+    }
+    match backend_preset {
+        StackPreset::Backend { .. } => (),
+        _ => panic!("Backend preset should match"),
+    }
+    match fullstack_preset {
+        StackPreset::Fullstack { .. } => (),
+        _ => panic!("Fullstack preset should match"),
+    }
+    match mobile_preset {
+        StackPreset::Mobile { .. } => (),
+        _ => panic!("Mobile preset should match"),
+    }
+    match systems_preset {
+        StackPreset::Systems { .. } => (),
+        _ => panic!("Systems preset should match"),
+    }
+}
+
+#[cfg(test)]
+#[test]
+fn test_cli_parse_invalid_subcommand() {
+    let args = vec!["code-guardian", "invalid"];
+    let result = Cli::try_parse_from(args);
+    assert!(result.is_err());
+}
+
+#[cfg(test)]
+#[test]
+fn test_cli_parse_scan_missing_path() {
+    let args = vec!["code-guardian", "scan"];
+    let result = Cli::try_parse_from(args);
+    assert!(result.is_err());
+}
+
+#[cfg(test)]
+#[test]
+fn test_cli_parse_report_missing_id() {
+    let args = vec!["code-guardian", "report"];
+    let result = Cli::try_parse_from(args);
+    assert!(result.is_err());
+}
+
+#[cfg(test)]
+#[test]
+fn test_handle_history_invalid_db() {
+    use code_guardian_cli::command_handlers::handle_history;
+    let invalid_db = PathBuf::from("/invalid/path/db.db");
+    let result = handle_history(Some(invalid_db));
+    assert!(result.is_err());
+}
+
+#[cfg(test)]
+#[test]
+fn test_handle_benchmark_invalid_path() {
+    use code_guardian_cli::command_handlers::handle_benchmark;
+    let invalid_path = PathBuf::from("/invalid/path");
+    let result = handle_benchmark(Some(invalid_path), false);
+    assert!(result.is_err());
+}