use paste::paste;
use dade::{model, Error, Model, Result};
macro_rules! success_parse_model {
($model: ident, $in_string:literal, $out_string:literal) => {
let ret = $model::parse($in_string);
assert!(ret.is_ok());
let val = ret.unwrap();
assert_eq!(val.json(false), $out_string);
};
}
#[test]
fn test_empty_model() {
#[model]
struct TestModel;
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(TestModel, "{}", "{}");
success_parse_model!(TestModel, "{\"abc\":1}", "{}");
assert!(TestModel::parse("[]").is_err());
assert!(TestModel::parse("1").is_err());
assert!(TestModel::parse("1.0").is_err());
assert!(TestModel::parse("null").is_err());
assert!(TestModel::parse("true").is_err());
assert!(TestModel::parse("false").is_err());
assert!(TestModel::parse("\"abc\"").is_err());
}
#[test]
fn test_null_model() {
#[model]
struct TestModel {
v1: (),
#[field(alias = "c2", default = null)]
v2: (),
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\"default\":null,\"title\":\"C2\",\"type\":\"null\"},\
\"v1\":{\"title\":\"V1\",\"type\":\"null\"}\
},\
\"required\":[\"v1\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(TestModel, "{\"v1\":null}", "{\"c2\":null,\"v1\":null}");
success_parse_model!(
TestModel,
"{\"v1\":null,\"c2\":null}",
"{\"c2\":null,\"v1\":null}"
);
assert!(TestModel::parse("{}").is_err());
assert!(TestModel::parse("{\"c2\":null}").is_err());
}
#[test]
fn test_bool_model() {
fn validate_fn(value: bool) -> Result<bool> {
if value {
Ok(value)
} else {
Err(Error::validate_err("only true"))
}
}
#[model]
struct TestModel {
b1: bool,
#[field(default = false, alias = "c2")]
b2: bool,
#[field(validate = validate_fn)]
b3: bool,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"b1\":{\"title\":\"B1\",\"type\":\"boolean\"},\
\"b3\":{\"title\":\"B3\",\"type\":\"boolean\"},\
\"c2\":{\"default\":false,\"title\":\"C2\",\"type\":\"boolean\"}\
},\
\"required\":[\"b1\",\"b3\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"b1\": true,\"b3\": true}",
"{\"b1\":true,\"b3\":true,\"c2\":false}"
);
success_parse_model!(
TestModel,
"{\"b1\": false,\"b3\": true}",
"{\"b1\":false,\"b3\":true,\"c2\":false}"
);
success_parse_model!(
TestModel,
"{\"c2\":false, \"b1\": true,\"b3\": true}",
"{\"b1\":true,\"b3\":true,\"c2\":false}"
);
success_parse_model!(
TestModel,
"{\"c2\":false, \"b1\": false,\"b3\": true}",
"{\"b1\":false,\"b3\":true,\"c2\":false}"
);
success_parse_model!(
TestModel,
"{\"c2\":true, \"b1\": true,\"b3\": true}",
"{\"b1\":true,\"b3\":true,\"c2\":true}"
);
success_parse_model!(
TestModel,
"{\"c2\":true, \"b1\": false,\"b3\": true}",
"{\"b1\":false,\"b3\":true,\"c2\":true}"
);
assert!(TestModel::parse("{\"b1\": true}").is_err());
assert!(TestModel::parse("{\"b3\": true}").is_err());
assert!(TestModel::parse("{\"c2\":true, \"b1\": false,\"b3\": false}").is_err());
}
macro_rules! test_signed_integer_model {
($ty: ident) => {
paste! {
#[test]
fn [<test_ $ty _model>] () {
fn validate_fn(value: $ty) -> Result<$ty> {
if value > 0 {
Ok(value)
} else {
Err(Error::validate_err("only positive"))
}
}
#[model]
struct TestModel {
v1: $ty,
#[field(default = 0, alias = "c2")]
v2: $ty,
#[field(validate = validate_fn)]
v3: $ty,
#[field(ge = 1, le = 10)]
v4: $ty,
#[field(gt = 1, lt = 10)]
v5: $ty,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\"default\":0,\"title\":\"C2\",\"type\":\"integer\"},\
\"v1\":{\"title\":\"V1\",\"type\":\"integer\"},\
\"v3\":{\"title\":\"V3\",\"type\":\"integer\"},\
\"v4\":{\"maximum\":10,\"minimum\":1,\"title\":\"V4\",\"type\":\"integer\"},\
\"v5\":{\"exclusiveMaximum\":10,\"exclusiveMinimum\":1,\"title\":\"V5\",\"type\":\"integer\"}\
},\
\"required\":[\"v1\",\"v3\",\"v4\",\"v5\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 2}",
"{\"c2\":0,\"v1\":0,\"v3\":1,\"v4\":1,\"v5\":2}"
);
success_parse_model!(
TestModel,
"{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 2,\"c2\":-2}",
"{\"c2\":-2,\"v1\":0,\"v3\":1,\"v4\":1,\"v5\":2}"
);
assert!(TestModel::parse("{\"v3\": 1,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 1}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": -1,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 0,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 1}").is_err());
}
}
};
( $( $ty:ident ),* ) => { $( test_signed_integer_model!($ty); )* };
}
test_signed_integer_model!(i8, i16, i32, i64, i128, isize);
macro_rules! test_unsigned_integer_model {
($ty: ident) => {
paste! {
#[test]
fn [<test_ $ty _model>] () {
fn validate_fn(value: $ty) -> Result<$ty> {
if value > 0 {
Ok(value)
} else {
Err(Error::validate_err("only positive"))
}
}
#[model]
struct TestModel {
v1: $ty,
#[field(default = 0, alias = "c2")]
v2: $ty,
#[field(validate = validate_fn)]
v3: $ty,
#[field(ge = 1, le = 10)]
v4: $ty,
#[field(gt = 1, lt = 10)]
v5: $ty,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\"default\":0,\"title\":\"C2\",\"type\":\"integer\"},\
\"v1\":{\"title\":\"V1\",\"type\":\"integer\"},\
\"v3\":{\"title\":\"V3\",\"type\":\"integer\"},\
\"v4\":{\"maximum\":10,\"minimum\":1,\"title\":\"V4\",\"type\":\"integer\"},\
\"v5\":{\"exclusiveMaximum\":10,\"exclusiveMinimum\":1,\"title\":\"V5\",\"type\":\"integer\"}\
},\
\"required\":[\"v1\",\"v3\",\"v4\",\"v5\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 2}",
"{\"c2\":0,\"v1\":0,\"v3\":1,\"v4\":1,\"v5\":2}"
);
success_parse_model!(
TestModel,
"{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 2,\"c2\":10}",
"{\"c2\":10,\"v1\":0,\"v3\":1,\"v4\":1,\"v5\":2}"
);
assert!(TestModel::parse("{\"v3\": 1,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 1}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 0,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 0,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 1}").is_err());
}
}
};
( $( $ty:ident ),* ) => { $( test_unsigned_integer_model!($ty); )* };
}
test_unsigned_integer_model!(u8, u16, u32, u64, u128, usize);
macro_rules! test_float_model {
($ty: ident) => {
paste! {
#[test]
fn [<test_ $ty _model>] () {
fn validate_fn(value: $ty) -> Result<$ty> {
if value > 0.0 {
Ok(value)
} else {
Err(Error::validate_err("only positive"))
}
}
#[model]
struct TestModel {
v1: $ty,
#[field(default = 0.0, alias = "c2")]
v2: $ty,
#[field(validate = validate_fn)]
v3: $ty,
#[field(ge = 1.0, le = 10.0)]
v4: $ty,
#[field(gt = 1.0, lt = 10.0)]
v5: $ty,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\"default\":0,\"title\":\"C2\",\"type\":\"number\"},\
\"v1\":{\"title\":\"V1\",\"type\":\"number\"},\
\"v3\":{\"title\":\"V3\",\"type\":\"number\"},\
\"v4\":{\"maximum\":10,\"minimum\":1,\"title\":\"V4\",\"type\":\"number\"},\
\"v5\":{\"exclusiveMaximum\":10,\"exclusiveMinimum\":1,\"title\":\"V5\",\"type\":\"number\"}\
},\
\"required\":[\"v1\",\"v3\",\"v4\",\"v5\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 2}",
"{\"c2\":0,\"v1\":0,\"v3\":1,\"v4\":1,\"v5\":2}"
);
success_parse_model!(
TestModel,
"{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 2,\"c2\":-2.1}",
"{\"c2\":-2.1,\"v1\":0,\"v3\":1,\"v4\":1,\"v5\":2}"
);
assert!(TestModel::parse("{\"v3\": 1,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 1}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 0,\"v4\": 1,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 0,\"v5\": 2}").is_err());
assert!(TestModel::parse("{\"v1\": 0,\"v3\": 1,\"v4\": 1,\"v5\": 1}").is_err());
}
}
};
( $( $ty:ident ),* ) => { $( test_float_model!($ty); )* };
}
test_float_model!(f32, f64);
#[test]
fn test_string_model() {
fn validate_fn(value: String) -> Result<String> {
Ok(format!("Hello, {}", value))
}
#[model]
struct TestModel {
v1: String,
#[field(default = "DEFAULT", alias = "c2")]
v2: String,
#[field(validate = validate_fn)]
v3: String,
#[field(min_length = 1, max_length = 10)]
v4: String,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\"default\":\"DEFAULT\",\"title\":\"C2\",\"type\":\"string\"},\
\"v1\":{\"title\":\"V1\",\"type\":\"string\"},\
\"v3\":{\"title\":\"V3\",\"type\":\"string\"},\
\"v4\":{\"maxLength\":10,\"minLength\":1,\"title\":\"V4\",\"type\":\"string\"}\
},\
\"required\":[\"v1\",\"v3\",\"v4\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"v1\":\"\",\"v3\":\"value3\",\"v4\":\"value4\"}",
"{\"c2\":\"DEFAULT\",\"v1\":\"\",\"v3\":\"Hello, value3\",\"v4\":\"value4\"}"
);
success_parse_model!(
TestModel,
"{\"v1\":\"value1\",\"v3\":\"value3\",\"v4\":\"value4\",\"c2\":\"any string\"}",
"{\"c2\":\"any string\",\"v1\":\"value1\",\"v3\":\"Hello, value3\",\"v4\":\"value4\"}"
);
assert!(TestModel::parse("{\"v3\": \"value3\",\"v4\": \"value4\"}").is_err());
assert!(TestModel::parse("{\"v1\": \"value1\",\"v4\": \"value4\"}").is_err());
assert!(TestModel::parse("{\"v1\": \"value1\",\"v3\": \"value3\"}").is_err());
assert!(TestModel::parse("{\"v1\": \"value1\",\"v3\": \"value3\",\"v4\": \"\"}").is_err());
assert!(
TestModel::parse("{\"v1\": \"value1\",\"v3\": \"value3\",\"v4\": \"12345678901\"}")
.is_err()
);
}
#[test]
fn test_vec_model() {
fn validate_fn(value: Vec<()>) -> Result<Vec<()>> {
let mut new_value = Vec::from(value);
new_value.push(());
Ok(new_value)
}
#[model]
struct TestModel {
v1: Vec<()>,
#[field(alias = "c2")]
v2: Vec<()>,
#[field(validate = validate_fn)]
v3: Vec<()>,
#[field(min_items = 1, max_items = 10)]
v4: Vec<()>,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\
\"items\":{\"type\":\"null\"},\
\"title\":\"C2\",\
\"type\":\"array\"\
},\
\"v1\":{\
\"items\":{\"type\":\"null\"},\
\"title\":\"V1\",\
\"type\":\"array\"\
},\
\"v3\":{\
\"items\":{\"type\":\"null\"},\
\"title\":\"V3\",\
\"type\":\"array\"\
},\
\"v4\":{\
\"items\":{\"type\":\"null\"},\
\"maxItems\":10,\
\"minItems\":1,\
\"title\":\"V4\",\
\"type\":\"array\"\
}\
},\
\"required\":[\"v1\",\"c2\",\"v3\",\"v4\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"v1\":[],\"c2\": [null],\"v3\":[null,null],\"v4\":[null,null,null]}",
"{\"c2\":[null],\"v1\":[],\"v3\":[null,null,null],\"v4\":[null,null,null]}"
);
success_parse_model!(
TestModel,
"{\"v1\":[],\"c2\": [null],\"v3\":[null,null],\"v4\":[null]}",
"{\"c2\":[null],\"v1\":[],\"v3\":[null,null,null],\"v4\":[null]}"
);
success_parse_model!(
TestModel,
"{\"v1\":[],\"c2\": [null],\"v3\":[null,null],\"v4\":[null,null,null,null,null,null,null,null,null,null]}",
"{\"c2\":[null],\"v1\":[],\"v3\":[null,null,null],\"v4\":[null,null,null,null,null,null,null,null,null,null]}"
);
assert!(
TestModel::parse("{\"c2\": [null],\"v3\":[null,null],\"v4\":[null,null,null]}").is_err()
);
assert!(TestModel::parse("{\"v1\":[],\"v3\":[null,null],\"v4\":[null,null,null]}").is_err());
assert!(TestModel::parse("{\"v1\":[],\"c2\": [null],\"v4\":[null,null,null]}").is_err());
assert!(TestModel::parse("{\"v1\":[],\"c2\": [null],\"v3\":[null,null],}").is_err());
assert!(TestModel::parse("{\"v1\":[],\"c2\": [null],\"v3\":[null,null],\"v4\":[]}").is_err());
assert!(TestModel::parse("{\"v1\":[],\"c2\": [null],\"v3\":[null,null],\"v4\":[null,null,null,null,null,null,null,null,null,null,null]}").is_err());
}
#[test]
fn test_nested_model() {
#[model]
struct TestModel1 {
v1: u8,
}
fn validate_fn(value: TestModel1) -> Result<TestModel1> {
Ok(TestModel1 { v1: value.v1 + 1 })
}
#[model]
struct TestModel2 {
v1: TestModel1,
#[field(alias = "c2", validate = validate_fn)]
v2: TestModel1,
}
assert_eq!(
TestModel2::schema(),
"{\
\"$ref\":\"#/definitions/TestModel2\",\
\"definitions\":{\
\"TestModel1\":{\
\"properties\":{\
\"v1\":{\
\"title\":\"V1\",\
\"type\":\"integer\"\
}\
},\
\"required\":[\"v1\"],\
\"title\":\"TestModel1\",\
\"type\":\"object\"\
},\
\"TestModel2\":{\
\"properties\":{\
\"c2\":{\
\"$ref\":\"#/definitions/TestModel1\",\
\"title\":\"C2\"\
},\
\"v1\":{\
\"$ref\":\"#/definitions/TestModel1\",\
\"title\":\"V1\"\
}\
},\
\"required\":[\"v1\",\"c2\"],\
\"title\":\"TestModel2\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel2,
"{\"v1\":{\"v1\": 1},\"c2\":{\"v1\": 2}}",
"{\"c2\":{\"v1\":3},\"v1\":{\"v1\":1}}"
);
assert!(TestModel2::parse("{\"c2\":{\"v1\": 2}}").is_err());
assert!(TestModel2::parse("{\"v1\":{\"v1\": 1}}").is_err());
assert!(TestModel2::parse("{\"v1\":{},\"c2\":{\"v1\": 2}}").is_err());
}
#[test]
fn test_self_reference_model() {
fn validate_fn(value: Option<Box<TestModel>>) -> Result<Option<Box<TestModel>>> {
if value.is_some() {
Ok(value)
} else {
Ok(None)
}
}
#[model]
struct TestModel {
v1: u8,
#[field(alias = "self", validate = validate_fn)]
v2: Option<Box<TestModel>>,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"TestModel\":{\
\"properties\":{\
\"self\":{\
\"anyOf\":[\
{\"type\":\"null\"},\
{\"$ref\":\"#/definitions/TestModel\"}\
],\
\"title\":\"Self\"\
},\
\"v1\":{\
\"title\":\"V1\",\
\"type\":\"integer\"\
}\
},\
\"required\":[\"v1\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(TestModel, "{\"v1\": 1}", "{\"self\":null,\"v1\":1}");
success_parse_model!(
TestModel,
"{\"v1\": 1,\"self\":{\"v1\": 2}}",
"{\"self\":{\"self\":null,\"v1\":2},\"v1\":1}"
);
success_parse_model!(
TestModel,
"{\"v1\": 1,\"self\":{\"v1\": 2,\"self\":{\"v1\": 3}}}",
"{\"self\":{\"self\":{\"self\":null,\"v1\":3},\"v1\":2},\"v1\":1}"
);
assert!(TestModel::parse("{}").is_err());
assert!(TestModel::parse("{\"self\":{\"v1\": 2}}").is_err());
}
#[test]
fn test_enum_model() {
#[model]
enum Pattern {
Value1,
Value2,
}
fn validate_fn(value: Pattern) -> Result<Pattern> {
Ok(match value {
Pattern::Value1 => Pattern::Value2,
Pattern::Value2 => Pattern::Value1,
})
}
#[model]
struct TestModel {
v1: Pattern,
#[field(alias = "c2", validate = validate_fn)]
v2: Pattern,
}
assert_eq!(
TestModel::schema(),
"{\
\"$ref\":\"#/definitions/TestModel\",\
\"definitions\":{\
\"Pattern\":{\
\"anyOf\":[{\
\"const\":\"Value1\",\
\"title\":\"Value1\"\
},{\
\"const\":\"Value2\",\
\"title\":\"Value2\"\
}],\
\"title\":\"Pattern\"\
},\
\"TestModel\":{\
\"properties\":{\
\"c2\":{\
\"$ref\":\"#/definitions/Pattern\",\
\"title\":\"C2\"\
},\
\"v1\":{\
\"$ref\":\"#/definitions/Pattern\",\
\"title\":\"V1\"\
}\
},\
\"required\":[\"v1\",\"c2\"],\
\"title\":\"TestModel\",\
\"type\":\"object\"\
}\
}\
}"
);
success_parse_model!(
TestModel,
"{\"c2\": \"Value1\",\"v1\": \"Value1\"}",
"{\"c2\":\"Value2\",\"v1\":\"Value1\"}"
);
success_parse_model!(
TestModel,
"{\"c2\": \"Value1\",\"v1\": \"Value2\"}",
"{\"c2\":\"Value2\",\"v1\":\"Value2\"}"
);
success_parse_model!(
TestModel,
"{\"c2\": \"Value2\",\"v1\": \"Value1\"}",
"{\"c2\":\"Value1\",\"v1\":\"Value1\"}"
);
assert!(TestModel::parse("{\"c2\": \"Value2\",\"v1\": \"Value3\"}").is_err());
assert!(TestModel::parse("{\"c2\": \"Value3\",\"v1\": \"Value1\"}").is_err());
}