jax-common 0.1.11

Core data structures and cryptography for JaxBucket - end-to-end encrypted P2P storage
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

//! Integration tests for Mount add and cat operations

mod common;

use std::io::Cursor;
use std::path::PathBuf;

#[tokio::test]
async fn test_add_and_cat() {
    let (mut mount, _, _, _temp) = common::setup_test_env().await;

    let data = b"Hello, world!";
    let path = PathBuf::from("/test.txt");

    mount.add(&path, Cursor::new(data.to_vec())).await.unwrap();

    let result = mount.cat(&path).await.unwrap();
    assert_eq!(result, data);
}

#[tokio::test]
async fn test_add_with_metadata() {
    let (mut mount, _, _, _temp) = common::setup_test_env().await;

    let data = b"{ \"key\": \"value\" }";
    let path = PathBuf::from("/data.json");

    mount.add(&path, Cursor::new(data.to_vec())).await.unwrap();

    let items = mount.ls(&PathBuf::from("/")).await.unwrap();
    assert_eq!(items.len(), 1);

    let (file_path, link) = items.iter().next().unwrap();
    assert_eq!(file_path, &PathBuf::from("data.json"));

    if let Some(data_info) = link.data() {
        assert!(data_info.mime().is_some());
        assert_eq!(data_info.mime().unwrap().as_ref(), "application/json");
    } else {
        panic!("Expected data link with metadata");
    }
}

#[tokio::test]
async fn test_various_file_types() {
    let (mut mount, _, _, _temp) = common::setup_test_env().await;

    let test_files = vec![
        ("/image.png", "image/png"),
        ("/video.mp4", "video/mp4"),
        ("/style.css", "text/css"),
        ("/script.js", "text/javascript"),
        ("/data.json", "application/json"),
        ("/archive.zip", "application/zip"),
        ("/document.pdf", "application/pdf"),
        ("/code.rs", "text/x-rust"),
    ];

    for (path, expected_mime) in test_files {
        mount
            .add(&PathBuf::from(path), Cursor::new(b"test".to_vec()))
            .await
            .unwrap();

        let items = mount.ls(&PathBuf::from("/")).await.unwrap();
        let link = items.values().find(|l| l.is_data()).unwrap();

        if let Some(data_info) = link.data() {
            assert!(data_info.mime().is_some());
            assert_eq!(data_info.mime().unwrap().as_ref(), expected_mime);
        }

        mount.rm(&PathBuf::from(path)).await.unwrap();
    }
}

#[tokio::test]
async fn test_nested_operations() {
    let (mut mount, _, _, _temp) = common::setup_test_env().await;

    let files = vec![
        ("/root.txt", b"root" as &[u8]),
        ("/docs/readme.md", b"readme" as &[u8]),
        ("/docs/guide.pdf", b"guide" as &[u8]),
        ("/src/main.rs", b"main" as &[u8]),
        ("/src/lib.rs", b"lib" as &[u8]),
        ("/src/tests/unit.rs", b"unit" as &[u8]),
        ("/src/tests/integration.rs", b"integration" as &[u8]),
    ];

    for (path, data) in &files {
        mount
            .add(&PathBuf::from(path), Cursor::new(data.to_vec()))
            .await
            .unwrap();
    }

    for (path, expected_data) in &files {
        let data = mount.cat(&PathBuf::from(path)).await.unwrap();
        assert_eq!(data, expected_data.to_vec());
    }

    mount
        .rm(&PathBuf::from("/src/tests/unit.rs"))
        .await
        .unwrap();

    let result = mount.cat(&PathBuf::from("/src/tests/unit.rs")).await;
    assert!(result.is_err());

    let data = mount
        .cat(&PathBuf::from("/src/tests/integration.rs"))
        .await
        .unwrap();
    assert_eq!(data, b"integration");
}