docbox-database 0.11.1

Docbox database structures, logic, and migrations
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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use chrono::{Days, Utc};
use docbox_database::models::tasks::{Task, TaskStatus};
use uuid::Uuid;

use crate::common::{database::test_tenant_db, make_test_document_box};

mod common;

/// Tests a task can be created
#[tokio::test]
async fn test_task_create() {
    let (db, _db_container) = test_tenant_db().await;
    let (document_box, _root) = make_test_document_box(&db, "test", None).await;

    let task = Task::create(&db, document_box.scope.clone()).await.unwrap();
    assert_eq!(task.status, TaskStatus::Pending);
    assert_eq!(task.output_data, None);
    assert_eq!(task.completed_at, None);
}

/// Tests that a task should not be able to be created in a document box that
/// does not exist
#[tokio::test]
async fn test_task_create_with_unknown_document_box() {
    let (db, _db_container) = test_tenant_db().await;
    let err = Task::create(&db, "unknown".to_string()).await.unwrap_err();

    // Shouldn't be able to create a task where the document box doesn't match
    assert!(
        err.into_database_error()
            .unwrap()
            .is_foreign_key_violation()
    );
}

/// Tests that deleting a document box will cascade and delete tasks within
#[tokio::test]
async fn test_task_cascade_delete() {
    let (db, _db_container) = test_tenant_db().await;
    let (document_box, root) = make_test_document_box(&db, "test", None).await;

    // Must delete the root folder to delete the document box
    root.delete(&db).await.unwrap();

    let task = Task::create(&db, document_box.scope.clone()).await.unwrap();
    document_box.delete(&db).await.unwrap();

    // Task should not exist after document box deletion
    let task = Task::find(&db, task.id, &document_box.scope).await.unwrap();
    assert!(task.is_none());
}

/// Tests that a task can be found by ID
#[tokio::test]
async fn test_task_find_by_id() {
    let (db, _db_container) = test_tenant_db().await;
    let (document_box, _root) = make_test_document_box(&db, "test", None).await;

    let task = Task::create(&db, document_box.scope.clone()).await.unwrap();
    let found_task = Task::find(&db, task.id, &document_box.scope)
        .await
        .unwrap()
        .expect("task should exist");

    assert_eq!(task, found_task);

    let found_task = Task::find(&db, task.id, "unknown").await.unwrap();
    assert!(found_task.is_none());

    let found_task = Task::find(&db, Uuid::nil(), &document_box.scope)
        .await
        .unwrap();
    assert!(found_task.is_none());
}

/// Tests that a task can be completed
#[tokio::test]
async fn test_task_complete() {
    let (db, _db_container) = test_tenant_db().await;
    let (document_box, _root) = make_test_document_box(&db, "test", None).await;

    let mut task = Task::create(&db, document_box.scope.clone()).await.unwrap();
    assert_eq!(task.status, TaskStatus::Pending);
    assert_eq!(task.output_data, None);
    assert_eq!(task.completed_at, None);

    task.complete_task(&db, TaskStatus::Failed, None)
        .await
        .unwrap();

    assert_eq!(task.status, TaskStatus::Failed);
    assert_eq!(task.output_data, None);
    assert!(task.completed_at.is_some());

    let test_output_value = serde_json::json!({
        "test": true
    });

    task.complete_task(&db, TaskStatus::Failed, Some(test_output_value.clone()))
        .await
        .unwrap();

    assert_eq!(task.status, TaskStatus::Failed);
    assert_eq!(task.output_data, Some(test_output_value.clone()));
    assert!(task.completed_at.is_some());

    let found_task = Task::find(&db, task.id, &document_box.scope)
        .await
        .unwrap()
        .expect("task should exist");
    assert_eq!(task, found_task);

    task.complete_task(&db, TaskStatus::Completed, Some(test_output_value.clone()))
        .await
        .unwrap();

    assert_eq!(task.status, TaskStatus::Completed);
    assert_eq!(task.output_data, Some(test_output_value.clone()));
    assert!(task.completed_at.is_some());

    let found_task = Task::find(&db, task.id, &document_box.scope)
        .await
        .unwrap()
        .expect("task should exist");
    assert_eq!(task, found_task);
}

/// Tests that expired tasks are deleted correctly
#[tokio::test]
async fn test_task_delete_expired() {
    let (db, _db_container) = test_tenant_db().await;
    let (document_box, _root) = make_test_document_box(&db, "test", None).await;
    let task = Task::create(&db, document_box.scope.clone()).await.unwrap();

    // Deleting in the future should delete our task
    Task::delete_expired(&db, Utc::now().checked_add_days(Days::new(1)).unwrap())
        .await
        .unwrap();

    let found_task = Task::find(&db, task.id, &document_box.scope).await.unwrap();
    assert!(found_task.is_none());

    let task = Task::create(&db, document_box.scope.clone()).await.unwrap();

    // Deleting in the past should not delete our task
    Task::delete_expired(&db, Utc::now().checked_sub_days(Days::new(1)).unwrap())
        .await
        .unwrap();

    let found_task = Task::find(&db, task.id, &document_box.scope)
        .await
        .unwrap()
        .expect("task should exist");
    assert_eq!(found_task, task);
}