Function test_simple_graph_operations

graphlite/tests/fixture_tests.rs:106–168

()

#[test]
fn test_simple_graph_operations() {
    let fixture = TestFixture::new().expect("Failed to create test fixture");
    // Setup fresh graph for this test to avoid interference
    fixture
        .setup_graph("test_simple_graph_operations")
        .expect("Failed to setup graph");
    // Re-insert simple data since we have a fresh graph
    fixture
        .insert_simple_data()
        .expect("Failed to insert simple data");

    // Test basic counts
    fixture.assert_first_value(
        "MATCH (n:TestNode) RETURN count(n) as node_count",
        "node_count",
        Value::Number(20.0),
    );

    fixture.assert_first_value(
        "MATCH ()-[e:CONNECTS_TO]->() RETURN count(e) as edge_count",
        "edge_count",
        Value::Number(9.0), // Creates edges from 1->2, 2->3, ..., 9->10
    );

    // Test property queries with exact values
    // From fixture: value = i * 10 (10, 20, 30, ..., 200)
    fixture.assert_first_value(
        "MATCH (n:TestNode) WHERE n.value > 100 RETURN count(n) as count",
        "count",
        Value::Number(10.0), // Nodes 11-20 have values 110-200
    );

    // Test aggregate statistics on simple graph
    let expected_stats = AggregateStats {
        count: 20.0,
        sum: 2100.0, // Sum of 10,20,30...200 = 10*(1+2+...+20) = 10*210 = 2100
        avg: 105.0,  // Average = 2100/20 = 105
        min: 10.0,
        max: 200.0,
    };

    let stats = fixture.assert_aggregates(
        "MATCH (n:TestNode)
         RETURN count(n.value) as count,
                sum(n.value) as sum,
                avg(n.value) as avg,
                min(n.value) as min,
                max(n.value) as max",
        expected_stats,
    );

    assert_eq!(stats.count, 20.0);
    assert_eq!(stats.sum, 2100.0);
    assert_eq!(stats.avg, 105.0);
    assert_eq!(stats.min, 10.0); // Minimum value is 10 (node 1)
    assert_eq!(stats.max, 200.0); // Maximum value is 200 (node 20)

    // Test path traversal (simplified - path assignment may not be supported)