foundation_keychain 0.1.2

Bitwarden-compatible vault + SSH key provisioning built on foundation_db and foundation_auth
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

//! Sync vault vertical — integration test (spec-57, F008 Stage 1).
//!
//! Verifies `GET /api/sync` assembles the profile + the user's folders + ciphers
//! into one payload, over a real Turso store.

use std::sync::Arc;

use foundation_core::valtron::{collect_one, execute, from_future, valtron_test};
use foundation_db::core::storage_provider::AsyncQueryStore;
use foundation_db::{StorageBackend, StorageProvider};
use foundation_keychain::core::api::{accounts, ciphers, folders, sync};
use foundation_keychain::core::models::cipher::{CipherCreateRequest, CipherType};
use foundation_keychain::core::models::folder::FolderCreateRequest;
use foundation_keychain::core::models::user::{KdfType, RegisterRequest};
use foundation_keychain::core::store::apply_schema;
use foundation_keychain::KeychainContext;
use tempfile::TempDir;

fn drive<T, F>(future: F) -> T
where
    T: Send + 'static,
    F: std::future::Future<Output = T> + Send + 'static,
{
    let task = from_future(future);
    let stream = execute(task, None).expect("valtron execute");
    collect_one(stream).expect("future produced a result")
}

fn fresh_ctx() -> (KeychainContext, TempDir) {
    let dir = tempfile::tempdir().expect("tempdir");
    let db_path = dir.path().join("keychain_test.db");
    let provider = StorageProvider::new(StorageBackend::Turso {
        url: db_path.to_str().unwrap().to_string(),
    })
    .expect("init turso");
    let db: Arc<dyn AsyncQueryStore> = Arc::new(provider);
    let db_for_schema = Arc::clone(&db);
    drive(async move { apply_schema(db_for_schema.as_ref()).await }).expect("apply schema");
    (KeychainContext::new(db), dir)
}

fn note_cipher(name: &str) -> CipherCreateRequest {
    CipherCreateRequest {
        cipher_type: CipherType::SecureNote,
        name: name.into(),
        notes: Some("2.n|enc".into()),
        fields: None,
        login: None,
        card: None,
        identity: None,
        secure_note: None,
        data: Some("2.d|enc".into()),
        favorite: Some(false),
        organization_id: None,
        collection_ids: None,
    }
}

#[valtron_test]
fn sync_returns_profile_folders_and_ciphers() {
    let (ctx, _dir) = fresh_ctx();

    // Register a user.
    let c = ctx.clone();
    let account = drive(async move {
        accounts::register(
            &c,
            RegisterRequest {
                email: "sync@example.com".into(),
                name: Some("Sync User".into()),
                master_password_hash: "h".into(),
                master_password_hint: None,
                key: Some("2.key|enc".into()),
                kdf: Some(KdfType::Pbkdf2Sha256),
                kdf_iterations: Some(600_000),
                kdf_memory: None,
                kdf_parallelism: None,
            },
        )
        .await
    })
    .expect("register");
    let uid = account.id.clone();

    // Two folders + two ciphers.
    for name in ["Personal", "Work"] {
        let c = ctx.clone();
        let uid = uid.clone();
        drive(async move { folders::create(&c, &uid, FolderCreateRequest { name: name.into() }).await })
            .expect("folder");
    }
    for name in ["2.a|enc", "2.b|enc"] {
        let c = ctx.clone();
        let uid = uid.clone();
        drive(async move { ciphers::create(&c, &uid, note_cipher(name)).await }).expect("cipher");
    }

    // Sync returns everything.
    let c = ctx.clone();
    let uid2 = uid.clone();
    let snapshot = drive(async move { sync::sync(&c, &uid2).await }).expect("sync");

    assert_eq!(snapshot.profile.as_ref().unwrap().email, "sync@example.com");
    assert_eq!(snapshot.folders.len(), 2);
    assert_eq!(snapshot.ciphers.len(), 2);
    assert!(snapshot.sends.is_empty());
    assert!(snapshot.collections.is_empty());
    assert!(snapshot.domains.is_some());
}