chore: consolidate repeated rmcp tests (modelcontextprotocol#931)

Author: DaleSeo

crates/rmcp/Cargo.toml

@@ -200,6 +200,7 @@ tracing-subscriber = { version = "0.3", features = [
   "fmt",
 ] }
 async-trait = "0.1"
+rstest = "0.26.1"
 [[test]]
 name = "test_tool_macros"
 required-features = ["server", "client"]

crates/rmcp/src/handler/server/common.rs

@@ -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>();
-
-        assert_eq!(schema.get("type"), Some(&serde_json::json!("integer")));
+    #[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!(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"));
-    }
-
-    #[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));
+        assert!(properties.contains_key("value"));
     }
 
-    #[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));
     }
 }

crates/rmcp/src/model/elicitation_schema.rs

@@ -1701,49 +1701,70 @@ impl ElicitationSchemaBuilder {
 #[cfg(test)]
 mod tests {
     use anyhow::anyhow;
+    use rstest::rstest;
     use serde_json::json;
 
     use super::*;
 
-    #[test]
-    fn test_string_schema_serialization() {
-        let schema = StringSchema::email().description("Email address");
-        let json = serde_json::to_value(&schema).unwrap();
-
-        assert_eq!(json["type"], "string");
-        assert_eq!(json["format"], "email");
-        assert_eq!(json["description"], "Email address");
+    fn string_schema_json() -> serde_json::Value {
+        serde_json::to_value(StringSchema::email().description("Email address")).unwrap()
     }
 
-    #[test]
-    fn test_number_schema_serialization() {
-        let schema = NumberSchema::new()
-            .range(0.0, 100.0)
-            .description("Percentage");
-        let json = serde_json::to_value(&schema).unwrap();
-
-        assert_eq!(json["type"], "number");
-        assert_eq!(json["minimum"], 0.0);
-        assert_eq!(json["maximum"], 100.0);
+    fn number_schema_json() -> serde_json::Value {
+        serde_json::to_value(
+            NumberSchema::new()
+                .range(0.0, 100.0)
+                .description("Percentage"),
+        )
+        .unwrap()
     }
 
-    #[test]
-    fn test_integer_schema_serialization() {
-        let schema = IntegerSchema::new().range(0, 150);
-        let json = serde_json::to_value(&schema).unwrap();
-
-        assert_eq!(json["type"], "integer");
-        assert_eq!(json["minimum"], 0);
-        assert_eq!(json["maximum"], 150);
+    fn integer_schema_json() -> serde_json::Value {
+        serde_json::to_value(IntegerSchema::new().range(0, 150)).unwrap()
     }
 
-    #[test]
-    fn test_boolean_schema_serialization() {
-        let schema = BooleanSchema::new().with_default(true);
-        let json = serde_json::to_value(&schema).unwrap();
+    fn boolean_schema_json() -> serde_json::Value {
+        serde_json::to_value(BooleanSchema::new().with_default(true)).unwrap()
+    }
 
-        assert_eq!(json["type"], "boolean");
-        assert_eq!(json["default"], true);
+    #[rstest]
+    #[case::string_schema(
+        string_schema_json,
+        json!({
+            "type": "string",
+            "format": "email",
+            "description": "Email address",
+        })
+    )]
+    #[case::number_schema(
+        number_schema_json,
+        json!({
+            "type": "number",
+            "description": "Percentage",
+            "minimum": 0.0,
+            "maximum": 100.0,
+        })
+    )]
+    #[case::integer_schema(
+        integer_schema_json,
+        json!({
+            "type": "integer",
+            "minimum": 0,
+            "maximum": 150,
+        })
+    )]
+    #[case::boolean_schema(
+        boolean_schema_json,
+        json!({
+            "type": "boolean",
+            "default": true,
+        })
+    )]
+    fn primitive_schema_serializes_to_expected_json(
+        #[case] schema_json: fn() -> serde_json::Value,
+        #[case] expected: serde_json::Value,
+    ) {
+        assert_eq!(schema_json(), expected);
     }
 
     #[test]