yan_net 0.2.1

A simple library for sending HTTP requests and creating HTTP servers
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
128
129
130
131
132
133
134

use std::{
    collections::HashMap,
    sync::{
        Arc,
        atomic::{AtomicBool, Ordering},
    },
};

use serial_test::serial;

use crate::prelude::*;
use yan_json::prelude::*;

#[test]
#[serial]
fn client() {
    let req = RequestBuilder::new()
        .method(HttpMethod::Get)
        .path("/posts/0")
        .header("Host", "json-placeholder.mock.beeceptor.com:80")
        .body_and_auto_content_headers(HttpBody::None)
        .build();

    let res = req.send().unwrap();
    println!("request recieved: {:#?}", res);

    let res_json_expected = json!({
        "userId": 1,
        "id": 0,
        "title": "Introduction to Artificial Intelligence",
        "body": "Learn the basics of Artificial Intelligence and its applications in various industries.",
        "link": "https://example.com/article1",
        "comment_count": 8
    });

    assert_eq!(res.body.as_json(), Some(&res_json_expected));
}

#[test]
#[serial]
fn server() {
    let mut server = Server::new();
    server.map("/api/echo", HttpMethod::Post, |req| {
        let req_json: JsonNode = req.body.try_into().ok()?;
        let req_json_obj = req_json.as_obj()?;
        let data_in = req_json_obj.get("data")?.as_str()?;
        let count = req_json_obj.get("count")?.as_f64()? as usize;
        let buffer = req_json_obj.get("sep")?.as_str()?;

        let data_out: &str = &vec![data_in; count].join(buffer);
        let res_json = json!({
            "result": data_out
        });

        println!("{res_json}");

        Some(
            ResponseBuilder::new()
                .status_ok()
                .body_and_auto_content_headers(HttpBody::Json(res_json))
                .build(),
        )
    });

    let stop_flag = Arc::new(AtomicBool::new(false));
    let handle = server.thread_start_at_port(8000, stop_flag.clone());

    let req = RequestBuilder::new()
        .method(HttpMethod::Post)
        .path("/api/echo")
        .header("Host", "127.0.0.1:8000")
        .body_and_auto_content_headers(HttpBody::Json(json!({
                    "data": "abc",
                    "count": 3,
                    "sep": ":=:"
        })))
        .build();
    let res = req.send().unwrap();
    println!("recieved: {:#?}", res);

    assert_eq!(
        res.body.as_json(),
        Some(&json!({
            "result": "abc:=:abc:=:abc"
        }))
    );

    stop_flag.store(true, Ordering::SeqCst);
    handle.join().unwrap();
}

#[test]
#[serial]
fn server_static() {
    let mut server = Server::new();
    server.mount_static("/files", "static_files/");

    let stop_flag = Arc::new(AtomicBool::new(false));
    let handle = server.thread_start_at_port(8000, stop_flag.clone());

    // build the request
    let req = RequestBuilder::new()
        .method(HttpMethod::Get)
        .path("/files")
        .header("Host", "127.0.0.1:8000")
        .body_and_auto_content_headers(HttpBody::None)
        .build();

    // send the request you just build and save the response
    let res = req.send().unwrap();

    // make sure the response matches index.html in static_files/
    assert_eq!(
        res.body,
        HttpBody::Html(
            r#"<!DOCTYPE html>
<html lang="en">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
</head>
<body>
  <p>This is static_files/index.html</p>
</body>
</html>
"#
            .to_string()
        )
    );

    stop_flag.store(true, Ordering::SeqCst);
    handle.join().unwrap();
}