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

package/data/probe/tests/query_command_json_tests.rs

@@ -0,0 +1,438 @@
+use serde_json::Value;
+use std::fs::{self, File};
+use std::io::Write;
+use std::path::PathBuf;
+use std::process::Command;
+use tempfile::TempDir;
+
+// Helper function to extract JSON from command output
+fn extract_json_from_output(output: &str) -> &str {
+    // Find the first occurrence of '{'
+    if let Some(start_index) = output.find('{') {
+        // Return the substring from the first '{' to the end
+        &output[start_index..]
+    } else {
+        // If no '{' is found, return the original string
+        output
+    }
+}
+
+// Helper function to create test files
+fn create_test_file(dir: &TempDir, filename: &str, content: &str) -> PathBuf {
+    let file_path = dir.path().join(filename);
+    let parent_dir = file_path.parent().unwrap();
+    fs::create_dir_all(parent_dir).expect("Failed to create parent directories");
+    let mut file = File::create(&file_path).expect("Failed to create test file");
+    file.write_all(content.as_bytes())
+        .expect("Failed to write test content");
+    file_path
+}
+
+// Helper function to create a test directory structure with various test files
+fn create_test_directory_structure(root_dir: &TempDir) {
+    // Create a source directory
+    let src_dir = root_dir.path().join("src");
+    fs::create_dir(&src_dir).expect("Failed to create src directory");
+
+    // Create Rust files with functions
+    let rust_content = r#"
+fn hello_world() {
+    println!("Hello, world!");
+}
+
+fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+"#;
+    create_test_file(root_dir, "src/functions.rs", rust_content);
+
+    // Create a JavaScript file with functions
+    let js_content = r#"
+function greet(name) {
+    return `Hello, ${name}!`;
+}
+
+const multiply = (a, b) => a * b;
+"#;
+    create_test_file(root_dir, "src/functions.js", js_content);
+
+    // Create a file with special characters
+    let special_chars_content = r#"
+// This file contains special characters: "quotes", 'apostrophes', <tags>, &ampersands
+function escapeTest(input) {
+    return input.replace(/[<>&"']/g, function(c) {
+        return {
+            '<': '&lt;',
+            '>': '&gt;',
+            '&': '&amp;',
+            '"': '&quot;',
+            "'": '&#39;'
+        }[c];
+    });
+}
+"#;
+    create_test_file(root_dir, "src/special_chars.js", special_chars_content);
+
+    // Create a Python file with functions
+    let python_content = r#"
+def calculate_sum(numbers):
+    """Calculate the sum of a list of numbers."""
+    return sum(numbers)
+
+def process_data(data, callback):
+    """Process data using the provided callback function."""
+    return callback(data)
+"#;
+    create_test_file(root_dir, "src/functions.py", python_content);
+}
+
+#[test]
+fn test_query_json_output_rust_functions() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    create_test_directory_structure(&temp_dir);
+
+    // Run the CLI with JSON output format
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "query",
+            "fn $NAME($$$PARAMS) $$$BODY", // Pattern to search for Rust functions
+            temp_dir.path().to_str().unwrap(),
+            "--language",
+            "rust",
+            "--format",
+            "json",
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command succeeded
+    assert!(output.status.success());
+
+    // Convert stdout to string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Extract the JSON part from the output
+    let json_str = extract_json_from_output(&stdout);
+
+    // Parse the JSON output
+    let json_result: Value = serde_json::from_str(json_str).expect("Failed to parse JSON output");
+
+    // Validate the structure of the JSON output
+    assert!(json_result.is_object(), "JSON output should be an object");
+    assert!(
+        json_result.get("results").is_some(),
+        "JSON output should have a 'results' field"
+    );
+    assert!(
+        json_result.get("summary").is_some(),
+        "JSON output should have a 'summary' field"
+    );
+
+    // Validate the results array
+    let results = json_result.get("results").unwrap().as_array().unwrap();
+    assert!(!results.is_empty(), "'results' array should not be empty");
+    assert_eq!(results.len(), 2, "Should find 2 Rust functions");
+
+    // Validate the structure of each result
+    for result in results {
+        assert!(
+            result.get("file").is_some(),
+            "Each result should have a 'file' field"
+        );
+        assert!(
+            result.get("lines").is_some(),
+            "Each result should have a 'lines' field"
+        );
+        assert!(
+            result.get("node_type").is_some(),
+            "Each result should have a 'node_type' field"
+        );
+        assert!(
+            result.get("column_start").is_some(),
+            "Each result should have a 'column_start' field"
+        );
+        assert!(
+            result.get("column_end").is_some(),
+            "Each result should have a 'column_end' field"
+        );
+        assert!(
+            result.get("code").is_some(),
+            "Each result should have a 'code' field"
+        );
+
+        // Check that the code contains function code
+        let code = result.get("code").unwrap().as_str().unwrap();
+        assert!(
+            code.starts_with("fn "),
+            "Function code should start with 'fn '"
+        );
+    }
+
+    // Validate the summary object
+    let summary = json_result.get("summary").unwrap();
+    assert!(summary.is_object(), "'summary' should be an object");
+    assert!(
+        summary.get("count").is_some(),
+        "'summary' should have a 'count' field"
+    );
+    assert!(
+        summary.get("total_bytes").is_some(),
+        "'summary' should have a 'total_bytes' field"
+    );
+    assert!(
+        summary.get("total_tokens").is_some(),
+        "'summary' should have a 'total_tokens' field"
+    );
+
+    // Validate the count matches the number of results
+    let count = summary.get("count").unwrap().as_u64().unwrap();
+    let results_count = results.len() as u64;
+    assert_eq!(
+        count, results_count,
+        "The 'count' in summary should match the number of results"
+    );
+}
+
+#[test]
+fn test_query_json_output_javascript_functions() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    create_test_directory_structure(&temp_dir);
+
+    // Run the CLI with JSON output format
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "query",
+            "function $NAME($$$PARAMS) $$$BODY", // Pattern to search for JavaScript functions
+            temp_dir.path().to_str().unwrap(),
+            "--language",
+            "javascript",
+            "--format",
+            "json",
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command succeeded
+    assert!(output.status.success());
+
+    // Convert stdout to string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Extract the JSON part from the output
+    let json_str = extract_json_from_output(&stdout);
+
+    // Parse the JSON output
+    let json_result: Value = serde_json::from_str(json_str).expect("Failed to parse JSON output");
+
+    // Validate the results array
+    let results = json_result.get("results").unwrap().as_array().unwrap();
+    assert!(!results.is_empty(), "'results' array should not be empty");
+
+    // Check that we found the JavaScript functions
+    let has_greet = results
+        .iter()
+        .any(|r| r.get("code").unwrap().as_str().unwrap().contains("greet"));
+
+    assert!(has_greet, "Should find the 'greet' function");
+}
+
+#[test]
+fn test_query_json_output_with_special_characters() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    create_test_directory_structure(&temp_dir);
+
+    // Run the CLI with JSON output format, searching for the escape function
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "query",
+            "function escapeTest", // Pattern to search for the escape function
+            temp_dir.path().to_str().unwrap(),
+            "--language",
+            "javascript",
+            "--format",
+            "json",
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command succeeded
+    assert!(output.status.success());
+
+    // Convert stdout to string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Extract the JSON part from the output
+    let json_str = extract_json_from_output(&stdout);
+
+    // Parse the JSON output
+    let json_result: Value = serde_json::from_str(json_str).expect("Failed to parse JSON output");
+
+    // Validate the results array
+    let results = json_result.get("results").unwrap().as_array().unwrap();
+    assert!(!results.is_empty(), "'results' array should not be empty");
+
+    // Check that we found the escape function
+    let escape_result = results.iter().find(|r| {
+        r.get("code")
+            .unwrap()
+            .as_str()
+            .unwrap()
+            .contains("escapeTest")
+    });
+
+    assert!(
+        escape_result.is_some(),
+        "Should find the 'escapeTest' function"
+    );
+
+    // Verify that special characters are properly escaped in the JSON
+    let code = escape_result
+        .unwrap()
+        .get("code")
+        .unwrap()
+        .as_str()
+        .unwrap();
+
+    // Print the code content for debugging
+    println!("Code content: {code}");
+
+    // Check for special characters in the function body
+    // The function contains special characters in the string literals
+    assert!(code.contains("&lt;"), "Should contain '&lt;'");
+    assert!(code.contains("&gt;"), "Should contain '&gt;'");
+    assert!(code.contains("&amp;"), "Should contain '&amp;'");
+    assert!(code.contains("&quot;"), "Should contain '&quot;'");
+    assert!(code.contains("&#39;"), "Should contain '&#39;'");
+}
+
+#[test]
+fn test_query_json_output_with_multiple_languages() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    create_test_directory_structure(&temp_dir);
+
+    // Run the CLI with JSON output format, without specifying a language
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "query",
+            "def $NAME($$$PARAMS): $$$BODY", // Pattern to search for Python functions
+            temp_dir.path().to_str().unwrap(),
+            "--language",
+            "python",
+            "--format",
+            "json",
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command succeeded
+    assert!(output.status.success());
+
+    // Convert stdout to string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Extract the JSON part from the output
+    let json_str = extract_json_from_output(&stdout);
+
+    // Parse the JSON output
+    let json_result: Value = serde_json::from_str(json_str).expect("Failed to parse JSON output");
+
+    // Validate the results array
+    let results = json_result.get("results").unwrap().as_array().unwrap();
+    assert!(!results.is_empty(), "'results' array should not be empty");
+
+    // Check that we found Python functions
+    let has_calculate_sum = results.iter().any(|r| {
+        r.get("code")
+            .unwrap()
+            .as_str()
+            .unwrap()
+            .contains("calculate_sum")
+    });
+
+    let has_process_data = results.iter().any(|r| {
+        r.get("code")
+            .unwrap()
+            .as_str()
+            .unwrap()
+            .contains("process_data")
+    });
+
+    assert!(
+        has_calculate_sum,
+        "Should find the 'calculate_sum' function"
+    );
+    assert!(has_process_data, "Should find the 'process_data' function");
+}
+
+#[test]
+fn test_query_json_output_with_no_results() {
+    let temp_dir = TempDir::new().expect("Failed to create temp dir");
+    create_test_directory_structure(&temp_dir);
+
+    // Run the CLI with JSON output format, searching for a pattern that doesn't exist
+    let output = Command::new("cargo")
+        .args([
+            "run",
+            "--",
+            "query",
+            "class $NAME { $$$METHODS }", // Pattern that doesn't match any file
+            temp_dir.path().to_str().unwrap(),
+            "--format",
+            "json",
+        ])
+        .output()
+        .expect("Failed to execute command");
+
+    // Check that the command succeeded
+    assert!(output.status.success());
+
+    // Convert stdout to string
+    let stdout = String::from_utf8_lossy(&output.stdout);
+
+    // Extract the JSON part from the output
+    let json_str = extract_json_from_output(&stdout);
+
+    // Parse the JSON output
+    let json_result: Value = serde_json::from_str(json_str).expect("Failed to parse JSON output");
+
+    // Validate the structure of the JSON output
+    assert!(json_result.is_object(), "JSON output should be an object");
+    assert!(
+        json_result.get("results").is_some(),
+        "JSON output should have a 'results' field"
+    );
+    assert!(
+        json_result.get("summary").is_some(),
+        "JSON output should have a 'summary' field"
+    );
+
+    // Validate the results array is empty
+    let results = json_result.get("results").unwrap().as_array().unwrap();
+    assert!(results.is_empty(), "'results' array should be empty");
+
+    // Validate the summary object
+    let summary = json_result.get("summary").unwrap();
+    assert_eq!(
+        summary.get("count").unwrap().as_u64().unwrap(),
+        0,
+        "'count' should be 0"
+    );
+    assert_eq!(
+        summary.get("total_bytes").unwrap().as_u64().unwrap(),
+        0,
+        "'total_bytes' should be 0"
+    );
+    assert_eq!(
+        summary.get("total_tokens").unwrap().as_u64().unwrap(),
+        0,
+        "'total_tokens' should be 0"
+    );
+}

