Function test_data_driven_match_queries

graphlite/tests/fixture_tests.rs:171–225

()

#[test]
fn test_data_driven_match_queries() {
    let test_suite = TestSuite {
        name: "MATCH Query Tests".to_string(),
        fixture_type: FixtureType::Fraud,
        test_cases: vec![
            TestCase {
                name: "count_all_nodes".to_string(),
                description: "Count all nodes in the graph".to_string(),
                query: "MATCH (n) RETURN count(n) as total".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("total".to_string(), Value::Number(70.0))])), // 50 accounts + 20 merchants
                expected_error: None,
            },
            TestCase {
                name: "count_all_relationships".to_string(),
                description: "Count all relationships in the graph".to_string(),
                query: "MATCH ()-[r]->() RETURN count(r) as total".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("total".to_string(), Value::Number(150.0))])), // 100 transactions + 50 purchases
                expected_error: None,
            },
            TestCase {
                name: "find_accounts_by_status".to_string(),
                description: "Find active accounts (all 50 are active)".to_string(),
                query: "MATCH (a:Account) WHERE a.status = 'active' RETURN count(a) as count"
                    .to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("count".to_string(), Value::Number(50.0))])), // all active
                expected_error: None,
            },
            TestCase {
                name: "retail_merchants".to_string(),
                description: "Find retail merchants (all are retail)".to_string(),
                query: "MATCH (m:Merchant) WHERE m.category = 'retail' RETURN count(m) as count"
                    .to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("count".to_string(), Value::Number(20.0))])), // all retail
                expected_error: None,
            },
            TestCase {
                name: "transaction_count".to_string(),
                description: "Count all transactions".to_string(),
                query: "MATCH ()-[t:Transaction]->() RETURN count(t) as count".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("count".to_string(), Value::Number(100.0))])),
                expected_error: None,
            },
        ],
    };

    let results = test_suite.run().expect("Failed to run test suite");
    results.print_summary();

    assert_eq!(results.failed, 0, "All test cases should pass");
}

#[test]
fn test_data_driven_aggregation_queries() {