chore(test): move to pretty-assertions

src/config/entities/apikeys.rs

@@ -75,6 +75,7 @@ impl ApiKeysStore {
 
 #[cfg(test)]
 mod tests {
+    use pretty_assertions::assert_eq;
     use serde_json::json;
 
     use super::{SCHEMA, SCHEMA_VALIDATOR, format_evaluation_error};

src/config/entities/mod.rs

@@ -448,6 +448,7 @@ impl<T: DeserializeOwned + Clone + Send + Sync + 'static> EntityStore<T> {
 
 #[cfg(test)]
 mod tests {
+    use pretty_assertions::assert_eq;
     use std::{sync::Mutex, time::Duration};
 
     use anyhow::Result;

src/config/entities/models.rs

@@ -93,6 +93,7 @@ impl ModelsStore {
 
 #[cfg(test)]
 mod tests {
+    use pretty_assertions::assert_eq;
     use serde_json::json;
 
     use super::{SCHEMA, SCHEMA_VALIDATOR, format_evaluation_error};

src/config/entities/providers.rs

@@ -112,6 +112,8 @@ impl ProvidersStore {
 
 #[cfg(test)]
 mod tests {
+    use assert_matches::assert_matches;
+    use pretty_assertions::assert_eq;
     use serde_json::json;
 
     use super::{SCHEMA, SCHEMA_VALIDATOR, format_evaluation_error};
@@ -212,9 +214,6 @@ mod tests {
 
         assert_eq!(provider.name, "openai-primary");
         assert_eq!(provider.provider_type(), "openai");
-        assert!(matches!(
-            provider.provider,
-            super::ProviderConfig::OpenAI(_)
-        ));
+        assert_matches!(provider.provider, super::ProviderConfig::OpenAI(_));
     }
 }

src/gateway/error.rs

@@ -88,6 +88,7 @@ pub type Result<T> = std::result::Result<T, GatewayError>;
 
 #[cfg(test)]
 mod tests {
+    use pretty_assertions::assert_eq;
     use serde_json::json;
 
     use super::*;

src/gateway/formats/anthropic_messages.rs

@@ -1000,6 +1000,8 @@ fn openai_finish_reason_to_anthropic_stream(finish_reason: &str) -> String {
 
 #[cfg(test)]
 mod tests {
+    use assert_matches::assert_matches;
+    use pretty_assertions::assert_eq;
     use serde_json::json;
 
     use super::AnthropicMessagesFormat;
@@ -1148,24 +1150,24 @@ mod tests {
             &BridgeContext::default(),
         )
         .unwrap();
-        assert!(matches!(
+        assert_matches!(
             &events[0],
             crate::gateway::types::anthropic::AnthropicStreamEvent::MessageStart { message }
                 if message.id == "chatcmpl-123"
                     && message.usage.input_tokens.is_none()
                     && message.usage.output_tokens.is_none()
-        ));
-        assert!(matches!(
+        );
+        assert_matches!(
             &events[1],
             crate::gateway::types::anthropic::AnthropicStreamEvent::ContentBlockStart { index, .. }
                 if *index == 0
-        ));
-        assert!(matches!(
+        );
+        assert_matches!(
             &events[2],
             crate::gateway::types::anthropic::AnthropicStreamEvent::ContentBlockDelta { index, delta }
                 if *index == 0
                     && matches!(delta, crate::gateway::types::anthropic::ContentDelta::TextDelta { text } if text == "hello")
-        ));
+        );
 
         assert!(
             AnthropicMessagesFormat::from_hub_stream(
@@ -1179,24 +1181,24 @@ mod tests {
 
         let end_events =
             AnthropicMessagesFormat::stream_end_events(&mut state, &BridgeContext::default());
-        assert!(matches!(
+        assert_matches!(
             &end_events[0],
             crate::gateway::types::anthropic::AnthropicStreamEvent::ContentBlockStop { index }
                 if *index == 0
-        ));
-        assert!(matches!(
+        );
+        assert_matches!(
             &end_events[1],
             crate::gateway::types::anthropic::AnthropicStreamEvent::MessageDelta { delta, usage }
                 if delta.stop_reason.is_none()
                     && usage.input_tokens == Some(5)
                     && usage.output_tokens == Some(9)
                     && usage.cache_creation_input_tokens == Some(0)
                     && usage.cache_read_input_tokens == Some(2)
-        ));
-        assert!(matches!(
+        );
+        assert_matches!(
             &end_events[2],
             crate::gateway::types::anthropic::AnthropicStreamEvent::MessageStop
-        ));
+        );
     }
 
     #[test]
@@ -1242,16 +1244,16 @@ mod tests {
         assert_eq!(bridged.usage.output_tokens, 7);
         assert_eq!(bridged.usage.cache_read_input_tokens, 2);
         assert!(bridged.usage.cache_creation.is_none());
-        assert!(matches!(
+        assert_matches!(
             &bridged.content[0],
             crate::gateway::types::anthropic::AnthropicContentBlock::Text { text, .. }
                 if text == "Calling tool"
-        ));
-        assert!(matches!(
+        );
+        assert_matches!(
             &bridged.content[1],
             crate::gateway::types::anthropic::AnthropicContentBlock::ToolUse { name, .. }
                 if name == "get_weather"
-        ));
+        );
     }
 
     #[test]
@@ -1308,39 +1310,39 @@ mod tests {
             &BridgeContext::default(),
         )
         .unwrap();
-        assert!(matches!(
+        assert_matches!(
             &first_events[1],
             crate::gateway::types::anthropic::AnthropicStreamEvent::ContentBlockStart { index, content_block }
                 if *index == 0
                     && matches!(content_block, crate::gateway::types::anthropic::AnthropicContentBlock::ToolUse { name, .. } if name == "get_weather")
-        ));
-        assert!(matches!(
+        );
+        assert_matches!(
             &first_events[2],
             crate::gateway::types::anthropic::AnthropicStreamEvent::ContentBlockDelta { index, delta }
                 if *index == 0
                     && matches!(delta, crate::gateway::types::anthropic::ContentDelta::InputJsonDelta { partial_json } if partial_json == "{\"city\"")
-        ));
+        );
 
         let second_events = AnthropicMessagesFormat::from_hub_stream(
             &second_chunk,
             &mut state,
             &BridgeContext::default(),
         )
         .unwrap();
-        assert!(matches!(
+        assert_matches!(
             &second_events[0],
             crate::gateway::types::anthropic::AnthropicStreamEvent::ContentBlockDelta { index, delta }
                 if *index == 0
                     && matches!(delta, crate::gateway::types::anthropic::ContentDelta::InputJsonDelta { partial_json } if partial_json == ":\"SF\"}")
-        ));
+        );
 
         let end_events =
             AnthropicMessagesFormat::stream_end_events(&mut state, &BridgeContext::default());
-        assert!(matches!(
+        assert_matches!(
             &end_events[1],
             crate::gateway::types::anthropic::AnthropicStreamEvent::MessageDelta { delta, .. }
                 if delta.stop_reason.as_deref() == Some("tool_use")
-        ));
+        );
     }
 
     #[test]
@@ -1374,11 +1376,11 @@ mod tests {
             &mut missing_type_state,
             &BridgeContext::default(),
         );
-        assert!(matches!(
+        assert_matches!(
             missing_type_result,
             Err(GatewayError::Bridge(message))
                 if message.contains("requires tool call types")
-        ));
+        );
 
         let mut invalid_type_state = super::AnthropicBridgeState::default();
         let invalid_type_chunk: crate::gateway::types::openai::ChatCompletionChunk =
@@ -1410,11 +1412,11 @@ mod tests {
             &mut invalid_type_state,
             &BridgeContext::default(),
         );
-        assert!(matches!(
+        assert_matches!(
             invalid_type_result,
             Err(GatewayError::Bridge(message))
                 if message.contains("only supports function tool calls")
-        ));
+        );
     }
 
     #[test]

src/gateway/formats/openai/mod.rs

@@ -68,6 +68,8 @@ impl ChatFormat for OpenAIChatFormat {
 
 #[cfg(test)]
 mod tests {
+    use assert_matches::assert_matches;
+    use pretty_assertions::assert_eq;
     use serde_json::json;
 
     use super::OpenAIChatFormat;
@@ -224,10 +226,10 @@ mod tests {
         let error = OpenAIChatFormat::transform_native_stream_chunk(&provider, "data: {}", &mut ())
             .unwrap_err();
 
-        assert!(matches!(
+        assert_matches!(
             error,
             GatewayError::NativeNotSupported { provider } if provider == "dummy"
-        ));
+        );
         assert!(OpenAIChatFormat::native_support(&provider).is_none());
     }
 }