cli_testing_specialist/generator/

test_generator.rs

use crate::analyzer::BehaviorInferrer;
use crate::error::Result;
use crate::types::{
    Assertion, CliAnalysis, CliOption, NoArgsBehavior, OptionType, TestCase, TestCategory,
    TestPriority,
};
use rayon::prelude::*;

/// Test generator for creating test cases from CLI analysis
pub struct TestGenerator {
    /// CLI analysis to generate tests from
    analysis: CliAnalysis,

    /// Categories to generate tests for
    categories: Vec<TestCategory>,
}

impl TestGenerator {
    /// Create a new test generator
    pub fn new(analysis: CliAnalysis, categories: Vec<TestCategory>) -> Self {
        Self {
            analysis,
            categories,
        }
    }

    /// Generate all test cases based on selected categories
    pub fn generate(&self) -> Result<Vec<TestCase>> {
        log::info!("Generating tests for {} categories", self.categories.len());

        let mut all_tests = Vec::new();

        for category in &self.categories {
            let tests = match category {
                TestCategory::Basic => self.generate_basic_tests()?,
                TestCategory::Help => self.generate_help_tests()?,
                TestCategory::Security => self.generate_security_tests()?,
                TestCategory::Path => self.generate_path_tests()?,
                TestCategory::InputValidation => self.generate_input_validation_tests()?,
                TestCategory::DestructiveOps => self.generate_destructive_ops_tests()?,
                TestCategory::DirectoryTraversal => self.generate_directory_traversal_tests()?,
                TestCategory::Performance => self.generate_performance_tests()?,
                TestCategory::MultiShell => self.generate_multi_shell_tests()?,
            };

            log::info!("Generated {} tests for {:?}", tests.len(), category);
            all_tests.extend(tests);
        }

        log::info!("Total tests generated: {}", all_tests.len());
        Ok(all_tests)
    }

    /// Generate tests in parallel using rayon
    pub fn generate_parallel(&self) -> Result<Vec<TestCase>> {
        log::info!(
            "Generating tests in parallel for {} categories",
            self.categories.len()
        );

        let results: Result<Vec<Vec<TestCase>>> = self
            .categories
            .par_iter()
            .map(|category| match category {
                TestCategory::Basic => self.generate_basic_tests(),
                TestCategory::Help => self.generate_help_tests(),
                TestCategory::Security => self.generate_security_tests(),
                TestCategory::Path => self.generate_path_tests(),
                TestCategory::InputValidation => self.generate_input_validation_tests(),
                TestCategory::DestructiveOps => self.generate_destructive_ops_tests(),
                TestCategory::DirectoryTraversal => self.generate_directory_traversal_tests(),
                TestCategory::Performance => self.generate_performance_tests(),
                TestCategory::MultiShell => self.generate_multi_shell_tests(),
            })
            .collect();

        let all_tests: Vec<TestCase> = results?.into_iter().flatten().collect();

        log::info!("Total tests generated (parallel): {}", all_tests.len());
        Ok(all_tests)
    }

    /// Generate basic validation tests (help, version, exit codes)
    fn generate_basic_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Test 1: Help flag
        tests.push(
            TestCase::new(
                "basic-001".to_string(),
                "Display help with --help flag".to_string(),
                TestCategory::Basic,
                "\"$CLI_BINARY\" --help".to_string(),
            )
            .with_exit_code(0)
            .with_assertion(Assertion::OutputContains("Usage:".to_string()))
            .with_tag("help".to_string()),
        );

        // Test 2: Short help flag
        tests.push(
            TestCase::new(
                "basic-002".to_string(),
                "Display help with -h flag".to_string(),
                TestCategory::Basic,
                "\"$CLI_BINARY\" -h".to_string(),
            )
            .with_exit_code(0)
            .with_assertion(Assertion::OutputContains("Usage:".to_string()))
            .with_tag("help".to_string()),
        );

        // Test 3: Version flag (if version detected)
        if self.analysis.version.is_some() {
            tests.push(
                TestCase::new(
                    "basic-003".to_string(),
                    "Display version with --version flag".to_string(),
                    TestCategory::Basic,
                    "\"$CLI_BINARY\" --version".to_string(),
                )
                .with_exit_code(0)
                .with_tag("version".to_string()),
            );
        }

