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

package/data/probe/tests/quoted_term_with_negative_keyword_tests.rs

@@ -0,0 +1,216 @@
+use std::fs;
+use std::path::Path;
+use tempfile::TempDir;
+
+use probe_code::search::{perform_probe, SearchOptions};
+
+/// Create test files with different content for testing queries
+fn create_test_files(temp_dir: &Path) {
+    // File with "keywordAlpha" only
+    let file1_path = temp_dir.join("file1.rs");
+    let file1_content = r#"
+// This file contains keywordAlpha only
+fn test_function() {
+    // This is keywordAlpha
+    let x = 1;
+
+    println!("Result: {}", x);
+}
+"#;
+
+    // File with "keywordAlpha" and "keywordGamma"
+    let file2_path = temp_dir.join("file2.rs");
+    let file2_content = r#"
+// This file contains keywordAlpha and keywordGamma
+fn another_function() {
+    // This is keywordAlpha
+    let x = 1;
+
+    // This is keywordGamma
+    let z = 3;
+
+    println!("Result: {}", x + z);
+}
+"#;
+
+    // Write files to disk
+    fs::write(file1_path, file1_content).unwrap();
+    fs::write(file2_path, file2_content).unwrap();
+}
+
+/// Test a query with a quoted term and a negative keyword: "keywordAlpha" -keywordGamma
+#[test]
+fn test_quoted_term_with_negative_keyword() {
+    // Create a temporary directory for testing
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create test files with different content
+    create_test_files(temp_path);
+
+    // Create search query with a quoted term and a negative keyword
+    let queries = vec!["\"keywordAlpha\" -keywordGamma".to_string()];
+    let custom_ignores: Vec<String> = vec![];
+
+    // Print the test files for debugging
+    println!("Test files created in: {temp_path:?}");
+    for entry in std::fs::read_dir(temp_path).unwrap() {
+        let entry = entry.unwrap();
+        println!("  {:?}", entry.path());
+
+        // Print file content for debugging
+        let content = std::fs::read_to_string(entry.path()).unwrap();
+        println!(
+            "  Content of {:?}:\n{}",
+            entry.path().file_name().unwrap(),
+            content
+        );
+    }
+
+    // Create SearchOptions
+    let options = SearchOptions {
+        path: temp_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: false,
+        max_results: None,
+        max_bytes: None,
+        max_tokens: None,
+        allow_tests: true,
+        no_merge: false,
+        merge_threshold: Some(5),
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Print the query for debugging
+    println!("Executing search with query: {queries:?}");
+    println!(
+        "Path: {:?}, frequency_search: {}",
+        options.path, options.frequency_search
+    );
+
+    // Run the search
+    let search_results = perform_probe(&options).unwrap();
+
+    // Check that we got results
+    assert!(
+        !search_results.results.is_empty(),
+        "Search should return results"
+    );
+
+    // We should find files with "keywordAlpha" but not "keywordGamma"
+    let file_names: Vec<&str> = search_results
+        .results
+        .iter()
+        .map(|r| r.file.as_str())
+        .collect();
+
+    // Debug output
+    println!(
+        "Quoted term with negative keyword query results: {} items",
+        search_results.results.len()
+    );
+    for result in &search_results.results {
+        println!("  File: {}", result.file);
+    }
+
+    // Check that we found file1 (has "keywordAlpha" but not "keywordGamma")
+    assert!(
+        file_names.iter().any(|&name| name.contains("file1")),
+        "Should find file1 which contains \"keywordAlpha\" but not \"keywordGamma\""
+    );
+
+    // Check that we don't find file2 (it has "keywordGamma")
+    assert!(
+        !file_names.iter().any(|&name| name.contains("file2")),
+        "Should not find file2 which contains \"keywordGamma\""
+    );
+}
+
+/// Test a query with a negative quoted term: -"keywordGamma"
+#[test]
+fn test_negative_quoted_term() {
+    // Create a temporary directory for testing
+    let temp_dir = TempDir::new().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create test files with different content
+    create_test_files(temp_path);
+
+    // Create search query with a negative quoted term
+    let queries = vec!["\"keywordalpha\" -\"keywordgamma\"".to_string()];
+    let custom_ignores: Vec<String> = vec![];
+
+    // Create SearchOptions
+    let options = SearchOptions {
+        path: temp_path,
+        queries: &queries,
+        files_only: false,
+        custom_ignores: &custom_ignores,
+        exclude_filenames: false,
+        language: None,
+        reranker: "hybrid",
+        frequency_search: false,
+        max_results: None,
+        max_bytes: None,
+        max_tokens: None,
+        allow_tests: true,
+        no_merge: false,
+        merge_threshold: Some(5),
+        dry_run: false,
+        session: None,
+        timeout: 30,
+        question: None,
+        exact: false,
+        no_gitignore: false,
+    };
+
+    // Print the query for debugging
+    println!("Executing search with query: {queries:?}");
+
+    // Run the search
+    let search_results = perform_probe(&options).unwrap();
+
+    // Check that we got results
+    assert!(
+        !search_results.results.is_empty(),
+        "Search should return results"
+    );
+
+    // We should find files with "keywordAlpha" but not "keywordGamma"
+    let file_names: Vec<&str> = search_results
+        .results
+        .iter()
+        .map(|r| r.file.as_str())
+        .collect();
+
+    // Debug output
+    println!(
+        "Negative quoted term query results: {} items",
+        search_results.results.len()
+    );
+    for result in &search_results.results {
+        println!("  File: {}", result.file);
+    }
+
+    // Check that we found file1 (has "keywordAlpha" but not "keywordGamma")
+    assert!(
+        file_names.iter().any(|&name| name.contains("file1")),
+        "Should find file1 which contains \"keywordAlpha\" but not \"keywordGamma\""
+    );
+
+    // Check that we don't find file2 (it has "keywordGamma")
+    assert!(
+        !file_names.iter().any(|&name| name.contains("file2")),
+        "Should not find file2 which contains \"keywordGamma\""
+    );
+}

package/data/probe/tests/required_terms_filename_tests.rs

@@ -0,0 +1,116 @@
+use std::fs::File;
+use std::io::Write;
+use tempfile::tempdir;
+
+#[test]
+fn test_required_terms_with_filename_matching() {
+    // Create a temporary directory for our test files
+    let temp_dir = tempdir().unwrap();
+    let temp_path = temp_dir.path();
+
+    // Create test files
+    let file1_path = temp_path.join("file1.rs");
+    let file2_path = temp_path.join("file2.rs");
+    let file3_path = temp_path.join("file3.rs");
+    let load_go_path = temp_path.join("load.go");
+
+    // File 1: Contains "api" and "load" but not "process"
+    let file1_content = r#"
+    fn main() {
+        let api = get_api();
+        api.load();
+    }
+    "#;
+
+    // File 2: Does not contain "api", but contains "load" and "process"
+    let file2_content = r#"
+    fn main() {
+        let data = load();
+        process(data);
+    }
+    "#;
+
+    // File 3: Contains all three terms
+    let file3_content = r#"
+    fn main() {
+        let api = get_api();
+        let data = api.load();
+        process(data);
+    }
+    "#;
+
+    // Load.go: Filename contains "load" and content contains "process"
+    let load_go_content = r#"
+    func main() {
+        process(data);
+    }
+    "#;
+
+    // Write the files
+    File::create(&file1_path)
+        .unwrap()
+        .write_all(file1_content.as_bytes())
+        .unwrap();
+    File::create(&file2_path)
+        .unwrap()
+        .write_all(file2_content.as_bytes())
+        .unwrap();
+    File::create(&file3_path)
+        .unwrap()
+        .write_all(file3_content.as_bytes())
+        .unwrap();
+    File::create(&load_go_path)
+        .unwrap()
+        .write_all(load_go_content.as_bytes())
+        .unwrap();
+
+    // Run the search with the query "api +load +process"
+    let output = std::process::Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "search",
+            "api +load +process",
+            temp_path.to_str().unwrap(),
+        ])
+        .env("DEBUG", "1")
+        .env("RUST_BACKTRACE", "1")
+        .output()
+        .expect("Failed to execute command");
+
+    let stdout = String::from_utf8_lossy(&output.stdout);
+    let stderr = String::from_utf8_lossy(&output.stderr);
+
+    println!("STDOUT: {stdout}");
+    println!("STDERR: {stderr}");
+
+    // Extract the file names from the output
+    let file_names: Vec<&str> = stdout
+        .lines()
+        .filter(|line| line.contains("File:"))
+        .collect();
+
+    // Check that file1.rs is NOT found (it doesn't have "process" which is required)
+    assert!(
+        !file_names.iter().any(|&name| name.contains("file1.rs")),
+        "Should NOT find file1.rs which contains 'api' and 'load' but not 'process'"
+    );
+
+    // Check that file2.rs is found (it has "load" and "process" which are required, even though it doesn't have "api")
+    assert!(
+        file_names.iter().any(|&name| name.contains("file2.rs")),
+        "Should find file2.rs which contains 'load' and 'process' but not 'api'"
+    );
+
+    // Check that file3.rs is found (it has all three terms)
+    assert!(
+        file_names.iter().any(|&name| name.contains("file3.rs")),
+        "Should find file3.rs which contains all three terms"
+    );
+
+    // Check that load.go is found (it has "process" in content and "load" in filename)
+    assert!(
+        file_names.iter().any(|&name| name.contains("load.go")),
+        "Should find load.go which has 'process' in content and 'load' in filename"
+    );
+}