136 lines
4.0 KiB
Rust
136 lines
4.0 KiB
Rust
use crate::prelude::*;
|
|
use regex::Regex;
|
|
use validator::Validate;
|
|
|
|
const ONE: f32 = 1.0;
|
|
const HUNDRED: f32 = 10.0;
|
|
|
|
// In real code, this would use something like a LazyLock
|
|
fn hello_regex() -> Regex {
|
|
Regex::new(r"^[Hh]ello").unwrap()
|
|
}
|
|
|
|
#[derive(JsonSchema, Deserialize, Serialize, Validate)]
|
|
pub struct ValidateAttrStruct {
|
|
#[validate(range(min = 1.0, max = 100.0))]
|
|
min_max: f32,
|
|
#[validate(range(min = ONE, max = HUNDRED))]
|
|
min_max2: f32,
|
|
#[validate(regex(path = hello_regex()))]
|
|
regex_str: String,
|
|
#[validate(contains(pattern = "substring..."))]
|
|
contains_str: String,
|
|
#[validate(email)]
|
|
email_address: String,
|
|
#[validate(url)]
|
|
homepage: String,
|
|
#[validate(length(min = 1, max = 100))]
|
|
non_empty_str: String,
|
|
#[validate(length(equal = 2))]
|
|
pair: Vec<String>,
|
|
#[validate(required)]
|
|
required_option: Option<bool>,
|
|
#[validate(required, nested)]
|
|
#[serde(flatten)]
|
|
required_flattened: Option<ValidateAttrInner>,
|
|
}
|
|
|
|
#[derive(JsonSchema, Deserialize, Serialize, Validate)]
|
|
pub struct ValidateAttrInner {
|
|
#[validate(range(min = -100, max = 100))]
|
|
x: i32,
|
|
}
|
|
|
|
impl Default for ValidateAttrStruct {
|
|
fn default() -> Self {
|
|
Self {
|
|
min_max: 1.0,
|
|
min_max2: 1.0,
|
|
regex_str: "Hello world".to_owned(),
|
|
contains_str: "Contains substring...".to_owned(),
|
|
email_address: "test@test.test".to_owned(),
|
|
homepage: "http://test.test".to_owned(),
|
|
non_empty_str: "test".to_owned(),
|
|
pair: vec!["a".to_owned(), "b".to_owned()],
|
|
required_option: Some(true),
|
|
required_flattened: Some(ValidateAttrInner { x: 0 }),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ValidateAttrStruct {
|
|
pub fn invalid_values() -> impl IntoIterator<Item = Self> {
|
|
static MUTATORS: &[fn(&mut ValidateAttrStruct)] = &[
|
|
|v| v.min_max = 0.9,
|
|
|v| v.min_max = 100.1,
|
|
|v| v.min_max2 = 0.9,
|
|
|v| v.min_max2 = 100.1,
|
|
|v| v.regex_str = "fail".to_owned(),
|
|
|v| v.contains_str = "fail".to_owned(),
|
|
|v| v.email_address = "fail".to_owned(),
|
|
|v| v.homepage = "fail".to_owned(),
|
|
|v| v.non_empty_str = String::new(),
|
|
|v| v.pair = Vec::new(),
|
|
|v| v.pair = vec!["a".to_owned(), "b".to_owned(), "c".to_owned()],
|
|
|v| v.required_option = None,
|
|
|v| v.required_flattened = None,
|
|
|v| v.required_flattened = Some(ValidateAttrInner { x: -101 }),
|
|
|v| v.required_flattened = Some(ValidateAttrInner { x: 101 }),
|
|
];
|
|
MUTATORS.iter().map(|f| {
|
|
let mut result = ValidateAttrStruct::default();
|
|
f(&mut result);
|
|
result
|
|
})
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn validate_attrs() {
|
|
test!(ValidateAttrStruct)
|
|
.with_validator(|v| v.validate().is_ok())
|
|
.assert_snapshot()
|
|
.assert_allows_ser_roundtrip_default()
|
|
.assert_rejects_invalid(ValidateAttrStruct::invalid_values())
|
|
.assert_matches_de_roundtrip(arbitrary_values());
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(JsonSchema)]
|
|
#[schemars(rename = "ValidateAttrStruct")]
|
|
pub struct SchemarsAttrStruct {
|
|
#[schemars(range(min = 1.0, max = 100.0))]
|
|
min_max: f32,
|
|
#[schemars(range(min = ONE, max = HUNDRED))]
|
|
min_max2: f32,
|
|
#[schemars(regex(pattern = hello_regex()))]
|
|
regex_str: String,
|
|
#[schemars(contains(pattern = "substring..."))]
|
|
contains_str: String,
|
|
#[schemars(email)]
|
|
email_address: String,
|
|
#[schemars(url)]
|
|
homepage: String,
|
|
#[schemars(length(min = 1, max = 100))]
|
|
non_empty_str: String,
|
|
#[schemars(length(equal = 2))]
|
|
pair: Vec<String>,
|
|
#[schemars(required)]
|
|
required_option: Option<bool>,
|
|
#[schemars(required)]
|
|
#[serde(flatten)]
|
|
required_flattened: Option<SchemarsAttrInner>,
|
|
}
|
|
|
|
#[allow(dead_code)]
|
|
#[derive(JsonSchema)]
|
|
pub struct SchemarsAttrInner {
|
|
#[schemars(range(min = -100, max = 100))]
|
|
x: i32,
|
|
}
|
|
|
|
#[test]
|
|
fn schemars_attrs() {
|
|
test!(SchemarsAttrStruct).assert_identical::<ValidateAttrStruct>();
|
|
}
|