witmproxy 0.0.1-alpha

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

mod tests {
    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(())
    }
}