@crownpeak/dqm-react-component-dev-mcp 1.2.0

package/data/probe/tests/parallel_extraction_tests.rs

@@ -0,0 +1,178 @@
+use probe_code::extract::{handle_extract, ExtractOptions};
+use std::fs;
+use tempfile::tempdir;
+
+#[test]
+fn test_parallel_file_extraction() {
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create multiple test files
+    let file_count = 10;
+    let mut file_paths = Vec::new();
+
+    for i in 0..file_count {
+        let file_path = base_path.join(format!("test_file_{i}.rs"));
+        let content = format!(
+            "// Test file {i}\n\nfn function_a() {{\n    println!(\"Hello from function A\");\n}}\n\nfn function_b() {{\n    println!(\"Hello from function B\");\n}}\n"
+        );
+        fs::write(&file_path, content).unwrap();
+        file_paths.push(file_path.to_string_lossy().to_string());
+    }
+
+    // Create options for extraction
+    let options = ExtractOptions {
+        files: file_paths,
+        custom_ignores: Vec::new(),
+        context_lines: 0,
+        format: "plain".to_string(),
+        from_clipboard: false,
+        input_file: None,
+        to_clipboard: false,
+        dry_run: false,
+        diff: false,
+        allow_tests: true,
+        instructions: None,
+        keep_input: false,
+        prompt: None,
+        no_gitignore: false,
+    };
+
+    // Run the extraction
+    let result = handle_extract(options);
+    assert!(result.is_ok(), "Extraction should succeed");
+
+    // Verify that all files were processed by checking the output
+    // This is a basic test - in a real scenario, you might want to capture
+    // and parse the output to verify each file was processed correctly
+}
+
+#[test]
+fn test_parallel_extraction_with_specific_lines() {
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create a test file with multiple functions
+    let file_path = base_path.join("multi_function.rs");
+    let content = r#"
+fn function_one() {
+    println!("This is function one");
+}
+
+fn function_two() {
+    println!("This is function two");
+}
+
+fn function_three() {
+    println!("This is function three");
+}
+
+fn function_four() {
+    println!("This is function four");
+}
+"#;
+    fs::write(&file_path, content).unwrap();
+
+    // Create multiple files with the same content to test parallelism
+    let file_count = 5;
+    let mut file_paths = Vec::new();
+
+    for i in 0..file_count {
+        let path = base_path.join(format!("multi_function_{i}.rs"));
+        fs::write(&path, content).unwrap();
+        file_paths.push(path.to_string_lossy().to_string());
+    }
+    // Create options for extraction with specific lines
+    let options = ExtractOptions {
+        files: file_paths,
+        custom_ignores: Vec::new(),
+        context_lines: 0,
+        format: "plain".to_string(),
+        from_clipboard: false,
+        input_file: None,
+        to_clipboard: false,
+        dry_run: false,
+        diff: false,
+        allow_tests: true,
+        instructions: None,
+        keep_input: false,
+        prompt: None,
+        no_gitignore: false,
+    };
+
+    // Run the extraction
+    let result = handle_extract(options);
+    assert!(result.is_ok(), "Extraction should succeed");
+
+    // In a real test, you might want to capture the output and verify
+    // that all functions were extracted correctly from all files
+}
+
+#[test]
+fn test_parallel_extraction_performance() {
+    // This test is designed to verify that parallel extraction is faster
+    // than sequential extraction for a large number of files
+
+    // Skip this test in CI environments where performance might vary
+    if std::env::var("CI").is_ok() {
+        return;
+    }
+
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create a large number of test files
+    let file_count = 50; // Adjust based on your system capabilities
+    let mut file_paths = Vec::new();
+
+    for i in 0..file_count {
+        let file_path = base_path.join(format!("perf_test_{i}.rs"));
+
+        // Create a file with multiple functions to make parsing non-trivial
+        let content = format!(
+            "// Performance test file {}\n\n{}\n",
+            i,
+            (0..20)
+                .map(|j| format!(
+                "fn function_{i}_{j}() {{\n    let x = {j};\n    println!(\"Value: {{}}\", x);\n}}\n"
+            ))
+                .collect::<Vec<_>>()
+                .join("\n")
+        );
+
+        fs::write(&file_path, content).unwrap();
+        file_paths.push(file_path.to_string_lossy().to_string());
+    }
+
+    // Note: In a real performance test, you would measure the time taken
+    // and compare it with a sequential implementation. For this example,
+    // we're just verifying that the parallel implementation works correctly
+    // with a large number of files.
+
+    let options = ExtractOptions {
+        files: file_paths,
+        custom_ignores: Vec::new(),
+        context_lines: 0,
+        format: "plain".to_string(),
+        from_clipboard: false,
+        input_file: None,
+        to_clipboard: false,
+        dry_run: true, // Use dry run to avoid large output
+        diff: false,
+        allow_tests: true,
+        instructions: None,
+        keep_input: false,
+        prompt: None,
+        no_gitignore: false,
+    };
+
+    // Run the extraction
+    let result = handle_extract(options);
+    assert!(
+        result.is_ok(),
+        "Parallel extraction should succeed with many files"
+    );
+}

