simplejrpc 0.1.0

Unix-socket JSON-RPC 2.0 SDK with middleware, config, and validation
Documentation
//! Public API tests for `Request` extensibility.

use std::collections::HashMap;

use serde_json::{json, Value};
use simplejrpc::server::{Request, RequestMut, RequestView};

#[test]
fn parts_roundtrip() {
    let mut req = Request::new("m", json!({"a": 1}), json!(9));
    req.set_extension("k", json!(true));
    let (method, params, id, ext) = req.into_parts();
    let again = Request::from_parts(method, params, id, ext);
    assert_eq!(again.method(), "m");
    assert_eq!(again.param_i64("a"), Some(1));
    assert_eq!(again.extension("k"), Some(&json!(true)));
}

#[test]
fn mutate_via_trait() {
    let mut req = Request::new("m", json!({"n": 1}), json!(1));
    *RequestMut::params_mut(&mut req) = json!({"n": 2});
    RequestMut::extensions_mut(&mut req).insert("lang".into(), json!("en"));
    assert_eq!(req.param_i64("n"), Some(2));
    assert_eq!(req.extension("lang"), Some(&json!("en")));
}

#[test]
fn override_param_str_via_wrapper() {
    struct Masked(Request);

    impl RequestView for Masked {
        fn method(&self) -> &str {
            self.0.method()
        }
        fn params_raw(&self) -> &Value {
            self.0.params_raw()
        }
        fn id(&self) -> &Value {
            self.0.id()
        }
        fn extension(&self, key: &str) -> Option<&Value> {
            self.0.extension(key)
        }
        fn param_str(&self, key: &str) -> Option<&str> {
            if key == "secret" {
                return Some("***");
            }
            self.params_raw().get(key)?.as_str()
        }
    }

    let m = Masked(Request::from_parts(
        "login".into(),
        json!({"secret": "pw", "user": "zack"}),
        json!(1),
        HashMap::new(),
    ));
    assert_eq!(RequestView::param_str(&m, "secret"), Some("***"));
    assert_eq!(RequestView::param_str(&m, "user"), Some("zack"));
    assert_eq!(RequestView::param_i64(&m, "missing"), None);
}


#[test]
fn override_params_deserialize() {
    use serde::Deserialize;

    struct Strict(Request);

    impl RequestView for Strict {
        fn method(&self) -> &str {
            self.0.method()
        }
        fn params_raw(&self) -> &Value {
            self.0.params_raw()
        }
        fn id(&self) -> &Value {
            self.0.id()
        }
        fn extension(&self, key: &str) -> Option<&Value> {
            self.0.extension(key)
        }
        fn params<T: serde::de::DeserializeOwned>(&self) -> simplejrpc::Result<T> {
            let v = self.params_raw();
            if v.get("legacy").is_some() {
                return Err(simplejrpc::Error::Validation("legacy field banned".into()));
            }
            serde_json::from_value(v.clone()).map_err(Into::into)
        }
    }

    #[derive(Debug, Deserialize, PartialEq)]
    struct Body {
        a: i64,
    }

    let ok = Strict(Request::new("m", json!({"a": 1}), json!(1)));
    assert_eq!(RequestView::params::<Body>(&ok).unwrap(), Body { a: 1 });

    let bad = Strict(Request::new("m", json!({"a": 1, "legacy": true}), json!(1)));
    assert!(RequestView::params::<Body>(&bad).is_err());
}