chore: integration test modified to use simple streaming example component

Signed-off-by: Aditya <aditya.salunkh919@gmail.com>

Author: Aditya1404Sal

crates/wash-runtime/tests/fixtures/http_ai_proxy.wasm

@@ -1,4 +1,11 @@
-//! Integration test for streaming Gemini proxy component
+//! Integration test for HTTP streaming component
+//!
+//! This test demonstrates:
+//! 1. Starting a host with HTTP and logging plugins
+//! 2. Creating and starting a workload that streams data at fixed intervals
+//! 3. Verifying that exactly 20 chunks are received
+//! 4. Validating total streaming duration is approximately 10 seconds
+//! 5. Asserting each chunk arrives at ~0.5 second intervals
 
 use anyhow::Result;
 use futures::stream;
@@ -24,12 +31,12 @@ use wash_runtime::{
     types::{Component, LocalResources, Workload, WorkloadStartRequest},
     wit::WitInterface,
 };
-
-const HTTP_STREAMING_GEMINI_WASM: &[u8] = include_bytes!("./fixtures/http_ai_proxy.wasm");
+// The component we built just now
+const HTTP_STREAMING_WASM: &[u8] = include_bytes!("./fixtures/http_streaming.wasm");
 
 #[test_log::test(tokio::test)]
-async fn wasi_http_gemini_proxy() -> Result<()> {
-    println!("\n🚀 STREAMING GEMINI PROXY TEST\n");
+async fn wasi_http_stream_random_chunks() -> Result<()> {
+    println!("\n🚀 STREAMING RANDOM CHUNKS TEST\n");
 
     let engine = Engine::builder().build()?;
     let port = find_available_port().await?;
@@ -51,15 +58,12 @@ async fn wasi_http_gemini_proxy() -> Result<()> {
         workload_id: uuid::Uuid::new_v4().to_string(),
         workload: Workload {
             namespace: "test".to_string(),
-            name: "gemini-proxy".to_string(),
+            name: "random-streamer".to_string(),
             annotations: HashMap::new(),
             service: None,
             components: vec![Component {
-                bytes: bytes::Bytes::from_static(HTTP_STREAMING_GEMINI_WASM),
-                local_resources: LocalResources {
-                    allowed_hosts: vec!["generativelanguage.googleapis.com".to_string()],
-                    ..Default::default()
-                },
+                bytes: bytes::Bytes::from_static(HTTP_STREAMING_WASM),
+                local_resources: LocalResources::default(),
                 pool_size: 1,
                 max_invocations: 100,
             }],
@@ -71,7 +75,7 @@ async fn wasi_http_gemini_proxy() -> Result<()> {
                     version: Some(semver::Version::parse("0.2.2").unwrap()),
                     config: {
                         let mut config = HashMap::new();
-                        config.insert("host".to_string(), "gemini-proxy".to_string());
+                        config.insert("host".to_string(), "random-streamer".to_string());
                         config
                     },
                 },
@@ -90,8 +94,7 @@ async fn wasi_http_gemini_proxy() -> Result<()> {
     host.workload_start(req).await?;
     println!("✓ Workload deployed\n");
 
-    let prompt = "Explain how AI works";
-    let body_stream = stream::iter([Ok::<_, hyper::Error>(Frame::data(Bytes::from(prompt)))]);
+    let body_stream = stream::iter([Ok::<_, hyper::Error>(Frame::data(Bytes::from("")))]);
 
     // Create HTTP client first
     let stream = tokio::net::TcpStream::connect(addr).await?;
@@ -111,13 +114,13 @@ async fn wasi_http_gemini_proxy() -> Result<()> {
     // Build request with relative URI but explicit Host header
     let mut request = hyper::Request::builder()
         .method(hyper::Method::POST)
-        .uri("/gemini-proxy")
+        .uri("/stream-random")
         .header("content-type", "text/plain")
         .body(BoxBody::new(StreamBody::new(body_stream)))?;
 
     request.headers_mut().insert(
         hyper::header::HOST,
-        hyper::header::HeaderValue::from_static("gemini-proxy"),
+        hyper::header::HeaderValue::from_static("random-streamer"),
     );
 
     let response = sender.send_request(request).await?;
@@ -135,15 +138,17 @@ async fn wasi_http_gemini_proxy() -> Result<()> {
     let mut chunk_count = 0;
     let mut total_bytes = 0;
     let mut response_text = String::new();
+    let mut chunk_timestamps = Vec::new();
 
     while let Some(frame) = body_stream.frame().await {
         match frame {
             Ok(frame) => {
                 if let Some(chunk) = frame.data_ref() {
+                    let elapsed = start_time.elapsed();
+                    chunk_timestamps.push(elapsed);
                     chunk_count += 1;
                     total_bytes += chunk.len();
 
-                    let elapsed = start_time.elapsed();
                     println!(
                         "[{:.7}s] Chunk #{} received ({} bytes)",
                         elapsed.as_secs_f64(),
@@ -174,32 +179,48 @@ async fn wasi_http_gemini_proxy() -> Result<()> {
         total_bytes
     );
 
-    // Assertions to verify streaming behavior
-    assert!(
-        chunk_count >= 10,
-        "Expected at least 10 chunks for streaming response, got {}",
+    // Assert exactly 20 chunks
+    assert_eq!(
+        chunk_count, 20,
+        "Expected exactly 20 chunks, got {}",
         chunk_count
     );
 
+    // Assert total time is approximately 10 seconds (20 chunks * 0.5s = 10s)
+    // Allow some variance for timing precision (9-11 seconds)
     assert!(
-        total_bytes > 100,
-        "Expected substantial response content, got {} bytes",
-        total_bytes
+        total_time.as_secs_f64() >= 9.0 && total_time.as_secs_f64() <= 11.0,
+        "Expected total time ~10 seconds (9-11s range), got {:.2}s",
+        total_time.as_secs_f64()
     );
 
+    // Assert chunks arrived at approximately 0.5 second intervals
+    for i in 1..chunk_timestamps.len() {
+        let interval = (chunk_timestamps[i] - chunk_timestamps[i - 1]).as_secs_f64();
+        assert!(
+            interval >= 0.4 && interval <= 0.6,
+            "Chunk {} interval was {:.3}s, expected ~0.5s (0.4-0.6s range)",
+            i + 1,
+            interval
+        );
+    }
+
+    // Verify response is not empty
     assert!(
         !response_text.is_empty(),
         "Expected non-empty response text"
     );
 
-    // Verify that streaming actually took time (not instant)
-    assert!(
-        total_time.as_millis() > 100,
-        "Response came too fast ({:?}ms), may not be streaming",
-        total_time.as_millis()
-    );
-
     println!("✓ All streaming assertions passed!");
+    println!("  - Received exactly 20 chunks");
+    println!(
+        "  - Total time: {:.2}s (~10s expected)",
+        total_time.as_secs_f64()
+    );
+    println!(
+        "  - Average interval: {:.3}s (~0.5s expected)",
+        total_time.as_secs_f64() / 20.0
+    );
 
     Ok(())
 }