package/data/probe/tests/query_command_tests.rs

@@ -0,0 +1,232 @@
+use anyhow::Result;
+use probe_code::query::{perform_query, QueryOptions};
+use std::fs;
+use tempfile::tempdir;
+
+#[test]
+fn test_query_rust_function() -> Result<()> {
+    // Create a temporary directory for our test files
+    let temp_dir = tempdir()?;
+    let temp_path = temp_dir.path();
+
+    // Create a test Rust file with a function
+    let rust_file_path = temp_path.join("test_function.rs");
+    let rust_content = r#"
+fn hello_world() {
+    println!("Hello, world!");
+}
+
+fn add(a: i32, b: i32) -> i32 {
+    a + b
+}
+"#;
+    fs::write(&rust_file_path, rust_content)?;
+
+    // Create query options to search for function definitions
+    let options = QueryOptions {
+        path: temp_path,
+        pattern: "fn $NAME($$$PARAMS) $$$BODY",
+        language: Some("rust"),
+        ignore: &[],
+        allow_tests: true,
+        max_results: None,
+        format: "plain",
+        no_gitignore: false,
+    };
+
+    // Perform the query
+    let matches = perform_query(&options)?;
+
+    // Verify that we found both functions
+    assert_eq!(matches.len(), 2);
+
+    // Check that the first match is the hello_world function
+    let hello_match = matches
+        .iter()
+        .find(|m| m.matched_text.contains("hello_world"))
+        .unwrap();
+    assert!(hello_match.matched_text.contains("println!"));
+
+    // Check that the second match is the add function
+    let add_match = matches
+        .iter()
+        .find(|m| m.matched_text.contains("add"))
+        .unwrap();
+    assert!(add_match.matched_text.contains("a + b"));
+
+    Ok(())
+}
+
+#[test]
+fn test_query_javascript_function() -> Result<()> {
+    // Create a temporary directory for our test files
+    let temp_dir = tempdir()?;
+    let temp_path = temp_dir.path();
+
+    // Create a test JavaScript file with a function
+    let js_file_path = temp_path.join("test_function.js");
+    let js_content = r#"
+function greet(name) {
+    return `Hello, ${name}!`;
+}
+
+const multiply = (a, b) => a * b;
+"#;
+    fs::write(&js_file_path, js_content)?;
+
+    // Create query options to search for function declarations
+    let options = QueryOptions {
+        path: temp_path,
+        pattern: "function $NAME($$$PARAMS) $$$BODY",
+        language: Some("javascript"),
+        ignore: &[],
+        allow_tests: true,
+        max_results: None,
+        format: "plain",
+        no_gitignore: false,
+    };
+
+    // Perform the query
+    let matches = perform_query(&options)?;
+
+    // Verify that we found the function declaration (not the arrow function)
+    assert_eq!(matches.len(), 1);
+    assert!(matches[0].matched_text.contains("greet"));
+    assert!(matches[0].matched_text.contains("return"));
+
+    // Now search for arrow functions
+    let arrow_options = QueryOptions {
+        path: temp_path,
+        pattern: "const $NAME = ($$$PARAMS) => $$$BODY",
+        language: Some("javascript"),
+        ignore: &[],
+        allow_tests: true,
+        max_results: None,
+        format: "plain",
+        no_gitignore: false,
+    };
+
+    // Perform the query
+    let arrow_matches = perform_query(&arrow_options)?;
+
+    // Verify that we found the arrow function
+    assert_eq!(arrow_matches.len(), 1);
+    assert!(arrow_matches[0].matched_text.contains("multiply"));
+    assert!(arrow_matches[0].matched_text.contains("a * b"));
+
+    Ok(())
+}
+
+#[test]
+fn test_query_with_max_results() -> Result<()> {
+    // Create a temporary directory for our test files
+    let temp_dir = tempdir()?;
+    let temp_path = temp_dir.path();
+
+    // Create a test Rust file with multiple functions
+    let rust_file_path = temp_path.join("test_multiple.rs");
+    let rust_content = r#"
+fn func1() {}
+fn func2() {}
+fn func3() {}
+fn func4() {}
+fn func5() {}
+"#;
+    fs::write(&rust_file_path, rust_content)?;
+
+    // Create query options with max_results = 3
+    let options = QueryOptions {
+        path: temp_path,
+        pattern: "fn $NAME() {}",
+        language: Some("rust"),
+        ignore: &[],
+        allow_tests: true,
+        max_results: Some(3),
+        format: "plain",
+        no_gitignore: false,
+    };
+
+    // Perform the query
+    let matches = perform_query(&options)?;
+
+    // Verify that we only got 3 matches (due to max_results)
+    assert_eq!(matches.len(), 3);
+
+    Ok(())
+}
+
+#[test]
+fn test_query_ignore_patterns() -> Result<()> {
+    // Create a temporary directory for our test files
+    let temp_dir = tempdir()?;
+    let temp_path = temp_dir.path();
+
+    // Create a test file in the main directory
+    let main_file_path = temp_path.join("main.rs");
+    fs::write(&main_file_path, "fn main() {}")?;
+
+    // Create a test file in a subdirectory that should be ignored
+    let test_dir_path = temp_path.join("test");
+    fs::create_dir(&test_dir_path)?;
+    let test_file_path = test_dir_path.join("test_file.rs");
+    fs::write(&test_file_path, "fn test_function() {}")?;
+
+    // Create query options with ignore patterns
+    let options = QueryOptions {
+        path: temp_path,
+        pattern: "fn $NAME() {}",
+        language: Some("rust"),
+        ignore: &["test".to_string()],
+        allow_tests: false,
+        max_results: None,
+        format: "plain",
+        no_gitignore: false,
+    };
+
+    // Perform the query
+    let matches = perform_query(&options)?;
+
+    // Verify that we only found the main function (test_function was ignored)
+    assert_eq!(matches.len(), 1);
+    assert!(matches[0].matched_text.contains("main"));
+    assert!(!matches[0].matched_text.contains("test_function"));
+
+    Ok(())
+}
+
+#[test]
+fn test_query_with_auto_detect_language() -> Result<()> {
+    // Create a temporary directory for our test files
+    let temp_dir = tempdir()?;
+    let temp_path = temp_dir.path();
+
+    // Create a test Rust file with a function
+    let rust_file_path = temp_path.join("test_auto_detect.rs");
+    let rust_content = r#"
+fn auto_detected_function() {
+    println!("This function should be found with auto-detection");
+}
+"#;
+    fs::write(&rust_file_path, rust_content)?;
+
+    // Create query options without specifying language
+    let options = QueryOptions {
+        path: temp_path,
+        pattern: "fn $NAME($$$PARAMS) $$$BODY",
+        language: None, // No language specified, should auto-detect
+        ignore: &[],
+        allow_tests: true,
+        max_results: None,
+        format: "plain",
+        no_gitignore: false,
+    };
+
+    // Perform the query
+    let matches = perform_query(&options)?;
+
+    // Verify that we found the function through auto-detection
+    assert_eq!(matches.len(), 1);
+    assert!(matches[0].matched_text.contains("auto_detected_function"));
+
+    Ok(())
+}