test(sidecar): add isolated SGLang unit coverage

lib/sidecar/sglang/Cargo.toml

@@ -45,3 +45,4 @@ tonic-build = { workspace = true }
 
 [dev-dependencies]
 dynamo-backend-common = { workspace = true, features = ["testing"] }
+tracing-subscriber = { workspace = true }

lib/sidecar/sglang/src/client.rs

@@ -369,12 +369,16 @@ pub fn status_to_dynamo(rpc: &str, status: tonic::Status) -> DynamoError {
 mod tests {
     use std::time::Duration;
 
+    use dynamo_backend_common::{BackendError, ErrorType};
     use serde_json::json;
     use tokio::net::TcpListener;
     use tokio::time::Instant;
     use tonic::transport::Endpoint;
 
-    use super::{client_from_channel, discover, json_u32, json_u64, parse_discovery};
+    use super::{
+        client_from_channel, discover, json_u32, json_u64, parse_discovery, rpc_with_deadline,
+        status_to_dynamo,
+    };
     use crate::proto as pb;
 
     #[test]
@@ -383,6 +387,25 @@ mod tests {
         assert_eq!(json_u64(&value, "a"), Some(16));
         assert_eq!(json_u32(&value, "b"), Some(32));
         assert_eq!(json_u64(&value, "c"), None);
+        for value in [json!(u64::MAX), json!(u64::MAX.to_string())] {
+            let info = json!({"limit": value});
+            assert_eq!(json_u64(&info, "limit"), Some(u64::MAX));
+            assert_eq!(json_u32(&info, "limit"), None);
+        }
+        for value in [json!(u32::MAX), json!(u32::MAX.to_string())] {
+            assert_eq!(json_u32(&json!({"limit": value}), "limit"), Some(u32::MAX));
+        }
+        for value in [
+            json!(null),
+            json!(true),
+            json!(1.5),
+            json!("-1"),
+            json!("1.5"),
+            json!("18446744073709551616"),
+        ] {
+            assert_eq!(json_u64(&json!({"limit": value}), "limit"), None);
+        }
+        assert_eq!(json_u32(&json!({}), "limit"), None);
     }
 
     #[test]
@@ -404,19 +427,244 @@ mod tests {
 
     #[test]
     fn discovery_requires_incremental_streaming() {
-        let error = parse_discovery(
-            pb::GetModelInfoResponse {
-                model_path: "model-repo".to_string(),
-                json_info: "{}".to_string(),
-            },
-            pb::GetServerInfoResponse {
-                json_info: json!({"incremental_streaming_output": false}).to_string(),
-            },
-            Vec::new(),
-        )
-        .unwrap_err()
-        .to_string();
-        assert!(error.contains("--incremental-streaming-output"), "{error}");
+        for info in [
+            json!({}),
+            json!({"incremental_streaming_output": false}),
+            json!({"incremental_streaming_output": "true"}),
+            json!({"incremental_streaming_output": null}),
+        ] {
+            let error = parse_discovery(
+                pb::GetModelInfoResponse {
+                    model_path: "model-repo".to_string(),
+                    json_info: "{}".to_string(),
+                },
+                pb::GetServerInfoResponse {
+                    json_info: info.to_string(),
+                },
+                Vec::new(),
+            )
+            .unwrap_err();
+            assert_eq!(
+                error.error_type(),
+                ErrorType::Backend(BackendError::InvalidArgument)
+            );
+            assert!(
+                error.to_string().contains("--incremental-streaming-output"),
+                "{error}"
+            );
+        }
+    }
+
+    #[test]
+    fn discovery_rejects_malformed_json_and_non_object_metadata() {
+        for label in ["GetModelInfo.json_info", "GetServerInfo.json_info"] {
+            for raw in ["{", "null", "[]", "1", "\"metadata\""] {
+                let error = parse_discovery(
+                    pb::GetModelInfoResponse {
+                        model_path: "model".into(),
+                        json_info: if label.starts_with("GetModelInfo") {
+                            raw
+                        } else {
+                            "{}"
+                        }
+                        .into(),
+                    },
+                    pb::GetServerInfoResponse {
+                        json_info: if label.starts_with("GetServerInfo") {
+                            raw.into()
+                        } else {
+                            json!({"incremental_streaming_output": true}).to_string()
+                        },
+                    },
+                    vec![],
+                )
+                .unwrap_err();
+                assert_eq!(
+                    error.error_type(),
+                    ErrorType::Backend(BackendError::Unknown)
+                );
+                assert!(error.to_string().contains(label), "{raw}: {error}");
+            }
+        }
+    }
+
+    #[test]
+    fn discovery_resolves_model_path_and_tokenizer_fallbacks() {
+        for (native_path, json_path, expected) in [
+            ("native-model", "json-model", Some("native-model")),
+            (" ", "json-model", Some("json-model")),
+            ("", " ", None),
+        ] {
+            for tokenizer in [json!(null), json!(""), json!(" "), json!(7)] {
+                let result = parse_discovery(
+                    pb::GetModelInfoResponse {
+                        model_path: native_path.into(),
+                        json_info: json!({"model_path": json_path, "tokenizer_path": tokenizer})
+                            .to_string(),
+                    },
+                    pb::GetServerInfoResponse {
+                        json_info: json!({"incremental_streaming_output": true}).to_string(),
+                    },
+                    vec![],
+                );
+                if let Some(expected) = expected {
+                    let info = result.unwrap();
+                    assert_eq!(info.model_path, expected);
+                    assert_eq!(info.tokenizer_path, expected);
+                    assert_eq!(info.served_model_name, None);
+                    assert_eq!(info.max_model_len, None);
+                } else {
+                    let error = result.unwrap_err();
+                    assert_eq!(
+                        error.error_type(),
+                        ErrorType::Backend(BackendError::Unknown)
+                    );
+                    assert!(error.to_string().contains("empty model_path"));
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn discovery_prefers_matching_model_and_server_alias() {
+        for (id, root, fallback_name) in [
+            ("card-alias", "model", Some("card-alias")),
+            ("model", "different-root", None),
+        ] {
+            for server_name in [None, Some("server-alias")] {
+                let model_info = json!({"tokenizer_path": "tokenizer", "custom": [1, 2]});
+                let server_info = json!({
+                    "incremental_streaming_output": true,
+                    "served_model_name": server_name,
+                    "context_length": 1024,
+                });
+                let info = parse_discovery(
+                    pb::GetModelInfoResponse {
+                        model_path: "model".into(),
+                        json_info: model_info.to_string(),
+                    },
+                    pb::GetServerInfoResponse {
+                        json_info: server_info.to_string(),
+                    },
+                    vec![
+                        pb::ModelCard {
+                            id: "unrelated".into(),
+                            max_model_len: Some(512),
+                            ..Default::default()
+                        },
+                        pb::ModelCard {
+                            id: id.into(),
+                            root: root.into(),
+                            max_model_len: Some(4096),
+                            ..Default::default()
+                        },
+                    ],
+                )
+                .unwrap();
+                assert_eq!(
+                    info.served_model_name.as_deref(),
+                    server_name.or(fallback_name)
+                );
+                assert_eq!(info.max_model_len, Some(4096));
+                assert_eq!(info.model_info, model_info);
+                assert_eq!(info.server_info, server_info);
+            }
+        }
+    }
+
+    #[test]
+    fn discovery_falls_back_to_first_card_and_valid_server_limits() {
+        for (card_limit, context, input_limit, expected) in [
+            (Some(2048), json!(4096), json!(8192), Some(2048)),
+            (Some(-1), json!("4096"), json!(8192), Some(4096)),
+            (
+                None,
+                json!(u64::from(u32::MAX) + 1),
+                json!("8192"),
+                Some(8192),
+            ),
+            (None, json!(null), json!(-1), None),
+        ] {
+            let info = parse_discovery(
+                pb::GetModelInfoResponse {
+                    model_path: "model".into(),
+                    json_info: "{}".into(),
+                },
+                pb::GetServerInfoResponse {
+                    json_info: json!({
+                        "incremental_streaming_output": true,
+                        "served_model_name": "",
+                        "context_length": context,
+                        "max_req_input_len": input_limit,
+                    })
+                    .to_string(),
+                },
+                vec![pb::ModelCard {
+                    id: "first-alias".into(),
+                    max_model_len: card_limit,
+                    ..Default::default()
+                }],
+            )
+            .unwrap();
+            assert_eq!(info.served_model_name.as_deref(), Some("first-alias"));
+            assert_eq!(info.max_model_len, expected);
+        }
+    }
+
+    #[test]
+    fn rpc_status_mapping_preserves_error_kind_and_context() {
+        for (code, kind) in [
+            (tonic::Code::InvalidArgument, BackendError::InvalidArgument),
+            (tonic::Code::NotFound, BackendError::InvalidArgument),
+            (tonic::Code::OutOfRange, BackendError::InvalidArgument),
+            (tonic::Code::Unavailable, BackendError::CannotConnect),
+            (tonic::Code::Cancelled, BackendError::Cancelled),
+            (
+                tonic::Code::DeadlineExceeded,
+                BackendError::ConnectionTimeout,
+            ),
+            (tonic::Code::Internal, BackendError::Unknown),
+        ] {
+            let error =
+                status_to_dynamo("GetModelInfo", tonic::Status::new(code, "native failure"));
+            assert_eq!(error.error_type(), ErrorType::Backend(kind));
+            assert!(error.to_string().contains("GetModelInfo: native failure"));
+            assert!(error.to_string().contains(&format!("{code:?}")));
+        }
+    }
+
+    #[tokio::test]
+    async fn rpc_deadline_preserves_success_status_and_timeout() {
+        let deadline = Instant::now() + Duration::from_secs(60);
+        assert_eq!(
+            rpc_with_deadline("HealthCheck", deadline, async { Ok(17) })
+                .await
+                .unwrap(),
+            17
+        );
+        let error = rpc_with_deadline::<(), _>("HealthCheck", deadline, async {
+            Err(tonic::Status::unavailable("offline"))
+        })
+        .await
+        .unwrap_err();
+        assert_eq!(
+            error.error_type(),
+            ErrorType::Backend(BackendError::CannotConnect)
+        );
+
+        let error =
+            rpc_with_deadline::<(), _>("HealthCheck", Instant::now(), std::future::pending())
+                .await
+                .unwrap_err();
+        assert_eq!(
+            error.error_type(),
+            ErrorType::Backend(BackendError::ConnectionTimeout)
+        );
+        assert!(
+            error
+                .to_string()
+                .contains("HealthCheck exceeded the configured deadline")
+        );
     }
 
     #[tokio::test]