alistapi 0.1.2

alist api sdk
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

use serde::{Deserialize, Serialize};

pub mod admin;
pub mod auth;
pub mod fs;
pub mod public;

#[derive(Debug, Serialize, Deserialize)]
pub struct Response<Data> {
    code: isize,
    message: String,
    data: Option<Data>,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct NullResponse;

#[cfg(test)]
mod tests {
    const SERVER: &str = "http://127.0.0.1:5244";
    const USERNAME: &str = "admin";
    const PASSWORD: &str = "123456";

    use super::*;

    #[tokio::test]
    async fn test_get_user_info() {
        let token = auth::login(SERVER, USERNAME, PASSWORD).await.unwrap();
        println!("{token}");
        match auth::get_user_info(SERVER, &token).await {
            Ok(user) => {
                println!("{:?}", user);
                assert!(true);
            }
            Err(e) => {
                println!("{e}");
                assert!(false);
            }
        }
    }

    #[tokio::test]
    async fn test_mkdir() {
        let token = auth::login(SERVER, USERNAME, PASSWORD).await.unwrap();
        match fs::mkdir(SERVER, &token, "/cloud/test_mkdir").await {
            Ok(()) => assert!(true),
            Err(e) => {
                println!("{e}");
                assert!(false);
            }
        }
    }

    #[tokio::test]
    async fn test_rename() {
        let token = auth::login(SERVER, USERNAME, PASSWORD).await.unwrap();
        match fs::rename(SERVER, &token, "/cloud/test_mkdir", "test_rename").await {
            Ok(()) => assert!(true),
            Err(e) => {
                println!("{e}");
                assert!(false);
            }
        }
    }

    #[tokio::test]
    async fn test_upload() {
        let token = auth::login(SERVER, USERNAME, PASSWORD).await.unwrap();
        match fs::upload(
            SERVER,
            &token,
            fs::UploadParams {
                local_file: ".gitignore".to_string(),
                remote_path: "/cloud/test_rename".to_string(),
                remote_name: "gitignore.txt".to_string(),
            },
        )
        .await
        {
            Ok(()) => assert!(true),
            Err(e) => {
                println!("{e}");
                assert!(false);
            }
        }
    }

    #[tokio::test]
    async fn test_listdir() {
        let token = auth::login(SERVER, USERNAME, PASSWORD).await.unwrap();
        let mut params = fs::FileParams::default();
        params.path = Some("/cloud/test_rename".to_string());
        match fs::listdir(SERVER, &token, params).await {
            Ok(n) => {
                println!("{:?}", n);
                assert_eq!(n.total, 1);
            }
            Err(e) => {
                println!("{e}");
                assert!(false);
            }
        }
    }
}