diff --git a/litellm-rust/Cargo.lock b/litellm-rust/Cargo.lock index 72688d5248e..803df633c27 100644 --- a/litellm-rust/Cargo.lock +++ b/litellm-rust/Cargo.lock @@ -1415,7 +1415,6 @@ dependencies = [ "litellm-core", "pyo3", "reqwest", - "rstest", "serde", "serde_json", "sha2 0.10.9", diff --git a/litellm-rust/crates/ai-gateway/Cargo.toml b/litellm-rust/crates/ai-gateway/Cargo.toml index 73b68e1a671..eef2bf55a07 100644 --- a/litellm-rust/crates/ai-gateway/Cargo.toml +++ b/litellm-rust/crates/ai-gateway/Cargo.toml @@ -44,5 +44,4 @@ trace-parity = ["server", "dep:tower", "litellm-core/observability"] [dev-dependencies] futures-channel = "0.3" -rstest.workspace = true tower = { version = "0.5.3", features = ["util"] } diff --git a/litellm-rust/crates/ai-gateway/src/ocr/common_utils.rs b/litellm-rust/crates/ai-gateway/src/ocr/common_utils.rs index 064b18a1fc0..d2be17260a3 100644 --- a/litellm-rust/crates/ai-gateway/src/ocr/common_utils.rs +++ b/litellm-rust/crates/ai-gateway/src/ocr/common_utils.rs @@ -395,9 +395,11 @@ pub(super) async fn poll_document_intelligence( #[cfg(test)] mod tests { - use super::*; + use litellm_core::ocr::transformation::OcrResponseHandling; use serde_json::json; + use super::*; + #[test] fn blocks_private_and_metadata_ips() { assert!(is_blocked_ip("127.0.0.1".parse().unwrap())); @@ -441,4 +443,87 @@ mod tests { assert_eq!(transformed, document); } + + #[test] + fn truncate_error_body_passes_short_strings_through() { + let body = "Unauthorized"; + assert_eq!(truncate_error_body(body), "Unauthorized"); + } + + #[test] + fn truncate_error_body_caps_long_payloads() { + let body = "x".repeat(306); + let truncated = truncate_error_body(&body); + + assert!(truncated.ends_with("... (truncated)")); + let prefix_chars = truncated + .strip_suffix("... (truncated)") + .expect("truncated marker present") + .chars() + .count(); + assert_eq!(prefix_chars, 256); + } + + #[test] + fn truncate_error_body_does_not_split_multibyte_chars() { + let body = "é".repeat(266); + let truncated = truncate_error_body(&body); + assert!(truncated.is_char_boundary(truncated.len())); + } + + #[test] + fn ocr_dispatch_supports_migrated_providers() { + assert!(ocr_provider_config("mistral", "mistral-ocr-latest").is_some()); + assert!( + ocr_provider_config("azure_ai", "pixtral-12b-2409") + .expect("azure ai config resolves") + .requires_data_uri_document() + ); + assert_eq!( + ocr_provider_config("azure_ai", "doc-intelligence/prebuilt-read") + .expect("document intelligence config resolves") + .response_handling(), + OcrResponseHandling::AzureDocumentIntelligencePoll + ); + assert!( + ocr_provider_config("vertex_ai", "deepseek-ocr-maas") + .expect("vertex deepseek config resolves") + .supported_ocr_params() + .contains(&"temperature") + ); + assert!(ocr_provider_config("openai", "gpt-4o").is_none()); + } + + #[test] + fn string_headers_accepts_string_values() { + let headers = json!({ + "x-trace-id": "trace-1" + }) + .as_object() + .unwrap() + .clone(); + + assert_eq!( + string_headers(Some(headers)).expect("string headers accepted"), + vec![("x-trace-id".to_string(), "trace-1".to_string())] + ); + } + + #[test] + fn string_headers_rejects_non_string_values() { + let headers = json!({ + "x-retry-count": 3 + }) + .as_object() + .unwrap() + .clone(); + + let err = string_headers(Some(headers)).expect_err("non-string header rejected"); + assert_eq!( + err, + Error::InvalidRequest( + "OCR extra_headers.x-retry-count must be a string, got number".to_string() + ) + ); + } } diff --git a/litellm-rust/crates/ai-gateway/src/ocr/mod.rs b/litellm-rust/crates/ai-gateway/src/ocr/mod.rs index d9230af1c59..2acdd232c80 100644 --- a/litellm-rust/crates/ai-gateway/src/ocr/mod.rs +++ b/litellm-rust/crates/ai-gateway/src/ocr/mod.rs @@ -24,4 +24,151 @@ pub async fn ocr(request: OcrRequest<'_>) -> Result { } #[cfg(test)] -mod tests; +mod tests { + use serde_json::{Map, json}; + use tokio::io::{AsyncReadExt, AsyncWriteExt}; + use tokio::net::{TcpListener, TcpStream}; + + use super::{OcrRequest, ocr}; + use crate::integrations::types::RequestMetadata; + + async fn read_http_request(socket: &mut TcpStream) -> String { + let mut request = Vec::new(); + let mut buffer = [0_u8; 1024]; + let header_end = loop { + let n = socket.read(&mut buffer).await.expect("reads request"); + if n == 0 { + break request.len(); + } + request.extend_from_slice(&buffer[..n]); + if let Some(position) = request.windows(4).position(|window| window == b"\r\n\r\n") { + break position + 4; + } + }; + let headers = String::from_utf8_lossy(&request[..header_end]); + let content_length = headers + .lines() + .find_map(|line| { + let (name, value) = line.split_once(':')?; + name.eq_ignore_ascii_case("content-length") + .then(|| value.trim().parse::().ok()) + .flatten() + }) + .unwrap_or(0); + while request.len().saturating_sub(header_end) < content_length { + let n = socket.read(&mut buffer).await.expect("reads body"); + if n == 0 { + break; + } + request.extend_from_slice(&buffer[..n]); + } + String::from_utf8(request).expect("request is utf8") + } + + fn base_ocr_request(model: &str) -> OcrRequest<'_> { + OcrRequest { + model, + document: json!({ + "type": "document_url", + "document_url": "https://example.com/doc.pdf" + }), + api_key: Some("sk-test"), + api_base: None, + custom_llm_provider: None, + extra_headers: None, + optional_params: Map::new(), + timeout: None, + callbacks: Vec::new(), + guardrails: Vec::new(), + request_metadata: RequestMetadata::default(), + litellm_call_id: None, + } + } + + #[tokio::test] + async fn reducto_file_upload_then_parse_maps_response() { + let listener = TcpListener::bind("127.0.0.1:0") + .await + .expect("test listener binds"); + let address = listener.local_addr().expect("listener has local address"); + let server = tokio::spawn(async move { + let (mut upload_socket, _) = listener.accept().await.expect("accepts upload request"); + let upload_request = read_http_request(&mut upload_socket).await; + let upload_body = r#"{"file_id":"reducto://uploaded.pdf"}"#; + let upload_response = format!( + "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}", + upload_body.len(), + upload_body + ); + upload_socket + .write_all(upload_response.as_bytes()) + .await + .expect("writes upload response"); + + let (mut parse_socket, _) = listener.accept().await.expect("accepts parse request"); + let parse_request = read_http_request(&mut parse_socket).await; + let parse_body = r#"{"job_id":"job_123","usage":{"num_pages":3,"credits":3},"result":{"chunks":[{"content":"Page 1 block A","blocks":[{"content":"Page 1 block A","bbox":{"page":1},"kind":"text"}]},{"content":"Page 2 block A","blocks":[{"content":"Page 2 block A","bbox":{"page":2},"kind":"table"}]},{"content":"Page 1 block B","blocks":[{"content":"Page 1 block B","bbox":{"page":1},"kind":"text"}]},{"content":"Page 3 block A","blocks":[{"content":"Page 3 block A","bbox":{"page":3},"kind":"figure"}]}]}}"#; + let parse_response = format!( + "HTTP/1.1 200 OK\r\ncontent-type: application/json\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}", + parse_body.len(), + parse_body + ); + parse_socket + .write_all(parse_response.as_bytes()) + .await + .expect("writes parse response"); + (upload_request, parse_request) + }); + let api_base = format!("http://{address}"); + let mut request = base_ocr_request("reducto/parse-v3"); + request.api_base = Some(&api_base); + request.api_key = None; + request.extra_headers = Some(Map::from_iter([ + ("Authorization".to_string(), json!("Bearer test-key")), + ("x-trace-id".to_string(), json!("trace-1")), + ])); + request.document = json!({ + "type": "document_url", + "document_url": "data:application/pdf;base64,JVBERi0xLjQ=" + }); + request.optional_params = Map::from_iter([ + ( + "formatting".to_string(), + json!({"table_output_format": "html"}), + ), + ("retrieval".to_string(), json!({"chunk_mode": "section"})), + ("settings".to_string(), json!({"ocr_system": "standard"})), + ]); + + let response = ocr(request).await.expect("Reducto OCR succeeds"); + + assert_eq!(response["pages"].as_array().map(Vec::len), Some(3)); + assert_eq!( + response["pages"][0]["markdown"], + "Page 1 block A\n\nPage 1 block B" + ); + assert_eq!(response["pages"][1]["markdown"], "Page 2 block A"); + assert_eq!(response["pages"][2]["markdown"], "Page 3 block A"); + assert_eq!(response["usage_info"]["pages_processed"], 3); + assert_eq!(response["usage_info"]["credits"], 3); + assert_eq!(response["provider_native_response"]["job_id"], "job_123"); + let (upload_request, parse_request) = server.await.expect("server task completes"); + assert!( + upload_request + .to_ascii_lowercase() + .contains("authorization: bearer test-key") + ); + assert!(upload_request.contains("application/pdf")); + assert!(upload_request.contains("%PDF-1.4")); + assert!(upload_request.contains("x-trace-id: trace-1")); + assert!( + parse_request + .to_ascii_lowercase() + .contains("authorization: bearer test-key") + ); + assert!(parse_request.contains(r#""input":"reducto://uploaded.pdf""#)); + assert!(parse_request.contains(r#""table_output_format":"html""#)); + assert!(parse_request.contains(r#""chunk_mode":"section""#)); + assert!(parse_request.contains(r#""ocr_system":"standard""#)); + } +} diff --git a/litellm-rust/crates/ai-gateway/src/ocr/prepare.rs b/litellm-rust/crates/ai-gateway/src/ocr/prepare.rs index ab70d9a6891..fa9ca1a193e 100644 --- a/litellm-rust/crates/ai-gateway/src/ocr/prepare.rs +++ b/litellm-rust/crates/ai-gateway/src/ocr/prepare.rs @@ -110,3 +110,54 @@ fn new_ocr_call_id() -> String { .unwrap_or(0); format!("ocr-{timestamp}-{sequence}") } + +#[cfg(test)] +mod tests { + use litellm_core::error::Error; + use serde_json::{Map, json}; + + use super::{OcrRequest, prepare_ocr_call}; + use crate::integrations::types::RequestMetadata; + + fn base_ocr_request(model: &str) -> OcrRequest<'_> { + OcrRequest { + model, + document: json!({ + "type": "document_url", + "document_url": "https://example.com/doc.pdf" + }), + api_key: Some("sk-test"), + api_base: None, + custom_llm_provider: None, + extra_headers: None, + optional_params: Map::new(), + timeout: None, + callbacks: Vec::new(), + guardrails: Vec::new(), + request_metadata: RequestMetadata::default(), + litellm_call_id: None, + } + } + + fn request_with_format(format: &str) -> OcrRequest<'_> { + let mut request = base_ocr_request("mistral/mistral-ocr-latest"); + request.optional_params = Map::from_iter([("req_format".to_string(), json!(format))]); + request + } + + #[test] + fn native_format_rejected_for_provider_without_support_as_bad_request() { + let prepared = prepare_ocr_call(request_with_format("native")); + assert!( + matches!(prepared.request.config, Err(Error::InvalidRequest(message)) if message.contains("not supported for provider")) + ); + } + + #[test] + fn unknown_format_rejected_for_provider_without_support_as_bad_request() { + let prepared = prepare_ocr_call(request_with_format("raw")); + assert!( + matches!(prepared.request.config, Err(Error::InvalidRequest(message)) if message.contains("Invalid `req_format`")) + ); + } +} diff --git a/litellm-rust/crates/ai-gateway/src/ocr/tests.rs b/litellm-rust/crates/ai-gateway/tests/ocr_lifecycle.rs similarity index 82% rename from litellm-rust/crates/ai-gateway/src/ocr/tests.rs rename to litellm-rust/crates/ai-gateway/tests/ocr_lifecycle.rs index 85e4c408045..c3a89f4394d 100644 --- a/litellm-rust/crates/ai-gateway/src/ocr/tests.rs +++ b/litellm-rust/crates/ai-gateway/tests/ocr_lifecycle.rs @@ -1,23 +1,19 @@ use std::sync::{Arc, Mutex}; use std::time::Duration; -use litellm_core::error::Error; -use litellm_core::http_utils::has_header; -use litellm_core::ocr::transformation::OcrResponseHandling; -use serde_json::{Map, Value, json}; -use tokio::io::{AsyncReadExt, AsyncWriteExt}; -use tokio::net::{TcpListener, TcpStream}; - -use super::common_utils::{ocr_provider_config, string_headers, truncate_error_body}; -use super::{OcrRequest, ocr}; -use crate::integrations::custom_guardrail::{ +use litellm_ai_gateway::integrations::custom_guardrail::{ CustomGuardrail, GuardrailContext, GuardrailDecision, GuardrailError, GuardrailEventHook, GuardrailFuture, GuardrailRequest, }; -use crate::integrations::custom_logger::{ +use litellm_ai_gateway::integrations::custom_logger::{ CallbackTiming, CallbackValue, CustomLogger, LogFuture, ModelCallDetails, }; -use crate::integrations::types::RequestMetadata; +use litellm_ai_gateway::integrations::types::RequestMetadata; +use litellm_ai_gateway::ocr::{OcrRequest, ocr}; +use litellm_core::error::Error; +use serde_json::{Map, Value, json}; +use tokio::io::{AsyncReadExt, AsyncWriteExt}; +use tokio::net::{TcpListener, TcpStream}; async fn read_http_headers(socket: &mut TcpStream) -> String { let mut request = Vec::new(); @@ -136,6 +132,7 @@ struct RecordingOcrGuardrail { hooks: Vec, events: Mutex>, block_pre_call: bool, + block_during_call: bool, } impl RecordingOcrGuardrail { @@ -144,6 +141,7 @@ impl RecordingOcrGuardrail { hooks, events: Mutex::new(Vec::new()), block_pre_call: false, + block_during_call: false, } } @@ -152,6 +150,16 @@ impl RecordingOcrGuardrail { hooks: vec![GuardrailEventHook::PreCall], events: Mutex::new(Vec::new()), block_pre_call: true, + block_during_call: false, + } + } + + fn blocking_during_call() -> Self { + Self { + hooks: vec![GuardrailEventHook::DuringCall], + events: Mutex::new(Vec::new()), + block_pre_call: false, + block_during_call: true, } } @@ -193,91 +201,95 @@ impl CustomGuardrail for RecordingOcrGuardrail { ) -> GuardrailFuture<'a> { Box::pin(async move { self.events.lock().unwrap().push("async_moderation_hook"); + if self.block_during_call { + return Ok(GuardrailDecision::Block(GuardrailError::blocked( + "blocked before provider", + ))); + } request.data["body"]["guarded_during"] = json!(true); Ok(GuardrailDecision::Mask(request)) }) } } -#[test] -fn truncate_error_body_passes_short_strings_through() { - let body = "Unauthorized"; - assert_eq!(truncate_error_body(body), "Unauthorized"); +fn base_ocr_request(model: &str) -> OcrRequest<'_> { + OcrRequest { + model, + document: json!({ + "type": "document_url", + "document_url": "https://example.com/doc.pdf" + }), + api_key: Some("sk-test"), + api_base: None, + custom_llm_provider: None, + extra_headers: None, + optional_params: Map::new(), + timeout: None, + callbacks: Vec::new(), + guardrails: Vec::new(), + request_metadata: RequestMetadata::default(), + litellm_call_id: None, + } } -#[test] -fn truncate_error_body_caps_long_payloads() { - let body = "x".repeat(306); - let truncated = truncate_error_body(&body); +#[tokio::test] +async fn reducto_during_call_guardrail_blocks_before_upload() { + let listener = TcpListener::bind("127.0.0.1:0") + .await + .expect("test listener binds"); + let address = listener.local_addr().expect("listener has local address"); + let api_base = format!("http://{address}"); + let guardrail = Arc::new(RecordingOcrGuardrail::blocking_during_call()); + let mut request = base_ocr_request("reducto/parse-v3"); + request.api_base = Some(&api_base); + request.document = json!({ + "type": "document_url", + "document_url": "data:application/pdf;base64,JVBERi0xLjQ=" + }); + request.guardrails = vec![guardrail.clone()]; - assert!(truncated.ends_with("... (truncated)")); - let prefix_chars = truncated - .strip_suffix("... (truncated)") - .expect("truncated marker present") - .chars() - .count(); - assert_eq!(prefix_chars, 256); + let error = ocr(request).await.expect_err("guardrail blocks upload"); + + assert!(matches!(error, Error::InvalidRequest(_))); + assert_eq!(guardrail.events(), vec!["async_moderation_hook"]); + let accepted = tokio::time::timeout(Duration::from_millis(100), listener.accept()).await; + assert!(accepted.is_err(), "upload socket should not be touched"); } -#[test] -fn truncate_error_body_does_not_split_multibyte_chars() { - let body = "é".repeat(266); - let truncated = truncate_error_body(&body); - assert!(truncated.is_char_boundary(truncated.len())); -} +#[tokio::test] +async fn reducto_upload_error_body_is_truncated() { + let listener = TcpListener::bind("127.0.0.1:0") + .await + .expect("test listener binds"); + let address = listener.local_addr().expect("listener has local address"); + let server = tokio::spawn(async move { + let (mut socket, _) = listener.accept().await.expect("accepts upload request"); + let _request = read_http_request(&mut socket).await; + let body = "x".repeat(300); + let response = format!( + "HTTP/1.1 500 Internal Server Error\r\ncontent-length: {}\r\nconnection: close\r\n\r\n{}", + body.len(), + body + ); + socket + .write_all(response.as_bytes()) + .await + .expect("writes upload response"); + }); + let api_base = format!("http://{address}"); + let mut request = base_ocr_request("reducto/parse-v3"); + request.api_base = Some(&api_base); + request.document = json!({ + "type": "document_url", + "document_url": "data:application/pdf;base64,JVBERi0xLjQ=" + }); + + let error = ocr(request).await.expect_err("upload should fail"); -#[test] -fn ocr_dispatch_supports_migrated_providers() { - assert!(ocr_provider_config("mistral", "mistral-ocr-latest").is_some()); assert!( - ocr_provider_config("azure_ai", "pixtral-12b-2409") - .expect("azure ai config resolves") - .requires_data_uri_document() + matches!(error, Error::Http { status: 500, body } if body.chars().count() < 300 && body.ends_with("... (truncated)")) ); - assert_eq!( - ocr_provider_config("azure_ai", "doc-intelligence/prebuilt-read") - .expect("document intelligence config resolves") - .response_handling(), - OcrResponseHandling::AzureDocumentIntelligencePoll - ); - assert!( - ocr_provider_config("vertex_ai", "deepseek-ocr-maas") - .expect("vertex deepseek config resolves") - .supported_ocr_params() - .contains(&"temperature") - ); - assert!(ocr_provider_config("openai", "gpt-4o").is_none()); -} - -#[test] -fn string_headers_accepts_string_values() { - let headers = json!({ - "x-trace-id": "trace-1" - }) - .as_object() - .unwrap() - .clone(); - - assert_eq!( - string_headers(Some(headers)).expect("string headers accepted"), - vec![("x-trace-id".to_string(), "trace-1".to_string())] - ); -} - -#[test] -fn auth_header_detection_is_case_insensitive() { - let headers = vec![ - ("x-trace-id".to_string(), "trace-1".to_string()), - ("authorization".to_string(), "Bearer sk-test".to_string()), - ]; - - assert!(has_header(&headers, "authorization")); - - let headers = vec![("Authorization".to_string(), "Bearer sk-test".to_string())]; - assert!(has_header(&headers, "authorization")); - - let headers = vec![("x-trace-id".to_string(), "trace-1".to_string())]; - assert!(!has_header(&headers, "authorization")); + server.await.expect("server task completes"); } #[tokio::test] @@ -595,21 +607,3 @@ async fn document_intelligence_poll_uses_resolved_subscription_key() { "{poll_request}" ); } - -#[test] -fn string_headers_rejects_non_string_values() { - let headers = json!({ - "x-retry-count": 3 - }) - .as_object() - .unwrap() - .clone(); - - let err = string_headers(Some(headers)).expect_err("non-string header rejected"); - assert_eq!( - err, - Error::InvalidRequest( - "OCR extra_headers.x-retry-count must be a string, got number".to_string() - ) - ); -} diff --git a/litellm-rust/crates/core/src/http_utils.rs b/litellm-rust/crates/core/src/http_utils.rs index 3633130528d..cb472dd5a57 100644 --- a/litellm-rust/crates/core/src/http_utils.rs +++ b/litellm-rust/crates/core/src/http_utils.rs @@ -101,6 +101,23 @@ mod tests { assert!(!has_header(&headers, "authorization")); } + #[test] + fn auth_header_detection_is_case_insensitive() { + let headers = vec![ + ("x-trace-id".to_string(), "trace-1".to_string()), + ("authorization".to_string(), "Bearer sk-test".to_string()), + ]; + + assert!(has_header(&headers, "authorization")); + + let headers = vec![("Authorization".to_string(), "Bearer sk-test".to_string())]; + + assert!(has_header(&headers, "authorization")); + + let headers = vec![("x-trace-id".to_string(), "trace-1".to_string())]; + assert!(!has_header(&headers, "authorization")); + } + #[test] fn bearer_detection_requires_a_non_empty_token() { assert!(has_bearer_auth(&[( diff --git a/litellm-rust/crates/core/src/providers/azure_ai/ocr/transformation.rs b/litellm-rust/crates/core/src/providers/azure_ai/ocr/transformation.rs index 4ee856005b4..d15c032f0bc 100644 --- a/litellm-rust/crates/core/src/providers/azure_ai/ocr/transformation.rs +++ b/litellm-rust/crates/core/src/providers/azure_ai/ocr/transformation.rs @@ -663,10 +663,12 @@ mod tests { .map(|(_, value)| value.as_str()) } + #[fixture] fn native_operation() -> Value { json!({ "status": "succeeded", "createdDateTime": "2026-07-02T00:00:00Z", + "lastUpdatedDateTime": "2026-07-02T00:00:05Z", "analyzeResult": { "content": "Invoice\nInvoice No: INV-12345\nTotal: $100.00", "pages": [{ @@ -682,13 +684,65 @@ mod tests { ], "words": [{"content": "Invoice", "confidence": 0.994}] }], - "tables": [{"rowCount": 1, "columnCount": 1}], - "keyValuePairs": [{"key": {"content": "Invoice No"}, "value": {"content": "INV-12345"}}], + "tables": [ + { + "rowCount": 2, + "columnCount": 2, + "cells": [ + {"kind": "columnHeader", "rowIndex": 0, "columnIndex": 0, "content": "Item"}, + {"kind": "columnHeader", "rowIndex": 0, "columnIndex": 1, "content": "Price"}, + {"rowIndex": 1, "columnIndex": 0, "content": "Widget"}, + {"rowIndex": 1, "columnIndex": 1, "content": "$100.00"} + ] + }, + { + "rowCount": 1, + "columnCount": 1, + "cells": [{"rowIndex": 0, "columnIndex": 0, "content": "Totals"}] + } + ], + "keyValuePairs": [ + { + "key": {"content": "Invoice No"}, + "value": {"content": "INV-12345"}, + "confidence": 0.98 + }, + { + "key": {"content": "Total"}, + "value": {"content": "$100.00"}, + "confidence": 0.95 + } + ], "paragraphs": [{"content": "Invoice"}] } }) } + fn assert_native_fields_preserved(response: &OcrResponseData, operation: &Value) { + let analyze_result = &operation["analyzeResult"]; + + assert_eq!(response.extra_fields["content"], analyze_result["content"]); + assert_eq!(response.extra_fields["tables"], analyze_result["tables"]); + assert_eq!( + response.extra_fields["keyValuePairs"], + analyze_result["keyValuePairs"] + ); + assert_eq!(response.object, "ocr"); + assert_eq!( + response.usage_info, + Some(json!({"pages_processed": 1, "doc_size_bytes": null})) + ); + assert_eq!(response.pages[0]["index"], 0); + assert_eq!( + response.pages[0]["markdown"], + "Invoice\nInvoice No: INV-12345\nTotal: $100.00" + ); + assert_eq!( + response.pages[0]["dimensions"], + json!({"width": 816, "height": 1056, "dpi": 96}) + ); + } + #[test] fn azure_ai_reuses_mistral_body_transform() { let body = AZURE_AI_OCR_CONFIG @@ -798,15 +852,10 @@ mod tests { #[case::nested_list(json!([["keyValuePairs"]]))] #[case::object(json!({"feature": "keyValuePairs"}))] #[case::number(json!(5))] - fn document_intelligence_url_rejects_invalid_features(#[case] features: Value) { + fn document_intelligence_mapping_rejects_invalid_features(#[case] features: Value) { let params = serde_json::Map::from_iter([("features".to_string(), features)]); - let error = complete_document_intelligence_url( - Some("https://example.cognitiveservices.azure.com"), - "prebuilt-layout", - ¶ms, - &|_| None, - ) - .expect_err("invalid features must fail"); + let error = + map_document_intelligence_ocr_params(¶ms).expect_err("invalid features must fail"); assert!(matches!( error, @@ -814,28 +863,25 @@ mod tests { )); } - #[test] - fn document_intelligence_maps_features() { - for (features, expected) in [ - (json!(["keyValuePairs"]), "keyValuePairs"), - ( - json!(["keyValuePairs", "languages"]), - "keyValuePairs,languages", - ), - (json!("keyValuePairs"), "keyValuePairs"), - (json!("keyValuePairs,languages"), "keyValuePairs,languages"), - (json!("keyValuePairs, languages"), "keyValuePairs,languages"), - ] { - let params = Map::from_iter([ - ("features".to_string(), features), - ("unsupported".to_string(), json!(true)), - ]); + #[rstest] + #[case::single_list(json!(["keyValuePairs"]), "keyValuePairs")] + #[case::multiple_list( + json!(["keyValuePairs", "languages"]), + "keyValuePairs,languages" + )] + #[case::single_string(json!("keyValuePairs"), "keyValuePairs")] + #[case::comma_separated(json!("keyValuePairs,languages"), "keyValuePairs,languages")] + #[case::spaces(json!("keyValuePairs, languages"), "keyValuePairs,languages")] + fn document_intelligence_maps_features(#[case] features: Value, #[case] expected: &str) { + let params = Map::from_iter([ + ("features".to_string(), features), + ("unsupported".to_string(), json!(true)), + ]); - assert_eq!( - AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG.map_ocr_params(¶ms), - Map::from_iter([("features".to_string(), json!(expected))]) - ); - } + assert_eq!( + AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG.map_ocr_params(¶ms), + Map::from_iter([("features".to_string(), json!(expected))]) + ); } #[test] @@ -852,43 +898,13 @@ mod tests { assert_eq!(body, json!({"base64Source": "abc123"})); } - #[test] - fn document_intelligence_response_normalizes_pages() { + #[rstest] + fn document_intelligence_response_normalizes_pages(native_operation: Value) { let response = AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG - .transform_ocr_response( - "prebuilt-layout", - json!({ - "status": "succeeded", - "analyzeResult": { - "content": "hello\nworld", - "tables": [{"rowCount": 1, "columnCount": 1}], - "keyValuePairs": [{"key": {"content": "Total"}, "value": {"content": "$100.00"}}], - "pages": [{ - "pageNumber": 2, - "width": 8.5, - "height": 11, - "unit": "inch", - "lines": [{"content": "hello"}, {"content": "world"}] - }] - } - }), - ) + .transform_ocr_response("prebuilt-layout", native_operation.clone()) .expect("response transforms"); - assert_eq!(response.pages[0]["index"], 1); - assert_eq!(response.pages[0]["markdown"], "hello\nworld"); - assert_eq!(response.pages[0]["dimensions"]["width"], 816); - assert_eq!(response.extra_fields["content"], "hello\nworld"); - assert_eq!(response.extra_fields["tables"][0]["rowCount"], 1); - assert_eq!( - response.extra_fields["keyValuePairs"][0]["key"]["content"], - "Total" - ); - assert_eq!(response.object, "ocr"); - assert_eq!( - response.usage_info, - Some(json!({"pages_processed": 1, "doc_size_bytes": null})) - ); + assert_native_fields_preserved(&response, &native_operation); } #[test] @@ -923,28 +939,16 @@ mod tests { ); } - #[test] - fn document_intelligence_async_response_preserves_normalized_fields() { + #[rstest] + fn document_intelligence_async_response_preserves_normalized_fields(native_operation: Value) { let response = AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG .transform_ocr_response( "azure_ai/doc-intelligence/prebuilt-layout", - native_operation(), + native_operation.clone(), ) .expect("response transforms"); - assert_eq!( - response.pages[0]["markdown"], - "Invoice\nInvoice No: INV-12345\nTotal: $100.00" - ); - assert_eq!( - response.pages[0]["dimensions"], - json!({"width": 816, "height": 1056, "dpi": 96}) - ); - assert_eq!(response.extra_fields["tables"][0]["rowCount"], 1); - assert_eq!( - response.extra_fields["keyValuePairs"][0]["key"]["content"], - "Invoice No" - ); + assert_native_fields_preserved(&response, &native_operation); } #[test] @@ -998,44 +1002,38 @@ mod tests { ); } - #[test] - fn document_intelligence_native_format_carries_raw_operation() { - let operation = native_operation(); + #[rstest] + fn document_intelligence_native_format_carries_raw_operation(native_operation: Value) { let response = AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG .transform_ocr_response_with_params( "azure_ai/doc-intelligence/prebuilt-layout", - operation.clone(), + native_operation.clone(), &Map::from_iter([("req_format".to_string(), json!("native"))]), ) .expect("native response transforms"); - assert_eq!(response.provider_native_response, Some(operation)); assert_eq!( - response.extra_fields["content"], - "Invoice\nInvoice No: INV-12345\nTotal: $100.00" - ); - assert_eq!( - response.usage_info.as_ref().expect("usage")["pages_processed"], - 1 + response.provider_native_response, + Some(native_operation.clone()) ); + assert_native_fields_preserved(&response, &native_operation); } - #[test] - fn document_intelligence_async_native_format_carries_raw_operation() { - let operation = native_operation(); + #[rstest] + fn document_intelligence_async_native_format_carries_raw_operation(native_operation: Value) { let response = AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG .transform_ocr_response_with_params( "azure_ai/doc-intelligence/prebuilt-layout", - operation.clone(), + native_operation.clone(), &Map::from_iter([("req_format".to_string(), json!("native"))]), ) .expect("native response transforms"); - assert_eq!(response.provider_native_response, Some(operation)); assert_eq!( - response.usage_info.as_ref().expect("usage")["pages_processed"], - 1 + response.provider_native_response, + Some(native_operation.clone()) ); + assert_native_fields_preserved(&response, &native_operation); } #[rstest] @@ -1043,17 +1041,18 @@ mod tests { #[case::litellm(Map::from_iter([("req_format".to_string(), json!("litellm"))]))] fn document_intelligence_default_format_omits_raw_operation( #[case] optional_params: Map, + native_operation: Value, ) { let response = AZURE_DOCUMENT_INTELLIGENCE_OCR_CONFIG .transform_ocr_response_with_params( "azure_ai/doc-intelligence/prebuilt-layout", - native_operation(), + native_operation.clone(), &optional_params, ) .expect("response transforms"); assert_eq!(response.provider_native_response, None); - assert_eq!(response.extra_fields["tables"][0]["rowCount"], 1); + assert_native_fields_preserved(&response, &native_operation); } #[rstest] diff --git a/tests/rust-python-harness/strategies/unit_tests_mapping/AGENTS.md b/tests/rust-python-harness/strategies/unit_tests_mapping/AGENTS.md index 5b389dc9d1b..379d1443f33 100644 --- a/tests/rust-python-harness/strategies/unit_tests_mapping/AGENTS.md +++ b/tests/rust-python-harness/strategies/unit_tests_mapping/AGENTS.md @@ -10,4 +10,4 @@ For Python, those traced functions define the denominator. Static references and For Rust, each traced function identifies its source file and module. If that source file has a colocated `#[cfg(test)] mod tests`, the harness inventories that module for the configured Rust target. Rust test names are therefore derived from traced implementation files, not from a hand-maintained list of OCR test modules -The Python-to-Rust mappings remain explicit because equivalent behavior often has different test boundaries and names in each SDK. The report validates those mappings against both live inventories, then shows mapped Python tests, unmapped Python tests that still need a Rust counterpart, and Rust-only tests +The Python-to-Rust mappings remain explicit because equivalent behavior often has different test boundaries and names in each SDK. Host-only exclusions require a reason. The report validates both against the live inventories, then shows mapped, excluded, and unmapped Python tests plus Rust-only tests diff --git a/tests/rust-python-harness/strategies/unit_tests_mapping/cases/ocr.py b/tests/rust-python-harness/strategies/unit_tests_mapping/cases/ocr.py index 0599539d314..dc3167017d9 100644 --- a/tests/rust-python-harness/strategies/unit_tests_mapping/cases/ocr.py +++ b/tests/rust-python-harness/strategies/unit_tests_mapping/cases/ocr.py @@ -4,8 +4,10 @@ from typing import Final from ....shared.unit_runners.rust_runner import RustTarget, RustTestIdentity from ..contracts import ( + MappingExclusionSpec, MappingSpec, PythonFunctionDiscoverySpec, + RustTestFamily, RustUnitSpec, TestMapping, UnitParityExclusionSpec, @@ -21,12 +23,249 @@ _GATEWAY_TARGET: Final = RustTarget( ) _AZURE_OCR_TESTS: Final = "providers::azure_ai::ocr::transformation::tests" _MISTRAL_OCR_TESTS: Final = "providers::mistral::ocr::transformation::tests" +_VERTEX_OCR_TESTS: Final = "providers::vertex_ai::ocr::transformation::tests" +_REDUCTO_OCR_TESTS: Final = "providers::reducto::ocr::tests" +_GATEWAY_OCR_TESTS: Final = "ocr::tests" +_GATEWAY_PREPARE_OCR_TESTS: Final = "ocr::prepare::tests" def _rust_test(target: RustTarget, module: str, test: str) -> RustTestIdentity: return RustTestIdentity(target=target, name=f"{module}::{test}") +def _rust_family(target: RustTarget, module: str, test: str) -> RustTestFamily: + return RustTestFamily(target=target, name=f"{module}::{test}") + + +def _test_mappings(target: RustTarget, module: str, pairs: tuple[tuple[str, str], ...]) -> tuple[TestMapping, ...]: + return tuple(TestMapping(python=python, rust=_rust_test(target, module, test)) for python, test in pairs) + + +_AZURE_TRANSFORM_FILE: Final = "tests/test_litellm/llms/azure_ai/test_azure_document_intelligence_ocr_transformation.py" +_AZURE_PAGES_FILE: Final = "tests/ocr_tests/test_ocr_azure_document_intelligence.py" +_AZURE_BASE_FILE: Final = "tests/test_litellm/ocr/test_ocr_azure_document_intelligence_api_base.py" +_RUST_BRIDGE_FILE: Final = "tests/test_litellm/ocr/test_rust_bridge.py" + +_AZURE_PORT_MAPPINGS: Final = _test_mappings( + _CORE_TARGET, + _AZURE_OCR_TESTS, + ( + ( + f"{_AZURE_TRANSFORM_FILE}::test_should_encode_azure_document_intelligence_model_id", + "azure_document_intelligence_model_id_is_encoded", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_should_reject_dot_segment_azure_document_intelligence_model_id", + "azure_document_intelligence_dot_segment_model_id_is_rejected", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_async_transform_ocr_response_preserves_azure_native_fields", + "document_intelligence_async_response_preserves_normalized_fields", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_transform_ocr_response_tolerates_missing_native_fields", + "document_intelligence_response_tolerates_missing_native_fields", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_transform_ocr_response_non_succeeded_status_raises", + "document_intelligence_non_succeeded_status_is_rejected", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_get_supported_ocr_params_includes_features", + "document_intelligence_supported_params_include_features", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_transform_ocr_response_native_format_carries_raw_operation", + "document_intelligence_native_format_carries_raw_operation", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_async_transform_ocr_response_native_format_carries_raw_operation", + "document_intelligence_async_native_format_carries_raw_operation", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_map_ocr_params_rejects_unknown_req_format_as_bad_request", + "document_intelligence_rejects_unknown_req_format", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_get_complete_url_omits_req_format_query_param", + "document_intelligence_url_omits_req_format", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_validate_environment_uses_subscription_key", + "document_intelligence_validate_environment_uses_subscription_key", + ), + ( + f"{_AZURE_TRANSFORM_FILE}::test_validate_environment_falls_back_to_entra_token", + "document_intelligence_validate_environment_falls_back_to_entra_token", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_get_supported_ocr_params_includes_pages_and_features", + "document_intelligence_supported_params_include_pages_features_and_req_format", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_mistral_zero_based_int_list", + "document_intelligence_maps_zero_based_page_list", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_dedupes_and_sorts", + "document_intelligence_page_mapping_dedupes_and_sorts", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_empty_list_omits_pages", + "document_intelligence_page_mapping_omits_empty_list", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_azure_native_string_range", + "document_intelligence_page_mapping_accepts_native_range", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_azure_native_string_with_spaces_stripped", + "document_intelligence_page_mapping_strips_spaces", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_list_of_string_tokens", + "document_intelligence_page_mapping_accepts_string_tokens", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_invalid_string_raises", + "document_intelligence_page_mapping_rejects_invalid_string", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_negative_index_raises", + "document_intelligence_page_mapping_rejects_negative_index", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_bool_list_raises", + "document_intelligence_page_mapping_rejects_bool_list", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_map_ocr_params_unsupported_type_raises", + "document_intelligence_page_mapping_rejects_unsupported_type", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_get_complete_url_appends_pages_query", + "document_intelligence_url_appends_pages_query", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_get_complete_url_no_pages_when_optional_params_empty", + "document_intelligence_url_has_no_pages_when_params_are_empty", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_transform_ocr_request_does_not_put_pages_in_body", + "document_intelligence_request_keeps_pages_out_of_body", + ), + ( + f"{_AZURE_PAGES_FILE}::TestAzureDocumentIntelligencePagesParam::test_end_to_end_mistral_shape_to_azure_query", + "document_intelligence_mistral_pages_flow_to_query_only", + ), + ( + "tests/test_litellm/llms/azure_ai/test_azure_ai_entra_auth.py::test_ocr_authenticates_with_entra_token", + "azure_ai_ocr_authenticates_with_entra_token", + ), + ( + f"{_AZURE_BASE_FILE}::TestDocIntelligenceApiBaseResolution::test_generic_azure_ai_base_does_not_hijack_doc_intelligence", + "document_intelligence_endpoint_ignores_generic_azure_ai_base", + ), + ( + f"{_AZURE_BASE_FILE}::TestDocIntelligenceApiBaseResolution::test_explicit_api_base_is_honoured_for_doc_intelligence", + "document_intelligence_endpoint_honors_explicit_api_base", + ), + ( + f"{_AZURE_BASE_FILE}::TestDocIntelligenceApiBaseResolution::test_generic_azure_ai_base_still_applies_to_mistral_ocr", + "azure_ai_mistral_ocr_uses_generic_api_base", + ), + ), +) + +_REDUCTO_PORT_MAPPINGS: Final = _test_mappings( + _CORE_TARGET, + _REDUCTO_OCR_TESTS, + ( + ( + "tests/test_litellm/llms/reducto/test_parse_v3.py::test_parse_v3_reducto_id_passthrough_skips_upload", + "test_parse_v3_reducto_id_passthrough_skips_upload", + ), + ( + "tests/test_litellm/llms/reducto/test_parse_legacy.py::test_parse_legacy_wraps_enhance_under_options", + "test_parse_legacy_wraps_enhance_under_options", + ), + ( + "tests/test_litellm/llms/reducto/test_upload.py::test_parse_v3_image_data_uri_upload_uses_image_mime", + "test_parse_v3_image_data_uri_upload_uses_image_mime", + ), + ( + "tests/test_litellm/llms/reducto/test_upload.py::test_parse_v3_uses_programmatic_api_key_over_env", + "test_parse_v3_uses_programmatic_api_key_over_env", + ), + ), +) + +_REDUCTO_GATEWAY_MAPPING: Final = TestMapping( + python="tests/test_litellm/llms/reducto/test_parse_v3.py::test_parse_v3_file_upload_and_response_mapping", + rust=_rust_test(_GATEWAY_TARGET, _GATEWAY_OCR_TESTS, "reducto_file_upload_then_parse_maps_response"), +) + +_GATEWAY_PORT_MAPPINGS: Final = _test_mappings( + _GATEWAY_TARGET, + _GATEWAY_PREPARE_OCR_TESTS, + ( + ( + "tests/test_litellm/ocr/test_ocr_native_format.py::test_native_format_rejected_for_provider_without_support_as_bad_request", + "native_format_rejected_for_provider_without_support_as_bad_request", + ), + ( + "tests/test_litellm/ocr/test_ocr_native_format.py::test_unknown_format_rejected_for_provider_without_support_as_bad_request", + "unknown_format_rejected_for_provider_without_support_as_bad_request", + ), + ), +) + +_HOST_ONLY_BRIDGE_EXCLUSIONS: Final = tuple( + MappingExclusionSpec(nodeid=f"{_RUST_BRIDGE_FILE}::{test}", reason=reason) + for test, reason in ( + ("test_ocr_routes_to_rust_when_enabled", "Python selects and invokes the native bridge."), + ("test_ocr_routes_azure_ai_to_rust_when_enabled", "Python resolves provider arguments before the bridge."), + ("test_ocr_rust_path_converts_file_document_before_bridge", "Python converts file inputs before the bridge."), + ( + "test_ocr_exception_type_uses_resolved_provider_context", + "Python wraps bridge exceptions into public errors.", + ), + ("test_aocr_routes_to_async_rust_when_enabled", "Python selects and invokes the async native bridge."), + ("test_aocr_exception_type_uses_resolved_provider_context", "Python wraps async bridge exceptions."), + ("test_ocr_forwards_timeout_to_rust", "Python converts and forwards explicit timeouts."), + ("test_ocr_passes_default_request_timeout_to_rust", "Python supplies its process-level default timeout."), + ("test_ocr_falls_back_to_python_when_bridge_unavailable", "Python owns fallback when the extension is absent."), + ) +) + +_FAMILY_PORT_MAPPINGS: Final = ( + TestMapping( + python=f"{_AZURE_TRANSFORM_FILE}::test_transform_ocr_response_default_format_omits_raw_operation", + rust=_rust_family( + _CORE_TARGET, + _AZURE_OCR_TESTS, + "document_intelligence_default_format_omits_raw_operation", + ), + ), + TestMapping( + python=f"{_AZURE_TRANSFORM_FILE}::test_map_ocr_params_passes_through_req_format", + rust=_rust_family(_CORE_TARGET, _AZURE_OCR_TESTS, "document_intelligence_maps_req_format"), + ), + TestMapping( + python="tests/ocr_tests/test_ocr_vertex_ai.py::test_deepseek_request_uses_single_provider_namespace", + rust=_rust_family( + _CORE_TARGET, + _VERTEX_OCR_TESTS, + "vertex_deepseek_request_uses_single_provider_namespace", + ), + ), + TestMapping( + python="tests/test_litellm/llms/reducto/test_upload.py::test_parse_v3_rejects_plain_http_urls", + rust=_rust_family(_CORE_TARGET, _REDUCTO_OCR_TESTS, "test_parse_v3_rejects_plain_http_urls"), + ), +) + + OCR_CONTRACT: Final = UnitTestContract( mapping=MappingSpec( python_functions=PythonFunctionDiscoverySpec( @@ -71,7 +310,7 @@ OCR_CONTRACT: Final = UnitTestContract( ), TestMapping( python="tests/test_litellm/llms/azure_ai/test_azure_document_intelligence_ocr_transformation.py::test_map_ocr_params_features", - rust=_rust_test(_CORE_TARGET, _AZURE_OCR_TESTS, "document_intelligence_maps_features"), + rust=_rust_family(_CORE_TARGET, _AZURE_OCR_TESTS, "document_intelligence_maps_features"), ), TestMapping( python="tests/test_litellm/llms/azure_ai/test_azure_document_intelligence_ocr_transformation.py::test_map_ocr_params_empty_features_list_omitted", @@ -79,7 +318,11 @@ OCR_CONTRACT: Final = UnitTestContract( ), TestMapping( python="tests/test_litellm/llms/azure_ai/test_azure_document_intelligence_ocr_transformation.py::test_map_ocr_params_invalid_features_raises", - rust=_rust_test(_CORE_TARGET, _AZURE_OCR_TESTS, "document_intelligence_url_rejects_invalid_features"), + rust=_rust_family( + _CORE_TARGET, + _AZURE_OCR_TESTS, + "document_intelligence_mapping_rejects_invalid_features", + ), ), TestMapping( python="tests/test_litellm/llms/azure_ai/test_azure_document_intelligence_ocr_transformation.py::test_get_complete_url_appends_features_query", @@ -145,7 +388,14 @@ OCR_CONTRACT: Final = UnitTestContract( python="tests/test_litellm/llms/mistral/ocr/test_mistral_ocr_transformation.py::TestTransformOcrResponseOcr4Fields::test_ocr4_fields_survive_model_dump", rust=_rust_test(_CORE_TARGET, _MISTRAL_OCR_TESTS, "transform_ocr_response_preserves_ocr4_page_fields"), ), + *_AZURE_PORT_MAPPINGS, + *_REDUCTO_PORT_MAPPINGS, + _REDUCTO_GATEWAY_MAPPING, + *_GATEWAY_PORT_MAPPINGS, + *_FAMILY_PORT_MAPPINGS, ), + exclusions=_HOST_ONLY_BRIDGE_EXCLUSIONS, + require_complete=True, ), unit_parity=UnitParitySpec( python_selectors=( diff --git a/tests/test_rust_python_harness.py b/tests/test_rust_python_harness.py index 72860c427d4..b27d1c83597 100644 --- a/tests/test_rust_python_harness.py +++ b/tests/test_rust_python_harness.py @@ -126,10 +126,13 @@ def test_should_derive_ocr_mapping_status_from_live_tests() -> None: f"Missing Python tests: {list(report.missing_python_tests)}\n" f"Missing Rust tests: {list(report.missing_rust_tests)}\n" f"Duplicate Python mappings: {list(report.duplicate_python_mappings)}\n" + f"Invalid mapping exclusions: {list(report.invalid_mapping_exclusions)}\n" f"Invalid parity exclusions: {list(report.invalid_unit_parity_exclusions)}" ) assert report.mapped_count == len(OCR_CONTRACT.mapping.mappings) - assert report.total_count == report.mapped_count + len(report.unmapped_python_tests) + assert report.total_count == ( + report.mapped_count + len(report.excluded_python_tests) + len(report.unmapped_python_tests) + ) def test_strategy_subcommand_accepts_function_filter(capsys: pytest.CaptureFixture[str]) -> None: