Function test_pattern_data_driven_cases

graphlite/tests/pattern_tests.rs:308–376

()

#[test]
fn test_pattern_data_driven_cases() {
    let test_suite = TestSuite {
        name: "Pattern Matching Test Suite".to_string(),
        fixture_type: FixtureType::Fraud,
        test_cases: vec![
            // Basic pattern tests
            TestCase {
                name: "simple_node_pattern".to_string(),
                description: "Match simple node pattern".to_string(),
                query: "MATCH (n) RETURN count(n) as total_nodes".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("total_nodes".to_string(), Value::Number(70.0))])),
                expected_error: None,
            },
            TestCase {
                name: "labeled_node_pattern".to_string(),
                description: "Match labeled node pattern".to_string(),
                query: "MATCH (a:Account) RETURN count(a) as accounts".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("accounts".to_string(), Value::Number(50.0))])),
                expected_error: None,
            },
            TestCase {
                name: "relationship_pattern".to_string(),
                description: "Match relationship pattern".to_string(),
                query: "MATCH ()-[r:Transaction]->() RETURN count(r) as transactions".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("transactions".to_string(), Value::Number(100.0))])),
                expected_error: None,
            },
            // Complex pattern tests
            TestCase {
                name: "multi_hop_pattern".to_string(),
                description: "Match multi-hop pattern".to_string(),
                query: "MATCH (a1:Account)-[:Transaction]->(m:Merchant)<-[:Transaction]-(a2:Account) WHERE a1 <> a2 RETURN count(*) as shared_merchants".to_string(),
                expected_rows: Some(1),
                expected_values: None,
                expected_error: None,
            },
            TestCase {
                name: "optional_pattern".to_string(),
                description: "Match with optional pattern".to_string(),
                query: "MATCH (a:Account) RETURN count(DISTINCT a) as all_accounts".to_string(),
                expected_rows: Some(1),
                expected_values: Some(HashMap::from([("all_accounts".to_string(), Value::Number(50.0))])),
                expected_error: None,
            },
            // Variable length patterns
            TestCase {
                name: "variable_length_pattern".to_string(),
                description: "Match variable length pattern".to_string(),
                query: "MATCH path = ()-[:Transaction|Purchase]->{1,2}() RETURN count(path) as paths LIMIT 1000".to_string(),
                expected_rows: Some(1),
                expected_values: None,
                expected_error: None,
            },
        ],
    };