simplejrpc 0.1.0

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

use serde_json::{json, Value};
use simplejrpc::valid::{FieldRule, Rule, Validator};
use simplejrpc::validate_object;

#[test]
fn builtin_required_min_range() {
    assert!(FieldRule::Required.check(None).is_err());
    assert!(FieldRule::Required.check(Some(&json!("zack"))).is_ok());
    assert_eq!(
        FieldRule::MinLength(3)
            .check(Some(&json!("ab")))
            .unwrap_err(),
        "min length is 3"
    );
    assert_eq!(
        FieldRule::Range { min: 18, max: 60 }
            .check(Some(&json!(17)))
            .unwrap_err(),
        "must be in [18, 60]"
    );
}

#[test]
fn validator_rules() {
    let v = Validator::new()
        .field("username", FieldRule::Required)
        .field("username", FieldRule::MinLength(3))
        .field("age", FieldRule::Range { min: 18, max: 100 });
    assert!(v.validate(&json!({"username":"zack","age":22})).is_ok());
    assert!(v.validate(&json!({"username":"ab","age":22})).is_err());
    assert!(v.validate(&json!({"username":"zack","age":10})).is_err());

    let r = validate_object!(&json!({"name":""}), "name" => FieldRule::Required,);
    assert!(r.is_err());
}

#[test]
fn custom_password_rule() {
    #[derive(Clone)]
    struct Password {
        min_len: usize,
        require_digit: bool,
    }

    impl Rule for Password {
        fn check(&self, value: Option<&Value>) -> Result<(), String> {
            let Some(Value::String(s)) = value else {
                return Err("must be a string".into());
            };
            if s.len() < self.min_len {
                return Err(format!("min length is {}", self.min_len));
            }
            if self.require_digit && !s.chars().any(|c| c.is_ascii_digit()) {
                return Err("must contain a digit".into());
            }
            Ok(())
        }
    }

    let v = Validator::new()
        .field("password", FieldRule::Required)
        .field(
            "password",
            Password {
                min_len: 8,
                require_digit: true,
            },
        );
    assert!(v.validate(&json!({"password": "secret12"})).is_ok());
    assert!(v.validate(&json!({"password": "short"})).is_err());
    assert!(v.validate(&json!({"password": "nodigit!"})).is_err());
}

#[test]
fn override_via_rule_fn_closure() {
    use simplejrpc::valid::rule_fn;

    let v = Validator::new().field(
        "role",
        rule_fn(|x| match x.and_then(|v| v.as_str()) {
            Some("admin" | "user") => Ok(()),
            _ => Err("role invalid".into()),
        }),
    );
    assert!(v.validate(&json!({"role": "admin"})).is_ok());
    assert!(v.validate(&json!({"role": "guest"})).is_err());
}