rust-integration-services 0.5.14

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

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::new(config)
        .route("/", async move |_req| {
            HttpResponse::builder().status(200).body_empty().unwrap()
        })
        .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::new(config)
        .route("/", async move |_req| {
            HttpResponse::builder().status(200).body_empty().unwrap()
        })
        .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]
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://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_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.headers().get("key").unwrap(), "value");
    let body = request.body().as_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.headers().get("key").unwrap(), "value");
    let body = response.body().as_bytes().await.unwrap();
    assert_eq!(body, "body");
}