afs 0.2.0

The first choice of fs library, inspired by node:fs
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

use afs::*;

#[tokio::test]
async fn test_read_file() {
    let path = "test_read.txt";
    std::fs::write(path, "Hello, world!").unwrap();

    let result = read_file(path).await.unwrap();
    assert_eq!(result, "Hello, world!");

    std::fs::remove_file(path).unwrap();
}

#[test]
fn test_read_file_sync() {
    let path = "test_read_sync.txt";
    std::fs::write(path, "Hello, sync!").unwrap();

    let result = read_file_sync(path).unwrap();
    assert_eq!(result, "Hello, sync!");

    std::fs::remove_file(path).unwrap();
}

#[tokio::test]
async fn test_read_json() {
    let file_path = "test_read.json";
    let content = r#"{"name": "test", "age": 30}"#;
    tokio::fs::write(file_path, content).await.unwrap();

    let result: serde_json::Value = read_from_json(file_path).await.unwrap();
    assert_eq!(result["name"], "test");
    assert_eq!(result["age"], 30);

    tokio::fs::remove_file(file_path).await.unwrap();
}

#[tokio::test]
async fn test_read_json_value() {
    let file_path = "test_read_value.json";
    let content = r#"{"items": [1, 2, 3]}"#;
    tokio::fs::write(file_path, content).await.unwrap();

    let result = read_json(file_path).await.unwrap();
    assert_eq!(result["items"][0], 1);

    tokio::fs::remove_file(file_path).await.unwrap();
}

#[tokio::test]
async fn test_get_file_size() {
    let path = "test_size.txt";
    std::fs::write(path, "12345").unwrap();

    let size = get_file_size(path).await.unwrap();
    assert_eq!(size, 5);

    std::fs::remove_file(path).unwrap();
}

#[tokio::test]
async fn test_get_dir_size() {
    let dir = "test_dir_size";
    std::fs::create_dir_all(dir).unwrap();
    std::fs::write(format!("{}/a.txt", dir), "123").unwrap();
    std::fs::write(format!("{}/b.txt", dir), "4567").unwrap();

    let size = get_dir_size(dir).await.unwrap();
    assert_eq!(size, 7);

    std::fs::remove_dir_all(dir).unwrap();
}

#[test]
fn test_stat_sync() {
    let path = "test_stat.txt";
    std::fs::write(path, "test").unwrap();

    let metadata = stat_sync(path).unwrap();
    assert!(metadata.is_file());

    std::fs::remove_file(path).unwrap();
}

#[tokio::test]
async fn test_stat() {
    let path = "test_stat_async.txt";
    std::fs::write(path, "test").unwrap();

    let metadata = stat(path).await.unwrap();
    assert!(metadata.is_file());

    std::fs::remove_file(path).unwrap();
}

#[test]
fn test_hash_sync() {
    let path = "test_hash.txt";
    std::fs::write(path, "hello").unwrap();

    let hash_val = hash_sync(path).unwrap();
    assert!(!hash_val.is_empty());
    assert_eq!(hash_val.len(), 64);

    std::fs::remove_file(path).unwrap();
}

#[tokio::test]
async fn test_hash() {
    let path = "test_hash_async.txt";
    std::fs::write(path, "hello").unwrap();

    let hash_result = hash(path).await.unwrap();
    assert!(!hash_result.is_empty());
    assert_eq!(hash_result.len(), 64);

    std::fs::remove_file(path).unwrap();
}

#[tokio::test]
async fn test_diskusage() {
    let usage = diskusage().await;
    assert!(usage.is_ok());
    let used_space = usage.unwrap();
    assert!(used_space > 0.0);
}