rust-integration-services 0.5.26

A modern, fast, and lightweight integration library written in Rust, designed for memory safety and stability.
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
135
136

use std::{env::home_dir, time::Duration};

use crate::http::{client::http_client::HttpClient, http_request::HttpRequest, http_response::HttpResponse, server::{http_server::{HttpServer}, http_server_config::HttpServerConfig}};

#[tokio::test(start_paused = true)]
async fn http_server_client() {
    tracing_subscriber::fmt().init();
    tokio::spawn(async move {
        let config = HttpServerConfig::new("127.0.0.1", 8080);
        HttpServer::builder(config)
        .route("/", async move |_| {
            HttpResponse::builder().status(200).body_empty().unwrap()
        })
        .build()
        .run()
        .await;
    });

    tokio::time::advance(Duration::from_millis(1000)).await;
    let request = HttpRequest::builder().get("http://127.0.0.1:8080").body_empty().unwrap();
    let result = HttpClient::new().send(request).await;
    assert!(result.is_ok());

    let response = result.unwrap();
    tracing::info!(?response);
    assert_eq!(response.status(), 200);
}

/// Create your own certs for testing.
/// 
/// mkcert -install
/// mkcert -cert-file server.pem -key-file server-key.pem localhost 127.0.0.1
#[tokio::test(start_paused = true)]
async fn http_server_client_tls() {
    tracing_subscriber::fmt().init();
    tokio::spawn(async move {
        let server_cert_path = home_dir().unwrap().join("server.pem");
        let server_key_path = home_dir().unwrap().join("server-key.pem");

        let config = HttpServerConfig::new("127.0.0.1", 8080).tls(server_cert_path, server_key_path);
        HttpServer::builder(config)
        .route("/", async move |_req| {
            HttpResponse::builder().status(200).body_empty().unwrap()
        })
        .build()
        .run()
        .await;
    });

    tokio::time::advance(Duration::from_millis(1000)).await;
    let request = HttpRequest::builder().get("https://127.0.0.1:8080").body_empty().unwrap();
    let result = HttpClient::new().send(request).await;
    assert!(result.is_ok());
    
    let response = result.unwrap();
    tracing::info!(?response);
    assert_eq!(response.status(), 200);
}

#[tokio::test(start_paused = true)]
async fn http_server_middleware() {
    tracing_subscriber::fmt().init();
    tokio::spawn(async move {
        let config = HttpServerConfig::new("127.0.0.1", 8080);
        HttpServer::builder(config)
        .route("/", async move |_req| {
            tracing::info!("route");
            HttpResponse::builder().status(200).body_empty().unwrap()
        })
        .before(async move |_| {
            tracing::info!("before");
            HttpResponse::builder().status(400).body_empty().unwrap()
        })
        .before(async move |request| {
            tracing::info!("before 2");
            assert!(false);
            request
        })
        .after(async move |response| {
            tracing::info!("after");
            response
        })
        .build()
        .run()
        .await;
    });

    tokio::time::advance(Duration::from_millis(1000)).await;
    let request = HttpRequest::builder().get("http://127.0.0.1:8080").body_empty().unwrap();
    let result = HttpClient::new().send(request).await;
    assert!(result.is_ok());

    let response = result.unwrap();
    tracing::info!(?response);
    assert_eq!(response.status(), 400);
}

#[tokio::test]
async fn http_client() {
    tracing_subscriber::fmt().init();
    let request = HttpRequest::builder().get("http://httpbin.org/get").body_empty().unwrap();
    let result = HttpClient::new().send(request).await;
    assert!(result.is_ok());

    let response = result.unwrap();
    tracing::info!(?response);
}

#[tokio::test]
async fn http_client_tls() {
    tracing_subscriber::fmt().init();
    let request = HttpRequest::builder().get("https://api.open-meteo.com/v1/forecast?latitude=59.33&longitude=18.07&current_weather=true").body_empty().unwrap();
    let result = HttpClient::new().send(request).await;
    assert!(result.is_ok());

    let response = result.unwrap();
    tracing::info!(?response);
}

#[tokio::test]
async fn http_request() {
    let request = HttpRequest::builder().get("https://127.0.0.1").header("key", "value").body_bytes("body").unwrap();
    assert_eq!(request.method(), "GET");
    assert_eq!(request.header("key").unwrap(), "value");
    let body = request.body().to_bytes().await.unwrap();
    assert_eq!(body, "body");
}

#[tokio::test]
async fn http_response() {
    let response = HttpResponse::builder().status(200).header("key", "value").body_bytes("body").unwrap();
    assert_eq!(response.status(), 200);
    assert_eq!(response.header("key").unwrap(), "value");
    let body = response.body().to_bytes().await.unwrap();
    assert_eq!(body, "body");
}