fslite-sqlite 0.1.0

A transport-independent, async virtual filesystem with a SQLite-backed persistent backend, HTTP adapter, and CLI.
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

use fslite_core::{ErrorCode, NodeKind, RequestContext, VirtualPath};
use fslite_sqlite::SqliteFileSystem;

#[tokio::test]
async fn creates_root_and_reopens_workspace() {
    let file = tempfile::NamedTempFile::new().unwrap();
    let fs = SqliteFileSystem::open(file.path(), Default::default())
        .await
        .unwrap();
    let workspace = fs.create_workspace(Default::default()).await.unwrap();
    drop(fs);

    let reopened = SqliteFileSystem::open(file.path(), Default::default())
        .await
        .unwrap();
    let ctx = RequestContext::trusted(workspace.id);
    let root = reopened
        .stat(&ctx, &VirtualPath::root(), Default::default())
        .await
        .unwrap();
    assert_eq!(root.kind, NodeKind::Directory);
}

#[tokio::test]
async fn one_workspace_cannot_observe_another_root_child() {
    let fs = SqliteFileSystem::open_in_memory(Default::default())
        .await
        .unwrap();
    let first = fs.create_workspace(Default::default()).await.unwrap();
    let second = fs.create_workspace(Default::default()).await.unwrap();
    let first_ctx = RequestContext::trusted(first.id);
    let second_ctx = RequestContext::trusted(second.id);
    fs.mkdir(
        &first_ctx,
        &VirtualPath::parse("/private").unwrap(),
        Default::default(),
    )
    .await
    .unwrap();
    let error = fs
        .stat(
            &second_ctx,
            &VirtualPath::parse("/private").unwrap(),
            Default::default(),
        )
        .await
        .unwrap_err();
    assert_eq!(error.code(), ErrorCode::NotFound);
}

#[tokio::test]
async fn reopening_a_database_is_idempotent() {
    let file = tempfile::NamedTempFile::new().unwrap();
    let fs = SqliteFileSystem::open(file.path(), Default::default())
        .await
        .unwrap();
    let workspace = fs.create_workspace(Default::default()).await.unwrap();
    drop(fs);

    for _ in 0..3 {
        let reopened = SqliteFileSystem::open(file.path(), Default::default())
            .await
            .unwrap();
        let ctx = RequestContext::trusted(workspace.id);
        reopened
            .stat(&ctx, &VirtualPath::root(), Default::default())
            .await
            .unwrap();
    }
}

#[tokio::test]
async fn deleted_workspace_is_no_longer_visible() {
    let fs = SqliteFileSystem::open_in_memory(Default::default())
        .await
        .unwrap();
    let workspace = fs.create_workspace(Default::default()).await.unwrap();
    let ctx = RequestContext::trusted(workspace.id);
    fs.delete_workspace(workspace.id).await.unwrap();

    let error = fs
        .stat(&ctx, &VirtualPath::root(), Default::default())
        .await
        .unwrap_err();
    assert_eq!(error.code(), ErrorCode::NotFound);
}

#[tokio::test]
async fn workspace_usage_reports_active_nodes() {
    let fs = SqliteFileSystem::open_in_memory(Default::default())
        .await
        .unwrap();
    let workspace = fs.create_workspace(Default::default()).await.unwrap();
    let ctx = RequestContext::trusted(workspace.id);
    fs.mkdir(
        &ctx,
        &VirtualPath::parse("/docs").unwrap(),
        Default::default(),
    )
    .await
    .unwrap();

    let usage = fs.workspace_usage(&ctx).await.unwrap();
    assert_eq!(usage.active_nodes, 2);
    assert_eq!(usage.trashed_nodes, 0);
}