modelcontextprotocol/rust-sdk
Watch
1
0
Fork
You've already forked rust-sdk
 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 2

chore: consolidate repeated rmcp tests (#931)

Browse source
This commit is contained in:
Dale Seo 2026-06-26 16:15:20 -04:00 • committed by GitHub
commit e1af378949
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
1 changed files with 306 additions and 332 deletions
Download patch file Download diff file Expand all files Collapse all files

119
crates/rmcp/src/handler/server/common.rs
View file

@ -233,6 +233,8 @@ pub trait AsRequestContext {
#[cfg(test)]
mod tests {
use rstest::rstest;
use super::*;
#[derive(serde::Serialize, serde::Deserialize, JsonSchema)]
@ -245,46 +247,44 @@ mod tests {
value: i32,
}
#[test]
fn test_schema_for_type_handles_primitive() {
let schema = schema_for_type::<i32>();
#[rstest]
#[case::primitive(schema_for_type::<i32>, "integer")]
#[case::array(schema_for_type::<Vec<i32>>, "array")]
#[case::struct_object(schema_for_type::<TestObject>, "object")]
fn schema_for_type_sets_expected_root_type(
#[case] schema_fn: fn() -> Arc<JsonObject>,
#[case] expected_type: &str,
) {
let schema = schema_fn();
assert_eq!(schema.get("type"), Some(&serde_json::json!("integer")));
assert_eq!(schema.get("type"), Some(&serde_json::json!(expected_type)));
}
#[test]
fn test_schema_for_type_handles_array() {
fn schema_for_type_sets_array_item_type() {
let schema = schema_for_type::<Vec<i32>>();
let items = schema.get("items").and_then(|v| v.as_object()).unwrap();
assert_eq!(schema.get("type"), Some(&serde_json::json!("array")));
let items = schema.get("items").and_then(|v| v.as_object());
assert_eq!(
items.unwrap().get("type"),
Some(&serde_json::json!("integer"))
);
assert_eq!(items.get("type"), Some(&serde_json::json!("integer")));
}
#[test]
fn test_schema_for_type_handles_struct() {
fn schema_for_type_sets_struct_properties() {
let schema = schema_for_type::<TestObject>();
let properties = schema
.get("properties")
.and_then(|v| v.as_object())
.unwrap();
assert_eq!(schema.get("type"), Some(&serde_json::json!("object")));
let properties = schema.get("properties").and_then(|v| v.as_object());
assert!(properties.unwrap().contains_key("value"));
assert!(properties.contains_key("value"));
}
#[test]
fn test_schema_for_type_caches_primitive_types() {
let schema1 = schema_for_type::<i32>();
let schema2 = schema_for_type::<i32>();
assert!(Arc::ptr_eq(&schema1, &schema2));
}
#[test]
fn test_schema_for_type_caches_struct_types() {
let schema1 = schema_for_type::<TestObject>();
let schema2 = schema_for_type::<TestObject>();
#[rstest]
#[case::primitive(schema_for_type::<i32>)]
#[case::struct_object(schema_for_type::<TestObject>)]
fn test_schema_for_type_caches_schemas(#[case] schema_fn: fn() -> Arc<JsonObject>) {
let schema1 = schema_fn();
let schema2 = schema_fn();
assert!(Arc::ptr_eq(&schema1, &schema2));
}
@ -305,51 +305,36 @@ mod tests {
assert!(Arc::ptr_eq(&schema, &cloned));
}
#[test]
fn test_schema_for_output_rejects_primitive() {
let result = schema_for_output::<i32>();
assert!(result.is_err(),);
}
#[test]
fn test_schema_for_output_accepts_object() {
let result = schema_for_output::<TestObject>();
assert!(result.is_ok(),);
}
#[test]
fn test_schema_for_output_strips_top_level_title() {
let schema = schema_for_output::<TestObject>().unwrap();
assert!(!schema.contains_key("title"));
}
#[test]
fn test_schema_for_output_strips_top_level_description() {
let schema = schema_for_output::<TestObject>().unwrap();
assert!(!schema.contains_key("description"));
}
#[test]
fn test_schema_for_input_rejects_primitive() {
let result = schema_for_input::<i32>();
#[rstest]
#[case::output(schema_for_output::<i32>)]
#[case::input(schema_for_input::<i32>)]
fn test_schema_for_object_wrappers_reject_primitives(
#[case] schema_fn: fn() -> Result<Arc<JsonObject>, String>,
) {
let result = schema_fn();
assert!(result.is_err());
}
#[test]
fn test_schema_for_input_accepts_object() {
let result = schema_for_input::<TestObject>();
#[rstest]
#[case::output(schema_for_output::<TestObject>)]
#[case::input(schema_for_input::<TestObject>)]
fn test_schema_for_object_wrappers_accept_objects(
#[case] schema_fn: fn() -> Result<Arc<JsonObject>, String>,
) {
let result = schema_fn();
assert!(result.is_ok());
}
#[test]
fn test_schema_for_input_strips_top_level_title() {
let schema = schema_for_input::<TestObject>().unwrap();
assert!(!schema.contains_key("title"));
}
#[test]
fn test_schema_for_input_strips_top_level_description() {
let schema = schema_for_input::<TestObject>().unwrap();
assert!(!schema.contains_key("description"));
#[rstest]
#[case::output_title(schema_for_output::<TestObject>, "title")]
#[case::output_description(schema_for_output::<TestObject>, "description")]
#[case::input_title(schema_for_input::<TestObject>, "title")]
#[case::input_description(schema_for_input::<TestObject>, "description")]
fn test_schema_for_object_wrappers_strip_top_level_metadata(
#[case] schema_fn: fn() -> Result<Arc<JsonObject>, String>,
#[case] field: &str,
) {
let schema = schema_fn().unwrap();
assert!(!schema.contains_key(field));
}
}