package/data/probe/tests/parallel_search_tests.rs

@@ -0,0 +1,355 @@
+use probe_code::search::search_runner::{
+    perform_probe, search_with_structured_patterns, SearchConfig,
+};
+use probe_code::search::SearchOptions;
+use std::fs;
+use std::path::{Path, PathBuf};
+use std::time::Instant;
+use tempfile::tempdir;
+
+// Helper function to create test files
+fn create_test_files(dir: &Path, count: usize, lines_per_file: usize) -> Vec<PathBuf> {
+    let mut paths = Vec::new();
+
+    for i in 0..count {
+        let file_path = dir.join(format!("test_file_{i}.rs"));
+
+        // Create file content with multiple functions and searchable terms
+        let mut content = format!("// Test file {i}\n\n");
+
+        for j in 0..lines_per_file / 10 {
+            content.push_str(&format!(
+                "/// Function documentation for function_{}_{}
+fn function_{}_{}() {{
+    // Initialize variables
+    let search_term_alpha = {};
+    let search_term_beta = {};
+
+    // Process data
+    println!(\"Processing data with search_term_gamma\");
+
+    // Return result
+    search_term_alpha + search_term_beta
+}}
+
+",
+                i,
+                j,
+                i,
+                j,
+                j * 2,
+                j * 3
+            ));
+        }
+
+        fs::write(&file_path, content).unwrap();
+        paths.push(file_path);
+    }
+
+    paths
+}
+
+#[test]
+fn test_parallel_file_search() {
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create multiple test files (50 files with 100 lines each)
+    let file_count = 50;
+    let lines_per_file = 100;
+    let _file_paths = create_test_files(base_path, file_count, lines_per_file);
+
+    // Create search options
+    let queries = vec![
+        "search_term_alpha".to_string(),
+        "search_term_beta".to_string(),
+    ];
+    let custom_ignores = Vec::new();
+
+    let options = SearchOptions {
+        path: base_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: false,
+        max_results: Some(100),
+        max_bytes: Some(1_000_000),
+        max_tokens: Some(100_000),
+        allow_tests: true,
+        no_merge: false,
+        merge_threshold: Some(5),
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Measure search time
+    let start_time = Instant::now();
+    let result = perform_probe(&options);
+    let duration = start_time.elapsed();
+
+    // Verify search results
+    assert!(result.is_ok(), "Search should succeed");
+    let search_results = result.unwrap();
+
+    // Ensure we found matches
+    assert!(
+        !search_results.results.is_empty(),
+        "Search should find matches"
+    );
+
+    // Print performance information
+    println!("Parallel search completed in {duration:?} for {file_count} files");
+    println!("Found {} results", search_results.results.len());
+}
+
+#[test]
+fn test_structured_patterns_search() {
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create test files
+    let file_count = 20;
+    let lines_per_file = 50;
+    let _file_paths = create_test_files(base_path, file_count, lines_per_file);
+
+    // Create a simple query plan and patterns for testing
+    let query_plan = probe_code::search::query::create_query_plan(
+        "search_term_alpha OR search_term_beta",
+        false,
+    )
+    .unwrap();
+
+    // Create patterns from the query plan
+    let patterns = probe_code::search::query::create_structured_patterns(&query_plan);
+
+    // Create empty custom ignores
+    let custom_ignores: Vec<String> = Vec::new();
+
+    // Measure search time
+    let start_time = Instant::now();
+    let search_filters = probe_code::search::filters::SearchFilters::new();
+    let search_config = SearchConfig {
+        custom_ignores: &custom_ignores,
+        allow_tests: true,
+        language: None,
+        no_gitignore: false,
+    };
+    let result = search_with_structured_patterns(
+        base_path,
+        &query_plan,
+        &patterns,
+        &search_config,
+        &search_filters,
+    );
+    let duration = start_time.elapsed();
+
+    // Verify search results
+    assert!(result.is_ok(), "Structured pattern search should succeed");
+    let file_term_maps = result.unwrap();
+
+    // Ensure we found matches
+    assert!(!file_term_maps.is_empty(), "Search should find matches");
+
+    // Print performance information
+    println!("Parallel structured pattern search completed in {duration:?} for {file_count} files");
+    println!("Found matches in {} files", file_term_maps.len());
+}
+
+#[test]
+fn test_ast_parallel_processing() {
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create a single large file with many top-level nodes to test AST parallelization
+    let file_path = base_path.join("large_file.rs");
+
+    // Create file content with many top-level functions
+    let mut content = "// Large test file with many top-level nodes\n\n".to_string();
+
+    for i in 0..100 {
+        content.push_str(&format!(
+            "/// Function documentation for function_{}
+fn function_{}() {{
+    // Function body with search terms
+    let search_term_alpha = {};
+    let search_term_beta = {};
+    println!(\"Processing with search_term_gamma\");
+}}
+
+",
+            i,
+            i,
+            i * 2,
+            i * 3
+        ));
+    }
+
+    fs::write(&file_path, content).unwrap();
+
+    // Create search options targeting the large file
+    let queries = vec![
+        "search_term_alpha".to_string(),
+        "search_term_beta".to_string(),
+    ];
+    let custom_ignores = Vec::new();
+
+    let options = SearchOptions {
+        path: base_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: false,
+        max_results: Some(100),
+        max_bytes: Some(1_000_000),
+        max_tokens: Some(100_000),
+        allow_tests: true,
+        no_merge: false,
+        merge_threshold: Some(5),
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Measure search time
+    let start_time = Instant::now();
+    let result = perform_probe(&options);
+    let duration = start_time.elapsed();
+
+    // Verify search results
+    assert!(
+        result.is_ok(),
+        "AST parallel processing search should succeed"
+    );
+    let search_results = result.unwrap();
+
+    // Ensure we found matches
+    assert!(
+        !search_results.results.is_empty(),
+        "Search should find matches"
+    );
+
+    // Print performance information
+    println!("AST parallel processing completed in {duration:?}");
+    println!("Found {} results", search_results.results.len());
+}
+
+#[test]
+fn test_block_parallel_processing() {
+    // Create a temporary directory for test files
+    let temp_dir = tempdir().unwrap();
+    let base_path = temp_dir.path();
+
+    // Create a file with many code blocks to test block parallelization
+    let file_path = base_path.join("multi_block.rs");
+
+    // Create file content with a large number of functions and nested blocks
+    let mut content = "// Test file with many code blocks\n\n".to_string();
+
+    for i in 0..50 {
+        content.push_str(&format!(
+            "/// Function with multiple blocks
+fn function_with_blocks_{}() {{
+    // Block 1
+    {{
+        let search_term_alpha = {};
+        println!(\"Block 1\");
+    }}
+
+    // Block 2
+    {{
+        let search_term_beta = {};
+        println!(\"Block 2\");
+    }}
+
+    // Block 3
+    {{
+        let search_term_gamma = {};
+        println!(\"Block 3\");
+    }}
+
+    // Block 4
+    if true {{
+        let search_term_delta = {};
+        println!(\"Block 4\");
+    }}
+}}
+
+",
+            i,
+            i,
+            i * 2,
+            i * 3,
+            i * 4
+        ));
+    }
+
+    fs::write(&file_path, content).unwrap();
+
+    // Create search options targeting the multi-block file
+    let queries = vec![
+        "search_term_alpha".to_string(),
+        "search_term_beta".to_string(),
+    ];
+    let custom_ignores = Vec::new();
+
+    let options = SearchOptions {
+        path: base_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: false,
+        max_results: Some(100),
+        max_bytes: Some(1_000_000),
+        max_tokens: Some(100_000),
+        allow_tests: true,
+        no_merge: false,
+        merge_threshold: Some(5),
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Measure search time
+    let start_time = Instant::now();
+    let result = perform_probe(&options);
+    let duration = start_time.elapsed();
+
+    // Verify search results
+    assert!(
+        result.is_ok(),
+        "Block parallel processing search should succeed"
+    );
+    let search_results = result.unwrap();
+
+    // Ensure we found matches
+    assert!(
+        !search_results.results.is_empty(),
+        "Search should find matches"
+    );
+
+    // Print performance information
+    println!("Block parallel processing completed in {duration:?}");
+    println!("Found {} results", search_results.results.len());
+}