witmproxy 0.0.2-alpha

A WASM-in-the-middle proxy
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

use anyhow::Result;
use tracing::debug;

use crate::test_utils::{
    EchoResponse, Protocol, create_client, create_html_server, create_json_echo_server,
    create_witmproxy, register_test_component,
};

#[tokio::test]
async fn e2e_simple_json_test() -> Result<()> {
    let _ = tracing_subscriber::fmt()
        .with_env_filter(format!("witmproxy={},{}", "debug", "info"))
        .try_init();
    let (mut proxy, registry, ca, _config, _temp_dir) = create_witmproxy().await?;
    proxy.start().await.unwrap();

    // Register test component, ensure write lock is dropped after use to prevent deadlock
    {
        let mut registry = registry.write().await;
        register_test_component(&mut registry).await.unwrap();
    }

    let target = create_json_echo_server("127.0.0.1", None, ca.clone(), Protocol::Http2).await;
    let client = create_client(
        ca,
        &format!("http://{}", proxy.proxy_listen_addr().unwrap()),
        Protocol::Http2,
    )
    .await;
    let resp = client
        .get(format!(
            "https://127.0.0.1:{}/example",
            target.listen_addr().port()
        ))
        .send()
        .await
        .unwrap();
    let headers = resp.headers().clone();
    let response_text = resp.text().await.unwrap();

    // Try to parse the response as JSON
    let json: EchoResponse = serde_json::from_str(&response_text)
        .map_err(|e| {
            panic!(
                "Failed to parse JSON response: {}. Response body was: '{}'",
                e, response_text
            );
        })
        .unwrap();
    assert_eq!(json.path, "/example");
    assert_eq!(json.method, "GET");

    debug!("Response JSON: {:?}", json);
    // Expect the request header added by the WASM plugin
    assert!(json.headers.contains_key("witmproxy"));
    assert!(json.headers.get("witmproxy").unwrap().contains("req"));
    // Expect the response header added by the WASM plugin
    assert!(headers.contains_key("witmproxy"));
    assert!(
        headers
            .get("witmproxy")
            .unwrap()
            .to_str()
            .unwrap()
            .contains("res")
    );
    Ok(())
}

#[tokio::test]
async fn e2e_simple_html_test() -> Result<()> {
    let _ = tracing_subscriber::fmt()
        .with_env_filter(format!("witmproxy={},{}", "debug", "info"))
        .try_init();
    let (mut proxy, registry, ca, _config, _temp_dir) = create_witmproxy().await?;
    proxy.start().await.unwrap();

    // Register test component, ensure write lock is dropped after use to prevent deadlock
    {
        let mut registry = registry.write().await;
        register_test_component(&mut registry).await.unwrap();
    }

    let target = create_html_server("127.0.0.1", None, ca.clone(), Protocol::Http2).await;
    let client = create_client(
        ca,
        &format!("http://{}", proxy.proxy_listen_addr().unwrap()),
        Protocol::Http2,
    )
    .await;
    let resp = client
        .get(format!(
            "https://127.0.0.1:{}/",
            target.listen_addr().port()
        ))
        .send()
        .await
        .unwrap();
    let response_text = resp.text().await.unwrap();

    // Verify that the original HTML content is still present
    assert!(
        response_text.contains("<h1>Hello from test server</h1>"),
        "Expected original HTML content to be present. Response was: '{}'",
        response_text
    );

    // Verify that the WASM plugin injected the expected comment
    assert!(
        response_text.contains("<!-- Processed by `wasm-test-component` plugin -->"),
        "Expected HTML to contain injected comment. Response was: '{}'",
        response_text
    );

    // Verify the injected comment comes before the DOCTYPE
    let comment_pos = response_text
        .find("<!-- Processed by `wasm-test-component` plugin -->")
        .expect("Comment should be present");
    let doctype_pos = response_text
        .find("<!DOCTYPE html>")
        .expect("DOCTYPE should be present");
    assert!(
        comment_pos < doctype_pos,
        "Expected comment to be prepended before DOCTYPE"
    );

    Ok(())
}