fmt: cargo fmt

worker/tests/common/mod.rs

@@ -3,13 +3,13 @@
 use std::fs::File;
 use std::io::{BufRead, BufReader};
 use std::path::{Path, PathBuf};
-use std::sync::{Arc, Mutex};
 use std::pin::Pin;
+use std::sync::{Arc, Mutex};
 
 use async_trait::async_trait;
 use futures::Stream;
-use worker::{Handler, TextBlockEvent, TextBlockKind, Timeline};
 use worker::llm_client::{ClientError, LlmClient, Request};
+use worker::{Handler, TextBlockEvent, TextBlockKind, Timeline};
 use worker_types::{BlockType, DeltaContent, Event};
 
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -51,11 +51,11 @@ impl LlmClient for MockLlmClient {
     ) -> Result<Pin<Box<dyn Stream<Item = Result<Event, ClientError>> + Send>>, ClientError> {
         let count = self.call_count.fetch_add(1, Ordering::SeqCst);
         if count >= self.responses.len() {
-             return Err(ClientError::Api {
-                 status: Some(500),
-                 code: Some("mock_error".to_string()),
-                 message: "No more mock responses".to_string(),
-             });
+            return Err(ClientError::Api {
+                status: Some(500),
+                code: Some("mock_error".to_string()),
+                message: "No more mock responses".to_string(),
+            });
         }
         let events = self.responses[count].clone();
         let stream = futures::stream::iter(events.into_iter().map(Ok));
@@ -135,7 +135,8 @@ pub fn assert_event_sequence(subdir: &str) {
     }
 
     // Find a text-based fixture
-    let fixture_path = fixtures.iter()
+    let fixture_path = fixtures
+        .iter()
         .find(|p| p.to_string_lossy().contains("text"))
         .unwrap_or(&fixtures[0]);
 
@@ -156,9 +157,9 @@ pub fn assert_event_sequence(subdir: &str) {
                 }
             }
             Event::BlockDelta(delta) => {
-                 if let DeltaContent::Text(_) = &delta.delta {
-                     delta_found = true;
-                 }
+                if let DeltaContent::Text(_) = &delta.delta {
+                    delta_found = true;
+                }
             }
             Event::BlockStop(stop) => {
                 if stop.block_type == BlockType::Text {
@@ -173,9 +174,9 @@ pub fn assert_event_sequence(subdir: &str) {
 
     // Check for BlockStart (Warn only for OpenAI/Ollama as it might be missing for text)
     if !start_found {
-         println!("Warning: No BlockStart found. This is common for OpenAI/Ollama text streams.");
-         // For Anthropic, strict start is usually expected, but to keep common logic simple we allow warning.
-         // If specific strictness is needed, we could add a `strict: bool` arg.
+        println!("Warning: No BlockStart found. This is common for OpenAI/Ollama text streams.");
+        // For Anthropic, strict start is usually expected, but to keep common logic simple we allow warning.
+        // If specific strictness is needed, we could add a `strict: bool` arg.
     }
 
     assert!(delta_found, "Should contain BlockDelta");
@@ -184,7 +185,9 @@ pub fn assert_event_sequence(subdir: &str) {
         assert!(stop_found, "Should contain BlockStop for Text block");
     } else {
         if !stop_found {
-             println!("  [Type: ToolUse] BlockStop detection skipped (not explicitly emitted by scheme)");
+            println!(
+                "  [Type: ToolUse] BlockStop detection skipped (not explicitly emitted by scheme)"
+            );
         }
     }
 }
@@ -200,13 +203,23 @@ pub fn assert_usage_tokens(subdir: &str) {
         let events = load_events_from_fixture(&fixture);
         let usage_events: Vec<_> = events
             .iter()
-            .filter_map(|e| if let Event::Usage(u) = e { Some(u) } else { None })
+            .filter_map(|e| {
+                if let Event::Usage(u) = e {
+                    Some(u)
+                } else {
+                    None
+                }
+            })
             .collect();
 
         if !usage_events.is_empty() {
             let last_usage = usage_events.last().unwrap();
             if last_usage.input_tokens.is_some() || last_usage.output_tokens.is_some() {
-                println!("  Fixture {:?} Usage: {:?}", fixture.file_name(), last_usage);
+                println!(
+                    "  Fixture {:?} Usage: {:?}",
+                    fixture.file_name(),
+                    last_usage
+                );
                 return; // Found valid usage
             }
         }
@@ -221,7 +234,8 @@ pub fn assert_timeline_integration(subdir: &str) {
         return;
     }
 
-    let fixture_path = fixtures.iter()
+    let fixture_path = fixtures
+        .iter()
         .find(|p| p.to_string_lossy().contains("text"))
         .unwrap_or(&fixtures[0]);