real-time-sqlx 0.1.1

Real-time SQLx backend for Tauri
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

//! Serialized operations tests

use std::{fs, path::Path};

use crate::database::sqlite::granular_operation_sqlite;
use crate::operations::serialize::{GranularOperation, OperationNotification};
use crate::tests::dummy::{dummy_sqlite_database, prepare_dummy_sqlite_database};

use super::dummy::Todo;
use super::utils::read_serialized_operation;

#[tokio::test]
async fn test_deserialize_operations() {
    // Get the operations
    let operations_path = Path::new("src/tests/operations");

    for entry in fs::read_dir(operations_path).unwrap() {
        let entry = entry.unwrap();

        let serialized_operation = fs::read_to_string(entry.path()).unwrap();

        // Deserialize the query from json
        let query: serde_json::Value = serde_json::from_str(&serialized_operation).unwrap();
        serde_json::from_value::<GranularOperation>(query).expect(&format!(
            "Failed to deserialize operation: {}",
            entry.file_name().into_string().unwrap()
        ));
    }
}

// ************************************************************************* //
//                     TESTING AGAINST SQLITE BACKEND                        //
// ************************************************************************* //

/// Test single row creation
#[tokio::test]
async fn test_sqlite_create() {
    let pool = dummy_sqlite_database().await;
    prepare_dummy_sqlite_database(&pool).await;

    let operation = read_serialized_operation("01_create.json");
    let result = granular_operation_sqlite(operation, &pool).await;

    assert!(result.is_some());
    let result: OperationNotification<Todo> = result.unwrap();

    match result {
        OperationNotification::Create { table: _, data } => {
            assert_eq!(data.id, 4);
            assert_eq!(data.title, "Fourth todo");
            assert_eq!(data.content, "This is the fourth todo");
        }
        _ => panic!("Expected a create operation"),
    }
}

/// Test multiple row creation
#[tokio::test]
async fn test_sqlite_create_many() {
    let pool = dummy_sqlite_database().await;
    prepare_dummy_sqlite_database(&pool).await;

    let operation = read_serialized_operation("02_create_many.json");
    let result = granular_operation_sqlite(operation, &pool).await;

    assert!(result.is_some());
    let result: OperationNotification<Todo> = result.unwrap();

    match result {
        OperationNotification::CreateMany { table: _, data } => {
            assert_eq!(data.len(), 2);

            let first_data = &data[0];
            assert_eq!(first_data.id, 4);
            assert_eq!(first_data.title, "Fourth todo");
            assert_eq!(first_data.content, "This is the fourth todo");

            let second_data = &data[1];
            assert_eq!(second_data.id, 5);
            assert_eq!(second_data.title, "Fifth todo");
            assert_eq!(second_data.content, "This is the fifth todo");
        }
        _ => panic!("Expected a create many operation"),
    }
}

/// Test single row update
#[tokio::test]
async fn test_sqlite_update() {
    let pool = dummy_sqlite_database().await;
    prepare_dummy_sqlite_database(&pool).await;

    let operation = read_serialized_operation("03_update.json");
    let result = granular_operation_sqlite(operation, &pool).await;

    assert!(result.is_some());
    let result: OperationNotification<Todo> = result.unwrap();

    match result {
        OperationNotification::Update {
            table: _,
            id: _,
            data,
        } => {
            assert_eq!(data.id, 3);
            assert_eq!(data.title, "Updated todo");
            assert_eq!(data.content, "This todo was updated");
        }
        _ => panic!("Expected an update operation"),
    }
}

/// Test single row deletion
#[tokio::test]
async fn test_sqlite_delete() {
    let pool = dummy_sqlite_database().await;
    prepare_dummy_sqlite_database(&pool).await;

    let operation = read_serialized_operation("04_delete.json");
    let result = granular_operation_sqlite(operation, &pool).await;

    assert!(result.is_some());
    let result: OperationNotification<Todo> = result.unwrap();

    match result {
        OperationNotification::Delete { .. } => {
            // Nothing to check here. The operation is not None, meaning 1 row ws affected
        }
        _ => panic!("Expected a delete operation"),
    }
}