graphlite 0.0.1

GraphLite - A lightweight ISO GQL Graph Database
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

// Test to verify that duplicate edge insertion produces a warning
// This test verifies the fix for: https://github.com/GraphLite-AI/GraphLite/issues/XXX

#![allow(unused_variables)]

#[path = "testutils/mod.rs"]
mod testutils;

use testutils::test_fixture::TestFixture;

#[test]
fn test_duplicate_edge_shows_warning() {
    // Create a fresh test fixture
    let fixture = TestFixture::new().expect("Failed to create fixture");

    // Setup graph context
    fixture
        .setup_graph("duplicate_edge_test")
        .expect("Failed to setup graph");

    // Setup: Create two people
    fixture
        .query("INSERT (:Person {name: 'Charlie'}), (:Person {name: 'Diana'})")
        .expect("Node creation should succeed");

    // First edge insertion - should succeed without warnings
    let result1 = fixture
        .query(
            "MATCH (c:Person {name: 'Charlie'}), (d:Person {name: 'Diana'})
         INSERT (c)-[:KNOWS {since: 2021, strength: 'weak'}]->(d)",
        )
        .expect("First edge insertion should succeed");

    assert_eq!(
        result1.rows_affected, 1,
        "First insertion should affect 1 row"
    );
    assert!(
        result1.warnings.is_empty(),
        "First insertion should have no warnings"
    );

    // Second edge insertion - should detect duplicate and show warning
    let result2 = fixture
        .query(
            "MATCH (c:Person {name: 'Charlie'}), (d:Person {name: 'Diana'})
         INSERT (c)-[:KNOWS {since: 2021, strength: 'weak'}]->(d)",
        )
        .expect("Second edge insertion should succeed (but skip duplicate)");

    // Verify warning exists
    assert!(
        !result2.warnings.is_empty(),
        "Expected warning for duplicate edge insertion"
    );

    assert!(
        result2.warnings[0].contains("Duplicate edge detected"),
        "Warning should mention 'Duplicate edge detected', got: {}",
        result2.warnings[0]
    );

    // Verify rows_affected is 0 for duplicate insert
    assert_eq!(
        result2.rows_affected, 0,
        "Duplicate edge insertion should not affect any rows"
    );

    // Verify only one edge exists
    let count_result = fixture
        .query("MATCH ()-[r:KNOWS]->() RETURN COUNT(r) AS edge_count")
        .expect("Count query should succeed");

    let edge_count = count_result.rows[0].values["edge_count"]
        .as_number()
        .expect("Should get a number");

    assert_eq!(
        edge_count, 1.0,
        "Should have exactly 1 edge after duplicate insertion attempt, found: {}",
        edge_count
    );
}

#[test]
fn test_duplicate_edge_with_regular_insert() {
    // Test that duplicate edge detection works with inline node creation
    let fixture = TestFixture::new().expect("Failed to create fixture");

    // Setup graph context
    fixture
        .setup_graph("regular_insert_test")
        .expect("Failed to setup graph");

    // First insertion with inline nodes - should succeed
    let result1 = fixture
        .query("INSERT (:User {id: 'u1'})-[:FOLLOWS {since: '2020-01-01'}]->(:User {id: 'u2'})")
        .expect("First insertion should succeed");

    assert!(result1.rows_affected >= 1, "Should create nodes and edge");
    assert!(result1.warnings.is_empty());

    // Second insertion - nodes already exist, so only edge insertion is attempted
    // Since nodes are duplicates, they won't be re-created, but we'll try to create the edge again
    let result2 = fixture
        .query("INSERT (:User {id: 'u1'})-[:FOLLOWS {since: '2020-01-01'}]->(:User {id: 'u2'})")
        .expect("Second insertion should succeed");

    // Should have warnings - at minimum for duplicate nodes
    // Edge warning appears only if nodes already existed and edge is duplicate
    assert!(
        !result2.warnings.is_empty(),
        "Should have warnings for duplicates"
    );

    // Verify we have node duplicate warnings
    let has_node_warnings = result2
        .warnings
        .iter()
        .any(|w| w.contains("Duplicate node detected"));

    assert!(
        has_node_warnings,
        "Should have 'Duplicate node detected' warnings, got: {:?}",
        result2.warnings
    );
}