pmcp 2.4.0

High-quality Rust SDK for Model Context Protocol (MCP) with full TypeScript SDK compatibility
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

//! Property-based tests for RequestHandlerExtra.extensions typemap.
//!
//! Covers: insert/get round-trip, key-collision returns old value, clone
//! preserves extensions, `remove::<T>()` round-trip, mixed-type coexistence.

use pmcp::RequestHandlerExtra;
use proptest::prelude::*;

proptest! {
    #![proptest_config(ProptestConfig { cases: 100, .. ProptestConfig::default() })]

    /// 70-01-02: Insert + get of a typed value yields the same value.
    #[test]
    fn prop_extensions_insert_get_roundtrip(key in ".{0,64}", value in any::<u64>()) {
        let mut extra = RequestHandlerExtra::default();
        let pair = (key.clone(), value);
        extra.extensions_mut().insert(pair.clone());
        let retrieved = extra.extensions().get::<(String, u64)>();
        prop_assert_eq!(retrieved, Some(&pair));
    }

    /// 70-01-03 (property-reinforced): inserting same type twice returns Some(old).
    #[test]
    fn prop_extensions_key_collision_returns_old_value(v1: u64, v2: u64) {
        let mut extra = RequestHandlerExtra::default();
        prop_assert_eq!(extra.extensions_mut().insert(v1), None);
        prop_assert_eq!(extra.extensions_mut().insert(v2), Some(v1));
        prop_assert_eq!(extra.extensions().get::<u64>(), Some(&v2));
    }

    /// 70-01-04: extra.clone() preserves extensions key set.
    #[test]
    fn prop_extra_clone_preserves_extensions(value in ".{1,64}") {
        let mut extra = RequestHandlerExtra::default();
        extra.extensions_mut().insert(value.clone());
        let cloned = extra.clone();
        prop_assert_eq!(cloned.extensions().get::<String>(), Some(&value));
        prop_assert_eq!(extra.extensions().get::<String>(), Some(&value));
    }

    /// NEW per Codex review LOW: remove<T>() returns the value when present, None after.
    #[test]
    fn prop_extensions_remove_returns_value(v: u64) {
        let mut extra = RequestHandlerExtra::default();
        extra.extensions_mut().insert(v);
        prop_assert_eq!(extra.extensions_mut().remove::<u64>(), Some(v));
        prop_assert_eq!(extra.extensions_mut().remove::<u64>(), None);
        prop_assert_eq!(extra.extensions().get::<u64>(), None);
    }

    /// NEW per Codex review LOW: two values of DIFFERENT types coexist without interference.
    #[test]
    fn prop_extensions_two_types_coexist(s in ".{1,64}", n: u64) {
        let mut extra = RequestHandlerExtra::default();
        extra.extensions_mut().insert(s.clone());
        extra.extensions_mut().insert(n);
        prop_assert_eq!(extra.extensions().get::<String>(), Some(&s));
        prop_assert_eq!(extra.extensions().get::<u64>(), Some(&n));
        // Removing one does not affect the other
        extra.extensions_mut().remove::<u64>();
        prop_assert_eq!(extra.extensions().get::<String>(), Some(&s));
        prop_assert_eq!(extra.extensions().get::<u64>(), None);
    }
}