relay-knowledge 1.1.17

Graph-database-based knowledge graph project.
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
128
129
130
131
132
133
134
135
136
137
138

use rusqlite::Connection;

use super::*;

#[test]
fn initialize_schema_marks_legacy_software_projection_status_stale() {
    let connection = Connection::open_in_memory().expect("sqlite should open");
    connection
        .execute_batch(
            "
            CREATE TABLE software_global_status (
                source_scope TEXT PRIMARY KEY,
                repository_id TEXT NOT NULL,
                projected_graph_version INTEGER NOT NULL,
                stale INTEGER NOT NULL,
                component_count INTEGER NOT NULL,
                sdk_usage_count INTEGER NOT NULL,
                last_error TEXT
            );
            INSERT INTO software_global_status (
                source_scope, repository_id, projected_graph_version, stale,
                component_count, sdk_usage_count, last_error
            ) VALUES ('scope-legacy', 'repo', 7, 0, 2, 1, NULL);
            ",
        )
        .expect("legacy status should insert");

    initialize_schema(&connection).expect("software schema should initialize");
    let (stale, schema_version, last_error) = connection
        .query_row(
            "SELECT stale, projection_schema_version, last_error
             FROM software_global_status
             WHERE source_scope = 'scope-legacy'",
            [],
            |row| {
                Ok((
                    row.get::<_, bool>(0)?,
                    row.get::<_, i64>(1)?,
                    row.get::<_, Option<String>>(2)?,
                ))
            },
        )
        .expect("status should load");

    assert!(stale);
    assert_eq!(schema_version, SOFTWARE_PROJECTION_SCHEMA_VERSION);
    assert_eq!(
        last_error.as_deref(),
        Some("software global projection schema changed; refresh required")
    );
}

#[test]
fn initialize_schema_invalidates_version_four_locked_component_projection() {
    let connection = Connection::open_in_memory().expect("sqlite should open");
    initialize_schema(&connection).expect("software schema should initialize");
    connection
        .execute(
            "INSERT INTO software_global_status (
                source_scope, repository_id, projected_graph_version, stale,
                component_count, sdk_usage_count, projection_schema_version, last_error
            ) VALUES ('scope-v4', 'repo', 9, 0, 70000, 0, 4, NULL)",
            [],
        )
        .expect("version four status should insert");

    initialize_schema(&connection).expect("software schema migration should rerun safely");
    let (stale, schema_version, last_error) = connection
        .query_row(
            "SELECT stale, projection_schema_version, last_error
             FROM software_global_status
             WHERE source_scope = 'scope-v4'",
            [],
            |row| {
                Ok((
                    row.get::<_, bool>(0)?,
                    row.get::<_, i64>(1)?,
                    row.get::<_, Option<String>>(2)?,
                ))
            },
        )
        .expect("migrated status should load");

    assert!(stale);
    assert_eq!(schema_version, SOFTWARE_PROJECTION_SCHEMA_VERSION);
    assert_eq!(
        last_error.as_deref(),
        Some("software global projection schema changed; refresh required")
    );
}

#[test]
fn initialize_schema_indexes_software_files_by_source_path() {
    let connection = Connection::open_in_memory().expect("sqlite should open");
    initialize_schema(&connection).expect("software schema should initialize");

    let index_sql = connection
        .query_row(
            "
            SELECT sql
            FROM sqlite_master
            WHERE type = 'index'
              AND name = 'software_files_scope_path'
            ",
            [],
            |row| row.get::<_, String>(0),
        )
        .expect("source path index should exist");

    assert!(index_sql.contains("software_files(source_scope, path)"));
}

#[test]
fn initialize_schema_defaults_new_status_rows_to_current_projection_version() {
    let connection = Connection::open_in_memory().expect("sqlite should open");
    initialize_schema(&connection).expect("software schema should initialize");
    connection
        .execute(
            "INSERT INTO software_global_status (
                source_scope, repository_id, projected_graph_version, stale,
                component_count, sdk_usage_count
            ) VALUES ('scope-current', 'repo', 1, 0, 0, 0)",
            [],
        )
        .expect("status should insert with schema default");

    let schema_version = connection
        .query_row(
            "SELECT projection_schema_version
             FROM software_global_status
             WHERE source_scope = 'scope-current'",
            [],
            |row| row.get::<_, i64>(0),
        )
        .expect("projection schema version should load");

    assert_eq!(schema_version, SOFTWARE_PROJECTION_SCHEMA_VERSION);
}