#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use validatable::*;
use validatable::{Format::*, Message::*};
use super::util::*;
#[test]
fn basic() {
#[derive(PartialEq, Clone, Validatable, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Person<F: FieldFamily> {
active: Field<F, bool>,
age: Field<F, u32>,
name: Field<F, String>,
email: FieldWith<F, Email, Edit<String>, String>,
fixed1: i32,
fixed2: Option<String>,
score: Field<F, Option<i32>>,
}
#[derive(PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Email(String);
impl ValidatableValue<String> for Email {
fn validate_from(input: &String) -> Result<Self, Message> {
if input.contains('@') {
Ok(Email(input.clone()))
} else {
Err(Message::Text(s!("input @")))
}
}
fn default_input() -> String {
"".to_owned()
}
fn into_input(self) -> String {
self.0
}
}
let mut valid: Person<Form> = Person {
active: e!(true),
age: es!("20"),
name: es!("Foo Bar"),
email: es!("foo@examlpe.com"),
fixed1: -123,
fixed2: None,
score: es!(""),
};
let plain: Person<Plain> = Person {
active: true,
age: 20,
name: s!("Foo Bar"),
email: Email(s!("foo@examlpe.com")),
fixed1: -123,
fixed2: None,
score: None,
};
assert_eq!(valid.validate(), Some(plain));
let mut invalid: Person<Form> = Person {
active: e!(false),
age: es!("unknown"),
name: es!("Foo Bar"),
email: es!("examlpe.com"),
fixed1: -123,
fixed2: None,
score: es!("-5"),
};
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Person {
active: e!(false),
age: es!("unknown", Message::BadFormat(Format::UnsignedInteger)),
name: es!("Foo Bar"),
email: es!("examlpe.com", Message::Text(s!("input @"))),
fixed1: -123,
fixed2: None,
score: es!("-5"),
}
);
assert_eq!(Person::<Input>::default().validate(), Err(ContentProblem));
let mut def = Person::<Form>::default();
assert_eq!(def.validate(), None);
assert_eq!(
def,
Person {
active: e!(false),
age: es!("", Empty),
name: es!(""),
email: es!("", Message::Text(s!("input @"))),
fixed1: 0,
fixed2: None,
score: es!(""),
}
);
}
#[test]
fn field_types_misc() {
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Misc<F: FieldFamily> {
bool: Field<F, bool>,
bool_o: Field<F, Option<bool>>,
char: Field<F, char>,
char_o: Field<F, Option<char>>,
string: Field<F, String>,
string_o: Field<F, Option<String>>,
}
let mut valid_misc_form: Misc<Form> = Misc {
bool: e!(true),
bool_o: e!(Some(false)),
char: es!("あ"),
char_o: es!(""),
string: es!("foo"),
string_o: es!(""),
};
let valid_misc_plain: Misc<Plain> = Misc {
bool: true,
bool_o: Some(false),
char: 'あ',
char_o: None,
string: s!("foo"),
string_o: None,
};
assert_eq!(valid_misc_form.validate(), Some(valid_misc_plain.clone()));
let mut invalid_misc_form: Misc<Form> = Misc {
bool: e!(false),
bool_o: e!(Some(true)),
char: es!("あい"),
char_o: es!("あい"),
string: es!(""),
string_o: es!("abc"),
};
assert_eq!(invalid_misc_form.validate(), None);
assert_eq!(
invalid_misc_form,
Misc {
bool: e!(false),
bool_o: e!(Some(true)),
char: es!("あい", Message::BadFormat(Format::Char)),
char_o: es!("あい", Message::BadFormat(Format::Char)),
string: es!(""),
string_o: es!("abc"),
}
);
assert_eq!(Misc::<Form>::default().validate(), None);
assert_eq!(Misc::<Input>::default().validate(), Err(ContentProblem));
let plain_input: Misc<Input> = valid_misc_plain.clone().into();
let plain_form: Misc<Form> = valid_misc_plain.clone().into();
let form_input: Misc<Input> = plain_form.into();
let mut input_form: Misc<Form> = plain_input.into();
assert_eq!(form_input.validate(), Ok(valid_misc_plain.clone()));
assert_eq!(input_form.validate(), Some(valid_misc_plain));
let mut empty_char_form: Misc<Form> = Misc {
bool: e!(false),
bool_o: e!(None),
char: es!(""),
char_o: es!(""),
string: es!("foo"),
string_o: es!(""),
};
assert_eq!(empty_char_form.validate(), None);
assert_eq!(empty_char_form.char.message, Some(Empty));
}
#[test]
fn field_types_signed() {
#[derive(Validatable, PartialEq, Debug)]
struct Signed<F: FieldFamily> {
i8: Field<F, i8>,
i8_o: Field<F, Option<i8>>,
i16: Field<F, i16>,
i16_o: Field<F, Option<i16>>,
i32: Field<F, i32>,
i32_o: Field<F, Option<i32>>,
i64: Field<F, i64>,
i64_o: Field<F, Option<i64>>,
}
let mut valid_signed_form: Signed<Form> = Signed {
i8: es!("-128"),
i8_o: es!(""),
i16: es!("-32768"),
i16_o: es!(""),
i32: es!("-2147483648"),
i32_o: es!("-2147483648"),
i64: es!("-9223372036854775808"),
i64_o: es!(""),
};
let valid_signed_plain: Signed<Plain> = Signed {
i8: -128,
i8_o: None,
i16: -32768,
i16_o: None,
i32: -2147483648,
i32_o: Some(-2147483648),
i64: -9223372036854775808,
i64_o: None,
};
assert_eq!(valid_signed_form.validate(), Some(valid_signed_plain));
let mut invalid_signed_form: Signed<Form> = Signed {
i8: es!("128"),
i8_o: es!("-129"),
i16: es!("not-number"),
i16_o: es!("-32769"),
i32: es!("-2147483649"),
i32_o: es!("foo"),
i64: es!("-9223372036854775809"),
i64_o: es!("-9223372036854775809"),
};
assert_eq!(invalid_signed_form.validate(), None);
let bad_format = Message::BadFormat(Format::SignedInteger);
assert_eq!(
invalid_signed_form,
Signed {
i8: es!("128", ValueExceedMax(s!("127"))),
i8_o: es!("-129", ValueExceedMin(s!("-128"))),
i16: es!("not-number", bad_format.clone()),
i16_o: es!("-32769", ValueExceedMin(s!("-32768"))),
i32: es!("-2147483649", ValueExceedMin(s!("-2147483648"))),
i32_o: es!("foo", bad_format),
i64: es!(
"-9223372036854775809",
ValueExceedMin(s!("-9223372036854775808"))
),
i64_o: es!(
"-9223372036854775809",
ValueExceedMin(s!("-9223372036854775808"))
),
}
);
assert_eq!(Signed::<Form>::default().validate(), None);
assert_eq!(Signed::<Input>::default().validate(), Err(ContentProblem));
}
#[test]
fn field_types_unsigned() {
#[derive(Validatable, PartialEq, Debug)]
struct Unsigned<F: FieldFamily> {
u8: Field<F, u8>,
u8_o: Field<F, Option<u8>>,
u16: Field<F, u16>,
u16_o: Field<F, Option<u16>>,
u32: Field<F, u32>,
u32_o: Field<F, Option<u32>>,
u64: Field<F, u64>,
u64_o: Field<F, Option<u64>>,
}
let valid_unsigned_plain: Unsigned<Plain> = Unsigned {
u8: 255,
u8_o: None,
u16: 65535,
u16_o: None,
u32: 4294967295,
u32_o: None,
u64: 18446744073709551615,
u64_o: None,
};
let mut valid_unsigned_form: Unsigned<Form> = Unsigned {
u8: es!("255"),
u8_o: es!(""),
u16: es!("65535"),
u16_o: es!(""),
u32: es!("4294967295"),
u32_o: es!(""),
u64: es!("18446744073709551615"),
u64_o: es!(""),
};
assert_eq!(valid_unsigned_form.validate(), Some(valid_unsigned_plain));
let mut invalid_unsigned_form: Unsigned<Form> = Unsigned {
u8: es!("-1"),
u8_o: es!("-1"),
u16: es!("abc"),
u16_o: es!("abc"),
u32: es!("-"),
u32_o: es!("-1"),
u64: es!("-1"),
u64_o: es!("-1"),
};
assert_eq!(invalid_unsigned_form.validate(), None);
let bad_format = Message::BadFormat(Format::UnsignedInteger);
assert_eq!(
invalid_unsigned_form,
Unsigned {
u8: es!("-1", ValueExceedMin(s!("0"))),
u8_o: es!("-1", ValueExceedMin(s!("0"))),
u16: es!("abc", bad_format.clone()),
u16_o: es!("abc", bad_format.clone()),
u32: es!("-", bad_format),
u32_o: es!("-1", ValueExceedMin(s!("0"))),
u64: es!("-1", ValueExceedMin(s!("0"))),
u64_o: es!("-1", ValueExceedMin(s!("0"))),
},
);
assert_eq!(Unsigned::<Form>::default().validate(), None);
assert_eq!(Unsigned::<Input>::default().validate(), Err(ContentProblem));
}
#[test]
fn field_types_float() {
#[derive(Validatable, PartialEq, Debug)]
struct Float<F: FieldFamily> {
f32: Field<F, f32>,
f32_o: Field<F, Option<f32>>,
f64: Field<F, f64>,
f64_o: Field<F, Option<f64>>,
}
let mut valid_float_form: Float<Form> = Float {
f32: es!("1234.5678"),
f32_o: es!("-1E-2"),
f64: es!("-9223372036854775808"),
f64_o: es!(""),
};
let valid_float_plain: Float<Plain> = Float {
f32: 1234.5678,
f32_o: Some(-0.01),
f64: -9223372036854775808.0,
f64_o: None,
};
assert_eq!(valid_float_form.validate(), Some(valid_float_plain));
let mut invalid_float_form: Float<Form> = Float {
f32: es!(""),
f32_o: es!("foo"),
f64: es!("foo"),
f64_o: es!("あ"),
};
assert_eq!(invalid_float_form.validate(), None);
let bad_format = Message::BadFormat(Format::Float);
assert_eq!(
invalid_float_form,
Float {
f32: es!("", Empty),
f32_o: es!("foo", bad_format.clone()),
f64: es!("foo", bad_format.clone()),
f64_o: es!("あ", bad_format),
}
);
assert_eq!(Float::<Form>::default().validate(), None);
assert_eq!(Float::<Input>::default().validate(), Err(ContentProblem));
}
#[test]
fn field_types_option_blank() {
#[derive(Validatable, PartialEq, Debug)]
struct Opt<F: FieldFamily> {
num: Field<F, Option<u32>>,
float: Field<F, Option<f64>>,
string: Field<F, Option<String>>,
char: Field<F, Option<char>>,
}
let mut blank: Opt<Form> = Opt {
num: es!(" "),
float: es!("\t"),
string: es!(" "),
char: es!(" "),
};
assert_eq!(
blank.validate(),
Some(Opt {
num: None,
float: None,
string: Some(s!(" ")),
char: Some(' '),
})
);
let mut invalid: Opt<Form> = Opt {
num: es!("abc"),
float: es!("x"),
string: es!("ok"),
char: es!("ab"),
};
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Opt {
num: es!("abc", BadFormat(UnsignedInteger)),
float: es!("x", BadFormat(Float)),
string: es!("ok"),
char: es!("ab", BadFormat(Char)),
}
);
}
#[test]
fn option_default_input() {
#[derive(PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Code(u8);
impl ValidatableValue<String> for Code {
fn validate_from(input: &String) -> Result<Self, Message> {
input
.parse()
.map(Code)
.map_err(|_| Message::Text(s!("two digits")))
}
fn default_input() -> String {
s!("00")
}
fn into_input(self) -> String {
format!("{:02}", self.0)
}
}
impl DefaultInputType for Code {
type InputType = String;
type FormType = Edit<String>;
}
assert_eq!(
<Option<Code> as ValidatableValue<String>>::default_input(),
s!("")
);
assert_eq!(
<Option<Code> as ValidatableValue<String>>::into_input(None),
s!("")
);
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct CodeForm<F: FieldFamily> {
code: Field<F, Option<Code>>,
}
let mut def = CodeForm::<Form>::default();
assert_eq!(def.code, es!(""));
assert_eq!(def.validate(), Some(CodeForm { code: None }));
}
#[test]
fn validate_input() {
#[derive(Validatable, PartialEq, Debug)]
struct Test<F: FieldFamily> {
pass1: bool,
field1: Field<F, u32>,
field2: Field<F, Option<String>>,
}
let valid: Test<Input> = Test {
pass1: true,
field1: s!("123"),
field2: s!(""),
};
assert_eq!(
valid.validate(),
Ok(Test {
pass1: true,
field1: 123,
field2: None
})
);
let invalid: Test<Input> = Test {
pass1: true,
field1: s!("a123"),
field2: s!(""),
};
assert_eq!(invalid.validate(), Err(Message::ContentProblem));
}
#[test]
fn convert() {
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
pass1: bool,
field1: Field<F, u32>,
field2: Field<F, Option<String>>,
}
let t1_plain: Test<Plain> = Test {
pass1: true,
field1: 123,
field2: Some(s!("foo")),
};
let t1_plain_input: Test<Input> = t1_plain.clone().into();
assert_eq!(
t1_plain_input,
Test {
pass1: true,
field1: s!("123"),
field2: s!("foo"),
}
);
let t1_plain_form: Test<Form> = t1_plain.into();
assert_eq!(
t1_plain_form,
Test {
pass1: true,
field1: es!("123"),
field2: es!("foo"),
}
);
let t1_input_form: Test<Form> = t1_plain_input.clone().into();
assert_eq!(t1_input_form, t1_plain_form);
let t1_form_input: Test<Input> = t1_plain_form.clone().into();
assert_eq!(t1_form_input, t1_plain_input);
assert_eq!(t1_plain_form.clone().into_input(), t1_plain_input);
assert_eq!(t1_plain_input.into_form(), t1_plain_form);
}
#[test]
fn non_empty_string() {
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
field1: Field<F, NonEmptyString>,
field2: Field<F, Option<NonEmptyString>>,
}
let plain: Test<Plain> = Test {
field1: ns!("some"),
field2: Some(ns!("some")),
};
let mut some: Test<Form> = Test {
field1: es!("some"),
field2: es!("some"),
};
assert_eq!(some.validate(), Some(plain.clone()));
let mut empty: Test<Form> = Test {
field1: es!(""),
field2: es!(""),
};
assert_eq!(empty.validate(), None);
assert_eq!(
empty,
Test {
field1: es!("", Message::Empty),
field2: es!(""),
}
);
let mut valid: Test<Form> = Test {
field1: es!("some"),
field2: es!(""),
};
assert_eq!(
valid.validate(),
Some(Test {
field1: NonEmptyString::new(s!("some")).unwrap(),
field2: None,
})
);
let plain_input: Test<Input> = plain.clone().into();
let plain_form: Test<Form> = plain.clone().into();
let form_input: Test<Input> = plain_form.into();
let mut input_form: Test<Form> = plain_input.into();
assert_eq!(form_input.validate(), Ok(plain.clone()));
assert_eq!(input_form.validate(), Some(plain));
assert_eq!(
Test::<Form>::new(),
Test {
field1: es!(""),
field2: es!(""),
}
);
}
#[test]
fn basic_vec() {
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
field1: Field<F, u8>,
field2: Vec<Field<F, u8>>,
field3: Vec<Field<F, Option<String>>>,
}
let plain: Test<Plain> = Test {
field1: 1,
field2: vec![3, 2, 1],
field3: vec![Some(s!("foo")), None, Some(s!("bar"))],
};
let mut valid: Test<Form> = Test {
field1: es!("1"),
field2: vec![es!("3"), es!("2"), es!("1")],
field3: vec![es!("foo"), es!(""), es!("bar")],
};
let input: Test<Input> = Test {
field1: s!("1"),
field2: vec![s!("3"), s!("2"), s!("1")],
field3: vec![s!("foo"), s!(""), s!("bar")],
};
let mut invalid: Test<Form> = Test {
field1: es!("a"),
field2: vec![es!("3"), es!("foo"), es!("1")],
field3: vec![es!("foo"), es!(""), es!("bar")],
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(Test::<Input>::from(plain.clone()), input);
assert_eq!(Test::<Input>::from(valid.clone()), input);
assert_eq!(Test::<Form>::from(plain), valid);
assert_eq!(Test::<Form>::from(input), valid);
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
field1: es!("a", Message::BadFormat(Format::UnsignedInteger)),
field2: vec![
es!("3"),
es!("foo", Message::BadFormat(Format::UnsignedInteger)),
es!("1"),
],
field3: vec![es!("foo"), es!(""), es!("bar"),],
}
);
assert_eq!(
Test::<Form>::new(),
Test {
field1: es!(""),
field2: vec![],
field3: vec![],
}
);
}
#[test]
fn vec_in_form_field() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
field1: Field<F, Vec<u8>>,
}
let plain: Test<Plain> = Test {
field1: vec![3, 2, 1],
};
let mut valid: Test<Form> = Test {
field1: e!(vec![es!("3"), es!("2"), es!("1"),]),
};
let input: Test<Input> = Test {
field1: vec![s!("3"), s!("2"), s!("1")],
};
let mut invalid: Test<Form> = Test {
field1: e!(vec![es!("3"), es!("foo"), es!("1"),]),
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(Test::<Input>::from(plain.clone()), input);
assert_eq!(Test::<Input>::from(valid.clone()), input);
assert_eq!(Test::<Form>::from(plain), valid);
assert_eq!(Test::<Form>::from(input), valid);
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
field1: e!(
vec![
es!("3"),
es!("foo", Message::BadFormat(Format::UnsignedInteger)),
es!("1"),
],
Message::ContentProblem
),
}
);
assert_eq!(Test::<Form>::new(), Test { field1: e!(vec![]) });
}
#[test]
fn nonempty_vec() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
f1: NonEmpty<Field<F, u8>>,
f2: Field<F, NonEmpty<u8>>,
}
let plain: Test<Plain> = Test {
f1: nonempty![1, 2, 3],
f2: nonempty![1, 2, 3],
};
let mut valid: Test<Form> = Test {
f1: nonempty![es!("1"), es!("2"), es!("3")],
f2: e!(nonempty![es!("1"), es!("2"), es!("3")]),
};
let mut invalid: Test<Form> = Test {
f1: nonempty![es!("1"), es!("f"), es!("3")],
f2: e!(nonempty![es!("1"), es!("f"), es!("3")]),
};
let input: Test<Input> = Test {
f1: nonempty![s!("1"), s!("2"), s!("3")],
f2: nonempty![s!("1"), s!("2"), s!("3")],
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(input.validate(), Ok(plain.clone()));
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
f1: nonempty![es!("1"), es!("f", BadFormat(UnsignedInteger)), es!("3")],
f2: e!(
nonempty![es!("1"), es!("f", BadFormat(UnsignedInteger)), es!("3")],
ContentProblem
),
}
);
assert_eq!(
Test::<Form>::new(),
Test {
f1: nonempty![es!("")],
f2: e!(nonempty![es!("")]),
}
);
let plain_input: Test<Input> = plain.clone().into();
let plain_form: Test<Form> = plain.clone().into();
let form_input: Test<Input> = plain_form.into();
let mut input_form: Test<Form> = plain_input.into();
assert_eq!(form_input.validate(), Ok(plain.clone()));
assert_eq!(input_form.validate(), Some(plain));
}
#[test]
fn bounded_vec() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
f1: BoundedVec<Field<F, u8>, 2, 5>,
f2: Field<F, BoundedVec<u8, 2, 4>>,
}
let plain: Test<Plain> = Test {
f1: bvec![1, 2, 3],
f2: bvec![1, 2, 3],
};
let mut valid: Test<Form> = Test {
f1: bvec![es!("1"), es!("2"), es!("3")],
f2: e!(vec![es!("1"), es!("2"), es!("3")]),
};
let mut invalid1: Test<Form> = Test {
f1: bvec![es!("1"), es!("f"), es!("3")],
f2: e!(vec![es!("1"), es!("f"), es!("3")]),
};
let mut invalid2: Test<Form> = Test {
f1: bvec![es!("1"), es!("2")],
f2: e!(vec![]),
};
let mut invalid3: Test<Form> = Test {
f1: bvec![es!("1"), es!("2")],
f2: e!(vec![es!("1")]),
};
let mut invalid4: Test<Form> = Test {
f1: bvec![es!("1"), es!("2")],
f2: e!(vec![es!("1"), es!("2"), es!("3"), es!("4"), es!("5")]),
};
let input: Test<Input> = Test {
f1: bvec![s!("1"), s!("2"), s!("3")],
f2: vec![s!("1"), s!("2"), s!("3")],
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(input.validate(), Ok(plain.clone()));
assert_eq!(invalid1.validate(), None);
assert_eq!(invalid2.validate(), None);
assert_eq!(invalid3.validate(), None);
assert_eq!(invalid4.validate(), None);
assert_eq!(
invalid1,
Test {
f1: bvec![es!("1"), es!("f", BadFormat(UnsignedInteger)), es!("3")],
f2: e!(
vec![es!("1"), es!("f", BadFormat(UnsignedInteger)), es!("3")],
ContentProblem
),
}
);
assert_eq!(
invalid2,
Test {
f1: bvec![es!("1"), es!("2")],
f2: e!(vec![], Empty),
}
);
assert_eq!(
invalid3,
Test {
f1: bvec![es!("1"), es!("2")],
f2: e!(vec![es!("1")], LengthExceedMin(s!("2"))),
}
);
assert_eq!(
invalid4,
Test {
f1: bvec![es!("1"), es!("2")],
f2: e!(
vec![es!("1"), es!("2"), es!("3"), es!("4"), es!("5")],
LengthExceedMax(s!("4"))
),
}
);
assert_eq!(
Test::<Form>::new(),
Test {
f1: bvec![es!(""), es!("")],
f2: e!(vec![es!(""), es!("")]),
}
);
let plain_input: Test<Input> = plain.clone().into();
let plain_form: Test<Form> = plain.clone().into();
let form_input: Test<Input> = plain_form.into();
let mut input_form: Test<Form> = plain_input.into();
assert_eq!(form_input.validate(), Ok(plain.clone()));
assert_eq!(input_form.validate(), Some(plain));
}
#[test]
fn basic_enum() {
#[derive(Validatable, PartialEq, Clone, Debug)]
enum TestEnum<F: FieldFamily> {
VariantEmpty,
VariantTuple0(),
VariantTuple1(Field<F, u8>),
VariantTuple1p(bool),
VariantTuple3(Field<F, u8>, bool, Field<F, Option<String>>),
VariantNamed {
field1: Field<F, u8>,
field2: Option<String>,
},
}
let vs: Vec<TestEnum<Plain>> = vec![
TestEnum::VariantEmpty,
TestEnum::VariantTuple0(),
TestEnum::VariantTuple1(123),
TestEnum::VariantTuple1p(true),
TestEnum::VariantTuple3(234, false, Some(s!("string"))),
TestEnum::VariantNamed {
field1: 56,
field2: None,
},
];
for v in vs {
let plain_input: TestEnum<Input> = v.clone().into();
let plain_form: TestEnum<Form> = v.clone().into();
let form_input: TestEnum<Input> = plain_form.into();
let mut input_form: TestEnum<Form> = plain_input.into();
assert_eq!(form_input.validate(), Ok(v.clone()));
assert_eq!(input_form.validate(), Some(v));
}
let mut invalid: TestEnum<Form> = TestEnum::VariantTuple3(es!("foo"), true, es!(""));
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
TestEnum::VariantTuple3(
es!("foo", Message::BadFormat(Format::UnsignedInteger)),
true,
es!(""),
)
);
assert_eq!(
TestEnum::<Input>::default().validate(),
Ok(TestEnum::VariantEmpty)
);
assert_eq!(
TestEnum::<Form>::default().validate(),
Some(TestEnum::VariantEmpty)
);
}
#[test]
fn basic_nest() {
#[derive(Validatable, PartialEq, Clone, Debug)]
enum TestEnum<F: FieldFamily> {
Empty,
Tuple1(Field<F, u8>),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
field1: TestEnum<F>,
field2: Vec<TestEnum<F>>,
}
let plain: Test<Plain> = Test {
field1: TestEnum::Tuple1(234),
field2: vec![TestEnum::Tuple1(1), TestEnum::Empty, TestEnum::Tuple1(2)],
};
let mut valid: Test<Form> = Test {
field1: TestEnum::Tuple1(es!("234")),
field2: vec![
TestEnum::Tuple1(es!("1")),
TestEnum::Empty,
TestEnum::Tuple1(es!("2")),
],
};
let input: Test<Input> = Test {
field1: TestEnum::Tuple1(s!("234")),
field2: vec![
TestEnum::Tuple1(s!("1")),
TestEnum::Empty,
TestEnum::Tuple1(s!("2")),
],
};
let mut invalid: Test<Form> = Test {
field1: TestEnum::Tuple1(es!("foo")),
field2: vec![
TestEnum::Tuple1(es!("1")),
TestEnum::Empty,
TestEnum::Tuple1(es!("bar")),
],
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(Test::<Input>::from(plain.clone()), input);
assert_eq!(Test::<Input>::from(valid.clone()), input);
assert_eq!(Test::<Form>::from(plain), valid);
assert_eq!(Test::<Form>::from(input), valid);
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
field1: TestEnum::Tuple1(es!("foo", Message::BadFormat(Format::UnsignedInteger))),
field2: vec![
TestEnum::Tuple1(es!("1")),
TestEnum::Empty,
TestEnum::Tuple1(es!("bar", Message::BadFormat(Format::UnsignedInteger))),
],
}
)
}
#[test]
fn advanced_nest() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Elem<F: FieldFamily> {
f1: Field<F, u8>,
}
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
f0: Field<F, u8>,
f1: Elem<F>,
f2: Field<F, Elem<Plain>>,
f3: Vec<Elem<F>>,
f4: Field<F, Vec<u8>>,
f5: Field<F, Vec<Elem<Plain>>>,
f6: String,
}
let plain: Test<Plain> = Test {
f0: 1,
f1: Elem { f1: 2 },
f2: Elem { f1: 2 },
f3: vec![Elem { f1: 3 }, Elem { f1: 4 }],
f4: vec![5, 6],
f5: vec![Elem { f1: 7 }, Elem { f1: 8 }],
f6: s!("foo"),
};
let input: Test<Input> = Test {
f0: s!("1"),
f1: Elem { f1: s!("2") },
f2: Elem { f1: s!("2") },
f3: vec![Elem { f1: s!("3") }, Elem { f1: s!("4") }],
f4: vec![s!("5"), s!("6")],
f5: vec![Elem { f1: s!("7") }, Elem { f1: s!("8") }],
f6: s!("foo"),
};
let mut valid: Test<Form> = Test {
f0: es!("1"),
f1: Elem { f1: es!("2") },
f2: e!(Elem { f1: es!("2") }),
f3: vec![Elem { f1: es!("3") }, Elem { f1: es!("4") }],
f4: e!(vec![es!("5"), es!("6")]),
f5: e!(vec![e!(Elem { f1: es!("7") }), e!(Elem { f1: es!("8") })]),
f6: s!("foo"),
};
let mut invalid: Test<Form> = Test {
f0: es!("a1"),
f1: Elem { f1: es!("a2") },
f2: e!(Elem { f1: es!("a2") }),
f3: vec![Elem { f1: es!("a3") }, Elem { f1: es!("a4") }],
f4: e!(vec![es!("a5"), es!("a6")]),
f5: e!(vec![e!(Elem { f1: es!("a7") }), e!(Elem { f1: es!("a8") })]),
f6: s!("foo"),
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
f0: es!("a1", BadFormat(UnsignedInteger)),
f1: Elem {
f1: es!("a2", BadFormat(UnsignedInteger))
},
f2: e!(Elem {
f1: es!("a2", BadFormat(UnsignedInteger))
}),
f3: vec![
Elem {
f1: es!("a3", BadFormat(UnsignedInteger))
},
Elem {
f1: es!("a4", BadFormat(UnsignedInteger))
}
],
f4: e!(
vec![
es!("a5", BadFormat(UnsignedInteger)),
es!("a6", BadFormat(UnsignedInteger))
],
ContentProblem
),
f5: e!(
vec![
e!(Elem {
f1: es!("a7", BadFormat(UnsignedInteger))
}),
e!(Elem {
f1: es!("a8", BadFormat(UnsignedInteger))
})
],
ContentProblem
),
f6: s!("foo"),
}
);
assert_eq!(Test::from(plain.clone()), valid);
assert_eq!(Test::from(input.clone()), valid);
assert_eq!(Test::from(plain), input);
assert_eq!(Test::from(valid.clone()), input);
}
#[test]
fn derive() {
#[allow(dead_code)]
#[derive(Validatable)]
struct TestStructNamed1<F: FieldFamily> {
field1: Field<F, u8>,
}
#[allow(dead_code)]
#[derive(Validatable)]
struct TestStructNamed2<F: FieldFamily> {
field1: Field<F, u8>,
field2: Field<F, Option<String>>,
}
#[allow(dead_code)]
#[derive(Validatable)]
struct TestStructNamed1p1<F: FieldFamily> {
field1: Field<F, u8>,
field2: Option<String>,
}
#[allow(dead_code)]
#[derive(Validatable)]
struct TestStructUnnamed1<F: FieldFamily>(Field<F, u8>);
#[allow(dead_code)]
#[derive(Validatable)]
struct TestStructUnnamed2<F: FieldFamily>(Field<F, u8>, Field<F, Option<String>>);
#[allow(dead_code)]
#[derive(Validatable)]
struct TestStructUnnamed2p1<F: FieldFamily>(Field<F, u8>, bool, Field<F, Option<String>>);
#[derive(Validatable)]
#[allow(dead_code)]
enum TestEnum<F: FieldFamily> {
VariantEmpty,
VariantTuple0(),
VariantTuple1(Field<F, u8>),
VariantTuple1p(bool),
VariantTuple3(Field<F, u8>, bool, Field<F, Option<String>>),
VariantNamed {
field1: Field<F, u8>,
field2: Option<String>,
},
}
}
#[test]
fn form_state() {
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
field: Field<F, i32>,
}
let mut form: Test<Form> = Test { field: es!("foo") };
assert_eq!(form.validate(), None);
assert_eq!(
form.field,
Edit {
value: s!("foo"),
message: Some(Message::BadFormat(Format::SignedInteger)),
edited: false
}
);
form.field.input(s!("1"));
assert_eq!(form.validate(), Some(Test { field: 1 }));
assert_eq!(
form.field,
Edit {
value: s!("1"),
message: None,
edited: true
}
);
}
#[test]
fn custom_validate() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[validatable(custom_validate)]
struct Test<F: FieldFamily> {
field1: Field<F, i32>,
field2: Field<F, i32>,
}
impl CustomValidate<Test<Plain>> for Test<Form> {
fn custom_validate(&mut self) -> Option<Test<Plain>> {
if self.field1.value == "one" {
self.field1.value = s!("1");
}
Test::<Plain>::validate_by(self, |form, value, c| {
form.field1.validate_by(c, |v| {
if v.len() > 1 {
Some(Text(s!("only single digit")))
} else {
None
}
});
form.field2.validate_by(c, |v| {
if v == "666" {
Some(Text(s!("bad number")))
} else {
None
}
});
if let Some(value) = value {
if !c.is_failed() && (value.field1 >= value.field2) {
form.field1
.fail(c, Message::Text(s!("must be less than field2")));
form.field2
.fail(c, Message::Text(s!("must be greater than field1")));
}
}
})
}
}
let plain: Test<Plain> = Test {
field1: 1,
field2: 2,
};
let mut valid: Test<Form> = Test {
field1: es!("one"),
field2: es!("2"),
};
let input: Test<Input> = valid.clone().into();
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(input.validate(), Ok(plain.clone()));
let mut invalid1: Test<Form> = Test {
field1: es!("22"),
field2: es!("3"),
};
assert_eq!(invalid1.validate(), None);
assert_eq!(
invalid1,
Test {
field1: es!("22", Message::Text(s!("only single digit"))),
field2: es!("3")
}
);
let invalid1_input: Test<Input> = invalid1.clone().into();
assert_eq!(invalid1_input.validate(), Err(Message::ContentProblem));
let mut invalid2: Test<Form> = Test {
field1: es!("one"),
field2: es!("666"),
};
assert_eq!(invalid2.validate(), None);
assert_eq!(
invalid2,
Test {
field1: es!("1"),
field2: es!("666", Message::Text(s!("bad number"))),
}
);
let mut invalid3: Test<Form> = Test {
field1: es!("3"),
field2: es!("1"),
};
assert_eq!(invalid3.validate(), None);
assert_eq!(
invalid3,
Test {
field1: es!("3", Message::Text(s!("must be less than field2"))),
field2: es!("1", Message::Text(s!("must be greater than field1"))),
}
);
{
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Container<F: FieldFamily> {
content: Test<F>,
}
let plain: Container<Plain> = Container {
content: plain.clone(),
};
let mut valid: Container<Form> = Container {
content: valid.clone(),
};
let input: Container<Input> = valid.clone().into();
let mut invalid1: Container<Form> = Container {
content: invalid1.clone(),
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(input.validate(), Ok(plain));
assert_eq!(invalid1.validate(), None);
assert_eq!(invalid1.validate(), None);
assert_eq!(
invalid1,
Container {
content: Test {
field1: es!("22", Message::Text(s!("only single digit"))),
field2: es!("3")
}
}
);
}
{
#[derive(Validatable, PartialEq, Clone, Debug)]
enum Container<F: FieldFamily> {
Variant(Test<F>),
}
let plain: Container<Plain> = Container::Variant(plain);
let mut valid: Container<Form> = Container::Variant(valid);
let input: Container<Input> = valid.clone().into();
let mut invalid1: Container<Form> = Container::Variant(invalid1);
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(input.validate(), Ok(plain));
assert_eq!(invalid1.validate(), None);
assert_eq!(invalid1.validate(), None);
assert_eq!(
invalid1,
Container::Variant(Test {
field1: es!("22", Message::Text(s!("only single digit"))),
field2: es!("3")
})
);
}
}
#[test]
fn custom_argument() {
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
field1: Field<F, i32>,
}
struct Config {
min: i32,
max: i32,
}
impl Test<Form> {
fn validate_with(&mut self, config: &Config) -> Option<Test<Plain>> {
<Test<Plain> as Validatable<Test<Input>, Test<Form>>>::validate_by(
self,
|form, value, c| {
if let Some(value) = value {
if config.min > value.field1 {
form.field1.fail(c, ValueExceedMin(config.min.to_string()))
}
if config.max < value.field1 {
form.field1.fail(c, ValueExceedMax(config.max.to_string()))
}
}
},
)
}
}
impl Test<Input> {
fn validate_with(self, config: &Config) -> Result<Test<Plain>, Message> {
let mut form =
<Test<Plain> as Validatable<Test<Input>, Test<Form>>>::input_into_form(self);
form.validate_with(config).ok_or(ContentProblem)
}
}
let mut form: Test<Form> = Test { field1: es!("3") };
assert_eq!(
form.validate_with(&Config { min: 1, max: 3 }),
Some(Test { field1: 3 })
);
assert_eq!(form.validate_with(&Config { min: 5, max: 6 }), None);
assert_eq!(
form,
Test {
field1: es!("3", ValueExceedMin(s!("5"))),
}
);
let input: Test<Input> = form.into();
assert_eq!(
input.clone().validate_with(&Config { min: 5, max: 6 }),
Err(ContentProblem)
);
assert_eq!(
input.validate_with(&Config { min: 1, max: 4 }),
Ok(Test { field1: 3 })
);
}
#[test]
fn other_input_type() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
f1: FieldWith<F, bool, Edit<String>, String>,
}
let plain: Test<Plain> = Test { f1: true };
let mut valid: Test<Form> = Test { f1: es!("true") };
let mut trimmed: Test<Form> = Test {
f1: es!(" true \n"),
};
let mut invalid: Test<Form> = Test { f1: es!("foo") };
let mut blank: Test<Form> = Test { f1: es!(" ") };
let input: Test<Input> = Test { f1: s!("true") };
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(trimmed.validate(), Some(plain.clone()));
assert_eq!(input.validate(), Ok(plain));
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
f1: es!("foo", BadFormat(Bool))
}
);
assert_eq!(blank.validate(), None);
assert_eq!(
blank,
Test {
f1: es!(" ", Empty)
}
);
}
#[test]
fn multiple_param_type() {
#[allow(dead_code)]
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize))]
struct Test<'a, 'b, A: Clone, B: validatable::FieldFamily, C, D, const N: i32>
where
A: Default,
C: Clone + Default,
D: Clone + Default,
{
f1: Field<B, bool>,
f2: (A, C, D, &'a str, &'b str),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize))]
#[allow(dead_code)]
enum EnumTest<'a: 'b + 'c, 'b, 'c, const N: u8, F: FieldFamily, A: Clone> {
V1(&'a str, &'b str, &'c str),
V2(Field<F, u32>),
V3(A),
}
}
#[test]
fn default_generic_param() {
#[allow(dead_code)]
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize))]
struct Test<F: FieldFamily, A: Clone + Default = u32, const N: usize = 3> {
f1: Field<F, bool>,
f2: A,
}
let mut d = Test::<Form>::default();
assert_eq!(
d.validate(),
Some(Test {
f1: false,
f2: 0u32
})
);
#[allow(dead_code)]
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize))]
enum EnumTest<F: FieldFamily, A: Clone = i64, const N: u8 = 7> {
V1(Field<F, u32>),
V2(A),
}
let mut e = EnumTest::<Form>::default();
assert_eq!(e.validate(), None);
}
#[test]
fn where_clause_family_param() {
#[derive(Validatable, PartialEq, Debug)]
struct Test<F>
where
F: FieldFamily,
{
pass1: bool,
field1: Field<F, u32>,
}
let valid: Test<Input> = Test {
pass1: true,
field1: s!("123"),
};
assert_eq!(
valid.validate(),
Ok(Test {
pass1: true,
field1: 123
})
);
#[allow(dead_code)]
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Mixed<A, F, B>
where
A: Clone + Default,
F: FieldFamily,
B: Clone + Default,
{
f1: Field<F, bool>,
f2: (A, B),
}
let mut d = Mixed::<u8, Form, String>::default();
assert_eq!(
d.validate(),
Some(Mixed {
f1: false,
f2: (0, String::new())
})
);
}
#[test]
fn family_param_name_not_confused_with_unrelated_path_segment() {
mod other {
#[derive(Clone, Debug, Default, PartialEq)]
pub struct F(pub i32);
}
#[derive(Validatable, PartialEq, Clone, Debug)]
struct Test<F: FieldFamily> {
real: Field<F, u32>,
unrelated: other::F,
}
let valid: Test<Input> = Test {
real: s!("42"),
unrelated: other::F(7),
};
assert_eq!(
valid.validate(),
Ok(Test {
real: 42,
unrelated: other::F(7),
})
);
}
#[test]
fn enum_default_value() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[allow(dead_code)]
enum TestEnum1<F: FieldFamily> {
VariantEmpty,
VariantTuple1(Field<F, u8>),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
#[allow(dead_code)]
enum TestEnum2<F: FieldFamily> {
VariantTuple0(),
VariantTuple1(Field<F, u8>),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
enum TestEnum3<F: FieldFamily> {
VariantTuple1(Field<F, u8>),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
#[allow(dead_code)]
enum TestEnum4<F: FieldFamily> {
VariantTuple1p(bool),
VariantTuple1(Field<F, u8>),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
enum TestEnum5<F: FieldFamily> {
VariantTuple3(Field<F, u8>, bool, Field<F, Option<String>>),
}
#[derive(Validatable, PartialEq, Clone, Debug)]
enum TestEnum6<F: FieldFamily> {
VariantNamed {
field1: Field<F, u8>,
field2: Option<String>,
},
}
assert_eq!(
TestEnum1::<Form>::default().validate(),
Some(TestEnum1::VariantEmpty)
);
assert_eq!(
TestEnum2::<Form>::default().validate(),
Some(TestEnum2::VariantTuple0())
);
let mut d = TestEnum3::<Form>::default();
assert_eq!(d.validate(), None);
assert_eq!(d, TestEnum3::VariantTuple1(es!("", Empty)));
assert_eq!(
TestEnum4::<Form>::default().validate(),
Some(TestEnum4::VariantTuple1p(false))
);
let mut d = TestEnum5::<Form>::default();
assert_eq!(d.validate(), None);
assert_eq!(d, TestEnum5::VariantTuple3(es!("", Empty), false, es!("")));
let mut d = TestEnum6::<Form>::default();
assert_eq!(d.validate(), None);
assert_eq!(
d,
TestEnum6::VariantNamed {
field1: es!("", Empty),
field2: None
}
);
}
#[test]
fn custom_default_value() {
#[derive(PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct MyType(u8);
fn two_args<const A: u8, const B: u8>() -> u8 {
A + B
}
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
#[validatable(default = -10 * 3)]
f1: Field<F, i32>,
#[validatable(default = MyType(3 * 4 + 1))]
f2: MyType,
#[validatable(default = two_args::<1, 2>())]
f3: Field<F, u8>,
}
let plain: Test<Plain> = Test {
f1: -30,
f2: MyType(13),
f3: 3,
};
assert_eq!(Test::<Form>::default().validate(), Some(plain.clone()));
assert_eq!(Test::<Input>::default().validate(), Ok(plain));
}
#[test]
fn validated_value() {
pub struct EmailValidator;
impl Validator<String> for EmailValidator {
fn validate(s: String) -> Result<String, Message> {
if s.contains('@') {
Ok(s)
} else {
Err(Message::Text(s!("input @")))
}
}
}
type Email = Validated<String, Chain<Trim, LengthRange<1, 20>, EmailValidator>>;
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
f1: Field<F, Validated<String, LengthRange<1, 3>>>,
#[allow(clippy::type_complexity)]
f2: Field<F, Option<Validated<String, Chain<LengthRange<2, 100>, Variant<1>>>>>,
f3: Field<F, Email>,
f4: Field<F, Validated<u32, Trim, UnsignedValueRange<5, 100>>>,
f5: Field<F, Validated<NonEmptyString, AllChars<CharClassAsciiDigit>>>,
}
let plain: Test<Plain> = Test {
f1: vs!("a"),
f2: None,
f3: vs!("foo@bar"),
f4: v!(7),
f5: ValidatedValue::from_raw(ns!("42")).unwrap(),
};
let mut valid1: Test<Form> = Test {
f1: es!("a"),
f2: es!(""),
f3: es!(" foo@bar "),
f4: es!(" 7 "),
f5: es!("42"),
};
let mut valid2: Test<Form> = Test {
f1: es!("abc"),
f2: es!("ab"),
f3: es!("foo@bar"),
f4: es!("42"),
f5: es!("123"),
};
assert_eq!(valid1.validate(), Some(plain.clone()));
assert_eq!(
valid2.validate(),
Some(Test {
f1: vs!("abc"),
f2: Some(vs!("ab")),
f3: vs!("foo@bar"),
f4: v!(42),
f5: ValidatedValue::from_raw(ns!("123")).unwrap(),
})
);
let mut invalid1: Test<Form> = Test {
f1: es!(""),
f2: es!("a"),
f3: es!("a"),
f4: es!(" 2 "),
f5: es!(""),
};
assert_eq!(invalid1.validate(), None);
assert_eq!(
invalid1,
Test {
f1: es!("", Empty),
f2: es!("a", LengthExceedMin(s!("2"))),
f3: es!("a", Text(s!("input @"))),
f4: es!(" 2 ", ValueExceedMin(s!("5"))),
f5: es!("", Empty),
}
);
let mut invalid2: Test<Form> = Test {
f1: es!("aaaaaaaaaa"),
f2: es!("あい"),
f3: es!(""),
f4: es!(""),
f5: es!("12a"),
};
assert_eq!(invalid2.validate(), None);
assert_eq!(
invalid2,
Test {
f1: es!("aaaaaaaaaa", LengthExceedMax(s!("3"))),
f2: es!("あい"),
f3: es!("", Empty),
f4: es!("", Empty),
f5: es!("12a", InvalidChars(cs!("a"))),
}
);
let mut invalid3: Test<Form> = Test {
f1: es!("a"),
f2: es!(" "),
f3: es!("foo@bar"),
f4: es!("7"),
f5: es!("42"),
};
assert_eq!(invalid3.validate(), None);
assert_eq!(
invalid3,
Test {
f1: es!("a"),
f2: es!(" ", LengthExceedMin(s!("2"))),
f3: es!("foo@bar"),
f4: es!("7"),
f5: es!("42"),
}
);
let plain_input: Test<Input> = plain.clone().into();
let plain_form: Test<Form> = plain.clone().into();
let form_input: Test<Input> = plain_form.into();
let mut input_form: Test<Form> = plain_input.into();
assert_eq!(form_input.validate(), Ok(plain.clone()));
assert_eq!(input_form.validate(), Some(plain));
assert_eq!(
Test::<Form>::new(),
Test {
f1: es!(""),
f2: es!(""),
f3: es!(""),
f4: es!(""),
f5: es!(""),
}
);
}
#[test]
fn newtype_struct() {
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Elem<A>(A);
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct My8(Validated<u8, Trim, UnsignedValueMin<5>>);
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Com<B: Eq>(B)
where
B: Clone + std::fmt::Debug;
#[derive(Validatable, PartialEq, Clone, Debug)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
struct Test<F: FieldFamily> {
f1: Field<F, Elem<String>>,
f2: Field<F, My8>,
f3: Field<F, Com<bool>>,
}
let plain: Test<Plain> = Test {
f1: Elem(s!("foo")),
f2: My8(v!(6)),
f3: Com(true),
};
let input: Test<Input> = Test {
f1: s!("foo"),
f2: s!("6"),
f3: true,
};
let mut valid: Test<Form> = Test {
f1: es!("foo"),
f2: es!("6"),
f3: e!(true),
};
let mut invalid: Test<Form> = Test {
f1: es!("bar"),
f2: es!("4"),
f3: e!(false),
};
assert_eq!(valid.validate(), Some(plain.clone()));
assert_eq!(invalid.validate(), None);
assert_eq!(
invalid,
Test {
f1: es!("bar"),
f2: es!("4", ValueExceedMin(s!("5"))),
f3: e!(false),
}
);
assert_eq!(Test::from(plain.clone()), valid);
assert_eq!(Test::from(input.clone()), valid);
assert_eq!(Test::from(plain), input);
assert_eq!(Test::from(valid.clone()), input);
}