        // Test 4: Invalid option
        // Note: clap returns exit code 2 for invalid options (Unix standard)
        tests.push(
            TestCase::new(
                "basic-004".to_string(),
                "Reject invalid option".to_string(),
                TestCategory::Basic,
                "\"$CLI_BINARY\" --invalid-option-xyz".to_string(),
            )
            .with_exit_code(2) // clap standard: 2 for usage errors
            .with_assertion(Assertion::OutputContains("error".to_string()))
            .with_tag("error-handling".to_string()),
        );

        // Test 5: No arguments (behavior depends on CLI type)
        let inferrer = BehaviorInferrer::new();
        let no_args_behavior = inferrer.infer_no_args_behavior(&self.analysis);

        match no_args_behavior {
            NoArgsBehavior::ShowHelp => {
                tests.push(
                    TestCase::new(
                        "basic-005".to_string(),
                        "Show help when invoked without arguments".to_string(),
                        TestCategory::Basic,
                        "\"$CLI_BINARY\"".to_string(),
                    )
                    .with_exit_code(0)
                    // Output check removed: Some CLIs output nothing
                    // (e.g., backup-suite exits silently with code 0)
                    .with_priority(TestPriority::Important)
                    .with_tag("no-args".to_string())
                    .with_tag("show-help".to_string()),
                );
            }

            NoArgsBehavior::RequireSubcommand => {
                tests.push(
                    TestCase::new(
                        "basic-005".to_string(),
                        "Require subcommand when invoked without arguments".to_string(),
                        TestCategory::Basic,
                        "\"$CLI_BINARY\"".to_string(),
                    )
                    .expect_nonzero_exit() // Accept exit 1 or 2
                    // Output check removed: CLIs show different error formats
                    // (short error message vs full help text)
                    .with_priority(TestPriority::Important)
                    .with_tag("no-args".to_string())
                    .with_tag("require-subcommand".to_string()),
                );
            }

            NoArgsBehavior::Interactive => {
                tests.push(
                    TestCase::new(
                        "basic-005".to_string(),
                        "Enter interactive mode when invoked without arguments".to_string(),
                        TestCategory::Basic,
                        "echo '' | \"$CLI_BINARY\"".to_string(), // Pipe empty input to exit immediately
                    )
                    .with_exit_code(0)
                    .with_priority(TestPriority::Important)
                    .with_tag("no-args".to_string())
                    .with_tag("interactive".to_string()),
                );
            }
        }

        Ok(tests)
    }

    /// Generate help display tests
    fn generate_help_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Test help for each subcommand
        for (idx, subcommand) in self.analysis.subcommands.iter().enumerate() {
            tests.push(
                TestCase::new(
                    format!("help-{:03}", idx + 1),
                    format!("Display help for subcommand '{}'", subcommand.name),
                    TestCategory::Help,
                    format!("\"$CLI_BINARY\" {} --help", subcommand.name),
                )
                .with_exit_code(0)
                .with_assertion(Assertion::OutputContains("Usage:".to_string()))
                .with_tag("subcommand-help".to_string())
                .with_tag(subcommand.name.clone()),
            );
        }

        Ok(tests)
    }

    /// Generate security scanner tests
    ///
    /// **IMPORTANT**: Security tests MUST expect non-zero exit codes for malicious inputs.
    /// A tool that accepts malicious input (exit code 0) is vulnerable.
    ///
    /// # Security Test Philosophy
    ///
    /// - **Injection attacks**: Tool MUST reject with non-zero exit code (1 or 2)
    /// - **Null bytes**: Tool MUST reject with non-zero exit code (1 or 2)
    /// - **Path traversal**: Tool MUST reject with non-zero exit code (1 or 2)
    /// - **Buffer overflow**: Tool MUST handle gracefully (may succeed if sanitized)
    ///
    /// # Unix Exit Code Convention
    ///
    /// - **0**: Success
    /// - **1**: General error (runtime error, validation failure)
    /// - **2**: Command-line usage error (invalid option, clap/argparse default)
    ///
    /// Modern CLI parsers (clap, commander, argparse) return exit code 2 for invalid options,
    /// which is the correct Unix convention. Security tests accept both 1 and 2 as valid rejection.
    fn generate_security_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Find a string option for testing (prefer --config, --file, or first string option)
        let string_option = self
            .analysis
            .global_options
            .iter()
            .find(|opt| {
                matches!(opt.option_type, OptionType::String | OptionType::Path)
                    && opt.long.is_some()
            })
            .and_then(|opt| opt.long.as_ref())
            .unwrap_or(&"--invalid-option".to_string())
            .clone();

        // Test 1: Command injection via option
        // MUST reject malicious input (any non-zero exit code)
        tests.push(
            TestCase::new(
                "security-001".to_string(),
                "Reject command injection in option value".to_string(),
                TestCategory::Security,
                format!("\"$CLI_BINARY\" {} 'test; rm -rf /'", string_option),
            )
            .expect_nonzero_exit() // Accept exit code 1, 2, or any non-zero
            .with_priority(TestPriority::SecurityCheck)
            .with_tag("injection".to_string())
            .with_tag("critical".to_string()),
        );

        // Test 2: Null byte injection
        // MUST reject malicious input (any non-zero exit code)
        tests.push(
            TestCase::new(
                "security-002".to_string(),
                "Reject null byte in option value".to_string(),
                TestCategory::Security,
                format!(r#""$CLI_BINARY" {} $'/tmp/test\x00malicious'"#, string_option),
            )
            .expect_nonzero_exit() // Accept exit code 1, 2, or any non-zero
            .with_priority(TestPriority::SecurityCheck)
            .with_tag("injection".to_string())
            .with_tag("critical".to_string()),
        );

        // Test 3: Path traversal
        // MUST reject path traversal attempt (any non-zero exit code)
        tests.push(
            TestCase::new(
                "security-003".to_string(),
                "Reject path traversal attempt".to_string(),
                TestCategory::Security,
                format!("\"$CLI_BINARY\" {} ../../../etc/passwd", string_option),
            )
            .expect_nonzero_exit() // Accept exit code 1, 2, or any non-zero
            .with_priority(TestPriority::SecurityCheck)
            .with_tag("path-traversal".to_string())
            .with_tag("critical".to_string()),
        );

        // Test 4: Long input (buffer overflow test)
        // This is informational - tool may succeed if input is properly sanitized
        let long_input = "A".repeat(10000);
        tests.push(
            TestCase::new(
                "security-004".to_string(),
                "Handle extremely long input".to_string(),
                TestCategory::Security,
                format!("\"$CLI_BINARY\" {} '{}'", string_option, long_input),
            )
            // No exit code expectation - this is informational
            // Tool may succeed (0) if properly sanitized, or fail (1) if rejected
            .with_priority(TestPriority::Important) // Informational test
            .with_tag("buffer-overflow".to_string())
            .with_tag("informational".to_string()),
        );

        Ok(tests)
    }

    /// Generate path handling tests
    fn generate_path_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Find path options
        let path_options: Vec<&CliOption> = self
            .analysis
            .global_options
            .iter()
            .filter(|opt| matches!(opt.option_type, OptionType::Path))
            .collect();

        if path_options.is_empty() {
            log::debug!("No path options found, generating generic path tests");
            return Ok(tests);
        }

        for (idx, option) in path_options.iter().enumerate() {
            let flag = option.long.as_ref().or(option.short.as_ref()).unwrap();

            // Test 1: Path with spaces
            tests.push(
                TestCase::new(
                    format!("path-{:03}-spaces", idx + 1),
                    format!("Handle path with spaces for {}", flag),
                    TestCategory::Path,
                    format!("\"$CLI_BINARY\" {} '/tmp/test dir/file.txt'", flag),
                )
                .with_tag("spaces".to_string()),
            );

            // Test 2: Unicode path
            tests.push(
                TestCase::new(
                    format!("path-{:03}-unicode", idx + 1),
                    format!("Handle Unicode in path for {}", flag),
                    TestCategory::Path,
                    format!("\"$CLI_BINARY\" {} '/tmp/テスト/file.txt'", flag),
                )
                .with_tag("unicode".to_string()),
            );

            // Test 3: Symbolic links
            tests.push(
                TestCase::new(
                    format!("path-{:03}-symlink", idx + 1),
                    format!("Handle symbolic links for {}", flag),
                    TestCategory::Path,
                    format!("\"$CLI_BINARY\" {} '/tmp/test-symlink'", flag),
                )
                .with_tag("symlink".to_string()),
            );
        }

        Ok(tests)
    }

    /// Generate input validation tests
    fn generate_input_validation_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Find numeric options
        let numeric_options: Vec<&CliOption> = self
            .analysis
            .global_options
            .iter()
            .filter(|opt| matches!(opt.option_type, OptionType::Numeric { .. }))
            .collect();

        for (idx, option) in numeric_options.iter().enumerate() {
            let flag = option.long.as_ref().or(option.short.as_ref()).unwrap();

            // Test 1: Valid value
            tests.push(
                TestCase::new(
                    format!("input-{:03}-valid", idx + 1),
                    format!("Accept valid numeric value for {}", flag),
                    TestCategory::InputValidation,
                    format!("\"$CLI_BINARY\" {} 10", flag),
                )
                .with_tag("numeric".to_string()),
            );

            // Test 2: Non-numeric value
            tests.push(
                TestCase::new(
                    format!("input-{:03}-invalid", idx + 1),
                    format!("Reject non-numeric value for {}", flag),
                    TestCategory::InputValidation,
                    format!("\"$CLI_BINARY\" {} 'not-a-number'", flag),
                )
                .with_exit_code(1)
                .with_tag("numeric".to_string())
                .with_tag("validation".to_string()),
            );

            // Test 3: Negative value (if min >= 0)
            if let OptionType::Numeric {
                min: Some(min_val), ..
            } = &option.option_type
            {
                if *min_val >= 0 {
                    tests.push(
                        TestCase::new(
                            format!("input-{:03}-negative", idx + 1),
                            format!("Reject negative value for {}", flag),
                            TestCategory::InputValidation,
                            format!("\"$CLI_BINARY\" {} -1", flag),
                        )
                        .with_exit_code(1)
                        .with_tag("numeric".to_string())
                        .with_tag("validation".to_string()),
                    );
                }
            }
        }

        // Find enum options
        let enum_options: Vec<&CliOption> = self
            .analysis
            .global_options
            .iter()
            .filter(|opt| matches!(opt.option_type, OptionType::Enum { .. }))
            .collect();

        for (idx, option) in enum_options.iter().enumerate() {
            let flag = option.long.as_ref().or(option.short.as_ref()).unwrap();

            if let OptionType::Enum { values } = &option.option_type {
                if let Some(first_value) = values.first() {
                    // Test valid enum value
                    tests.push(
                        TestCase::new(
                            format!("enum-{:03}-valid", idx + 1),
                            format!("Accept valid enum value for {}", flag),
                            TestCategory::InputValidation,
                            format!("\"$CLI_BINARY\" {} {}", flag, first_value),
                        )
                        .with_tag("enum".to_string()),
                    );
                }

                // Test invalid enum value
                tests.push(
                    TestCase::new(
                        format!("enum-{:03}-invalid", idx + 1),
                        format!("Reject invalid enum value for {}", flag),
                        TestCategory::InputValidation,
                        format!("\"$CLI_BINARY\" {} 'invalid-value-xyz'", flag),
                    )
                    .with_exit_code(1)
                    .with_tag("enum".to_string())
                    .with_tag("validation".to_string()),
                );
            }
        }

        Ok(tests)
    }

    /// Generate destructive operations tests
    fn generate_destructive_ops_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Look for destructive subcommands (delete, remove, clean, destroy, etc.)
        let destructive_keywords = ["delete", "remove", "clean", "destroy", "purge", "drop"];

        for subcommand in &self.analysis.subcommands {
            let is_destructive = destructive_keywords
                .iter()
                .any(|keyword| subcommand.name.to_lowercase().contains(keyword));

            if is_destructive {
                // Generate dummy values for required arguments
                let dummy_args = subcommand
                    .required_args
                    .iter()
                    .map(|arg| {
                        // Generate appropriate dummy value based on argument name
                        match arg.to_lowercase().as_str() {
                            "id" | "name" => "test-id",
                            "file" | "path" => "/tmp/test-file",
                            "dir" | "directory" => "/tmp/test-dir",
                            _ => "test-value",
                        }
                    })
                    .collect::<Vec<_>>()
                    .join(" ");

                let args_part = if dummy_args.is_empty() {
                    String::new()
                } else {
                    format!(" {}", dummy_args)
                };

                // Test 1: Check for confirmation prompt
                tests.push(
                    TestCase::new(
                        format!("destructive-{}-001", subcommand.name),
                        format!("Subcommand '{}' requires confirmation", subcommand.name),
                        TestCategory::DestructiveOps,
                        format!("echo 'n' | \"$CLI_BINARY\" {}{}", subcommand.name, args_part),
                    )
                    .with_assertion(Assertion::OutputContains("confirm".to_string()))
                    .with_tag("confirmation".to_string())
                    .with_tag(subcommand.name.clone()),
                );

                // Test 2: Check for --yes or --force flag
                let has_yes_flag = subcommand.options.iter().any(|opt| {
                    opt.long
                        .as_ref()
                        .is_some_and(|l| l.contains("yes") || l.contains("force"))
                });

                if has_yes_flag {
                    tests.push(
                        TestCase::new(
                            format!("destructive-{}-002", subcommand.name),
                            format!("Subcommand '{}' accepts --yes flag", subcommand.name),
                            TestCategory::DestructiveOps,
                            format!("\"$CLI_BINARY\" {}{} --yes", subcommand.name, args_part),
                        )
                        .with_tag("force".to_string())
                        .with_tag(subcommand.name.clone()),
                    );
                }
            }
        }

        // If no destructive subcommands found, generate generic test
        if tests.is_empty() {
            log::debug!("No destructive subcommands detected");
        }

        Ok(tests)
    }

    /// Generate directory traversal tests
    fn generate_directory_traversal_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Test 1: Large directory (1000 files)
        tests.push(
            TestCase::new(
                "dir-traversal-001".to_string(),
                "Handle directory with 1000 files".to_string(),
                TestCategory::DirectoryTraversal,
                "\"$CLI_BINARY\" /tmp/test-large-dir".to_string(),
            )
            .with_tag("performance".to_string())
            .with_tag("large-dir".to_string()),
        );

        // Test 2: Deep directory nesting (50 levels)
        tests.push(
            TestCase::new(
                "dir-traversal-002".to_string(),
                "Handle deeply nested directory (50 levels)".to_string(),
                TestCategory::DirectoryTraversal,
                "\"$CLI_BINARY\" /tmp/test-deep-dir".to_string(),
            )
            .with_tag("performance".to_string())
            .with_tag("deep-nesting".to_string()),
        );

        // Test 3: Symlink loops
        tests.push(
            TestCase::new(
                "dir-traversal-003".to_string(),
                "Detect and handle symlink loops".to_string(),
                TestCategory::DirectoryTraversal,
                "\"$CLI_BINARY\" /tmp/test-symlink-loop".to_string(),
            )
            .with_tag("symlink".to_string())
            .with_tag("loop-detection".to_string()),
        );

        Ok(tests)
    }

    /// Generate performance tests
    fn generate_performance_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Test 1: Startup time (help should be fast)
        tests.push(
            TestCase::new(
                "perf-001".to_string(),
                "Startup time for --help < 100ms".to_string(),
                TestCategory::Performance,
                "\"$CLI_BINARY\" --help".to_string(),
            )
            .with_exit_code(0)
            .with_tag("startup".to_string())
            .with_tag("benchmark".to_string()),
        );

        // Test 2: Memory usage
        tests.push(
            TestCase::new(
                "perf-002".to_string(),
                "Memory usage stays within reasonable limits".to_string(),
                TestCategory::Performance,
                "\"$CLI_BINARY\" --help".to_string(),
            )
            .with_exit_code(0)
            .with_tag("memory".to_string())
            .with_tag("benchmark".to_string()),
        );

        Ok(tests)
    }

    /// Generate multi-shell compatibility tests
    fn generate_multi_shell_tests(&self) -> Result<Vec<TestCase>> {
        let mut tests = Vec::new();

        // Test basic command in different shells (bash, zsh, sh)
        for shell in &["bash", "zsh", "sh"] {
            tests.push(
                TestCase::new(
                    format!("multi-shell-{}", shell),
                    format!("Run --help in {}", shell),
                    TestCategory::MultiShell,
                    format!("{} -c '\"$CLI_BINARY\" --help'", shell),
                )
                .with_exit_code(0)
                .with_tag(shell.to_string()),
            );
        }

        Ok(tests)
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use crate::types::Subcommand;
    use std::path::PathBuf;

    fn create_test_analysis() -> CliAnalysis {
        let mut analysis = CliAnalysis::new(
            PathBuf::from("/usr/bin/test-cli"),
            "test-cli".to_string(),
            "Test CLI help output".to_string(),
        );

        analysis.version = Some("1.0.0".to_string());

        // Add a numeric option
        analysis.global_options.push(CliOption {
            short: Some("-t".to_string()),
            long: Some("--timeout".to_string()),
            description: Some("Timeout in seconds".to_string()),
            option_type: OptionType::Numeric {
                min: Some(0),
                max: Some(3600),
            },
            required: false,
            default_value: Some("30".to_string()),
        });

        // Add a path option
        analysis.global_options.push(CliOption {
            short: Some("-f".to_string()),
            long: Some("--file".to_string()),
            description: Some("Input file".to_string()),
            option_type: OptionType::Path,
            required: false,
            default_value: None,
        });

        // Add an enum option
        analysis.global_options.push(CliOption {
            short: None,
            long: Some("--format".to_string()),
            description: Some("Output format".to_string()),
            option_type: OptionType::Enum {
                values: vec!["json".to_string(), "yaml".to_string(), "text".to_string()],
            },
            required: false,
            default_value: Some("text".to_string()),
        });

        // Add a subcommand
        analysis.subcommands.push(Subcommand {
            name: "delete".to_string(),
            description: Some("Delete resources".to_string()),
            options: vec![CliOption {
                short: None,
                long: Some("--yes".to_string()),
                description: Some("Skip confirmation".to_string()),
                option_type: OptionType::Flag,
                required: false,
                default_value: None,
            }],
            required_args: vec![],
            subcommands: vec![],
            depth: 0,
        });

        analysis
    }

    #[test]
    fn test_generator_creation() {
        let analysis = create_test_analysis();
        let categories = vec![TestCategory::Basic];
        let generator = TestGenerator::new(analysis, categories);

        assert_eq!(generator.categories.len(), 1);
    }

    #[test]
    fn test_generate_basic_tests() {
        let analysis = create_test_analysis();
        let generator = TestGenerator::new(analysis, vec![]);

        let tests = generator.generate_basic_tests().unwrap();

        assert!(!tests.is_empty());
        assert!(tests.iter().any(|t| t.command.contains("--help")));
        assert!(tests.iter().any(|t| t.command.contains("--version")));
    }

    #[test]
    fn test_generate_security_tests() {
        let analysis = create_test_analysis();
        let generator = TestGenerator::new(analysis, vec![]);

        let tests = generator.generate_security_tests().unwrap();

        assert!(!tests.is_empty());
        assert!(tests
            .iter()
            .any(|t| t.tags.contains(&"injection".to_string())));
    }

    #[test]
    fn test_generate_input_validation_tests() {
        let analysis = create_test_analysis();
        let generator = TestGenerator::new(analysis, vec![]);

        let tests = generator.generate_input_validation_tests().unwrap();

        assert!(!tests.is_empty());
        // Should have tests for numeric, path, and enum options
        assert!(tests
            .iter()
            .any(|t| t.tags.contains(&"numeric".to_string())));
        assert!(tests.iter().any(|t| t.tags.contains(&"enum".to_string())));
    }

    #[test]
    fn test_generate_destructive_ops_tests() {
        let analysis = create_test_analysis();
        let generator = TestGenerator::new(analysis, vec![]);

        let tests = generator.generate_destructive_ops_tests().unwrap();

        assert!(!tests.is_empty());
        assert!(tests.iter().any(|t| t.command.contains("delete")));
    }

    #[test]
    fn test_generate_all_categories() {
        let analysis = create_test_analysis();
        let categories = vec![
            TestCategory::Basic,
            TestCategory::Security,
            TestCategory::InputValidation,
        ];
        let generator = TestGenerator::new(analysis, categories);

        let tests = generator.generate().unwrap();

        assert!(!tests.is_empty());
        assert!(tests.iter().any(|t| t.category == TestCategory::Basic));
        assert!(tests.iter().any(|t| t.category == TestCategory::Security));
        assert!(tests
            .iter()
            .any(|t| t.category == TestCategory::InputValidation));
    }

    #[test]
    fn test_generate_parallel() {
        let analysis = create_test_analysis();
        let categories = vec![
            TestCategory::Basic,
            TestCategory::Security,
            TestCategory::Performance,
        ];
        let generator = TestGenerator::new(analysis, categories);

        let tests = generator.generate_parallel().unwrap();

        assert!(!tests.is_empty());
    }
}