Error benchmarks and validator names (#114)

* improve error benchmarks, tweak validator names

* improve validator names

benches/main.rs

@@ -82,13 +82,24 @@ fn list_error_json(bench: &mut Bencher) {
     let gil = Python::acquire_gil();
     let py = gil.python();
     let validator = build_schema_validator(py, "{'type': 'list', 'items': 'int'}");
-    let mut code = format!("[{}", (0..90).map(|x| x.to_string()).collect::<Vec<String>>().join(","));
-    code.push_str(r#","a","b","c","d","e","f","g","h","i","j"]"#);
+    let code = format!(
+        "[{}]",
+        (0..100)
+            .map(|v| format!(r#""{}""#, as_str(v)))
+            .collect::<Vec<String>>()
+            .join(", ")
+    );
 
     let input_json = black_box(code.clone());
     match validator.validate_json(py, input_json) {
         Ok(_) => panic!("unexpectedly valid"),
-        Err(e) => e,
+        Err(e) => {
+            let v = e.value(py);
+            // println!("error: {}", v.to_string());
+            assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
+            let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
+            assert_eq!(error_count, 100);
+        }
     };
 
     bench.iter(|| {
@@ -105,11 +116,28 @@ fn list_error_python(bench: &mut Bencher) {
     let gil = Python::acquire_gil();
     let py = gil.python();
     let validator = build_schema_validator(py, "{'type': 'list', 'items': 'int'}");
-    let mut code = format!("[{}", (0..90).map(|x| x.to_string()).collect::<Vec<String>>().join(","));
-    code.push_str(r#","a","b","c","d","e","f","g","h","i","j"]"#);
+    let code = format!(
+        "[{}]",
+        (0..100)
+            .map(|v| format!(r#""{}""#, as_str(v)))
+            .collect::<Vec<String>>()
+            .join(", ")
+    );
 
     let input_python = py.eval(&code, None, None).unwrap();
     let input_python = black_box(input_python.to_object(py));
+
+    match validator.validate_python(py, input_python.as_ref(py)) {
+        Ok(_) => panic!("unexpectedly valid"),
+        Err(e) => {
+            let v = e.value(py);
+            // println!("error: {}", v.to_string());
+            assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
+            let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
+            assert_eq!(error_count, 100);
+        }
+    };
+
     bench.iter(|| {
         let result = validator.validate_python(py, black_box(input_python.as_ref(py)));
 
@@ -159,6 +187,10 @@ fn as_char(i: u8) -> char {
     (i % 26 + 97) as char
 }
 
+fn as_str(i: u8) -> String {
+    format!("{}{}", as_char(i / 26), as_char(i))
+}
+
 #[bench]
 fn dict_json(bench: &mut Bencher) {
     let gil = Python::acquire_gil();
@@ -168,7 +200,7 @@ fn dict_json(bench: &mut Bencher) {
     let code = format!(
         "{{{}}}",
         (0..100_u8)
-            .map(|i| format!(r#""{}{}": {}"#, as_char(i / 26), as_char(i), i))
+            .map(|i| format!(r#""{}": {}"#, as_str(i), i))
             .collect::<Vec<String>>()
             .join(", ")
     );
@@ -203,32 +235,43 @@ fn dict_python(bench: &mut Bencher) {
 }
 
 #[bench]
-fn dict_key_error(bench: &mut Bencher) {
+fn dict_value_error(bench: &mut Bencher) {
     let gil = Python::acquire_gil();
     let py = gil.python();
     let validator = build_schema_validator(
         py,
         r#"{
             'type': 'dict',
-            'keys': {
+            'keys': 'str',
+            'values': {
                 'type': 'int',
-                'lt': 10,
+                'lt': 0,
             },
-            'values': 'int'
         }"#,
     );
 
     let code = format!(
         "{{{}}}",
         (0..100_u8)
-            .map(|i| format!(r#"{}: {}"#, i, i))
+            .map(|i| format!(r#""{}": {}"#, as_str(i), i))
             .collect::<Vec<String>>()
             .join(", ")
     );
 
     let input_python = py.eval(&code, None, None).unwrap();
     let input_python = black_box(input_python.to_object(py));
 
+    match validator.validate_python(py, input_python.as_ref(py)) {
+        Ok(_) => panic!("unexpectedly valid"),
+        Err(e) => {
+            let v = e.value(py);
+            // println!("error: {}", v.to_string());
+            assert_eq!(v.getattr("title").unwrap().to_string(), "dict[str, constrained-int]");
+            let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
+            assert_eq!(error_count, 100);
+        }
+    };
+
     bench.iter(|| {
         let result = validator.validate_python(py, black_box(input_python.as_ref(py)));
 

src/validators/dict.rs

@@ -69,8 +69,13 @@ impl Validator for DictValidator {
         self._validation_logic(py, input, input.strict_dict()?, extra, slots)
     }
 
-    fn get_name(&self, _py: Python) -> String {
-        Self::EXPECTED_TYPE.to_string()
+    fn get_name(&self, py: Python) -> String {
+        format!(
+            "{}[{}, {}]",
+            Self::EXPECTED_TYPE,
+            self.key_validator.get_name(py),
+            self.value_validator.get_name(py)
+        )
     }
 }
 

src/validators/frozenset.rs

@@ -48,7 +48,7 @@ impl Validator for FrozenSetValidator {
     }
 
     fn get_name(&self, py: Python) -> String {
-        format!("{}-{}", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
+        format!("{}[{}]", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
     }
 }
 

src/validators/list.rs

@@ -69,7 +69,7 @@ impl Validator for ListValidator {
     }
 
     fn get_name(&self, py: Python) -> String {
-        format!("{}-{}", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
+        format!("{}[{}]", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
     }
 }
 

src/validators/literal.rs

@@ -77,7 +77,7 @@ impl Validator for LiteralSingleStringValidator {
     }
 
     fn get_name(&self, _py: Python) -> String {
-        "literal-single-string".to_string()
+        format!("literal[{}]", self.repr)
     }
 }
 
@@ -113,7 +113,7 @@ impl Validator for LiteralSingleIntValidator {
     }
 
     fn get_name(&self, _py: Python) -> String {
-        "literal-single-int".to_string()
+        format!("literal[{}]", self.expected)
     }
 }
 
@@ -164,7 +164,7 @@ impl Validator for LiteralMultipleStringsValidator {
     }
 
     fn get_name(&self, _py: Python) -> String {
-        "literal-multiple-strings".to_string()
+        format!("literal[{}]", self.repr)
     }
 }
 
@@ -215,7 +215,7 @@ impl Validator for LiteralMultipleIntsValidator {
     }
 
     fn get_name(&self, _py: Python) -> String {
-        "literal-multiple-ints".to_string()
+        format!("literal[{}]", self.repr)
     }
 }
 
@@ -292,6 +292,6 @@ impl Validator for LiteralGeneralValidator {
     }
 
     fn get_name(&self, _py: Python) -> String {
-        "literal-general".to_string()
+        format!("literal[{}]", self.repr)
     }
 }

src/validators/model.rs

@@ -20,7 +20,6 @@ struct ModelField {
 
 #[derive(Debug, Clone)]
 pub struct ModelValidator {
-    name: String,
     fields: Vec<ModelField>,
     extra_behavior: ExtraBehavior,
     extra_validator: Option<Box<CombinedValidator>>,
@@ -48,7 +47,6 @@ impl BuildValidator for ModelValidator {
             _ => None,
         };
 
-        let name: String = schema.get_as("name")?.unwrap_or_else(|| "Model".to_string());
         let fields_dict: &PyDict = schema.get_as_req("fields")?;
         let mut fields: Vec<ModelField> = Vec::with_capacity(fields_dict.len());
         let allow_by_name: bool = config.get_as("allow_population_by_field_name")?.unwrap_or(false);
@@ -81,7 +79,6 @@ impl BuildValidator for ModelValidator {
             });
         }
         Ok(Self {
-            name,
             fields,
             extra_behavior,
             extra_validator,
@@ -206,7 +203,7 @@ impl Validator for ModelValidator {
     }
 
     fn get_name(&self, _py: Python) -> String {
-        self.name.clone()
+        Self::EXPECTED_TYPE.to_string()
     }
 }
 

src/validators/nullable.rs

@@ -54,7 +54,7 @@ impl Validator for NullableValidator {
         }
     }
 
-    fn get_name(&self, _py: Python) -> String {
-        Self::EXPECTED_TYPE.to_string()
+    fn get_name(&self, py: Python) -> String {
+        format!("{}[{}]", Self::EXPECTED_TYPE, self.validator.get_name(py))
     }
 }

src/validators/set.rs

@@ -48,7 +48,7 @@ impl Validator for SetValidator {
     }
 
     fn get_name(&self, py: Python) -> String {
-        format!("{}-{}", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
+        format!("{}[{}]", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
     }
 }
 

src/validators/tuple.rs

@@ -48,7 +48,7 @@ impl Validator for TupleVarLenValidator {
     }
 
     fn get_name(&self, py: Python) -> String {
-        format!("{}-{}", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
+        format!("{}[{}]", Self::EXPECTED_TYPE, self.item_validator.get_name(py))
     }
 }
 
@@ -142,8 +142,14 @@ impl Validator for TupleFixLenValidator {
         self._validation_logic(py, input, input.strict_tuple()?, extra, slots)
     }
 
-    fn get_name(&self, _py: Python) -> String {
-        format!("{}-{}-items", Self::EXPECTED_TYPE, self.items_validators.len())
+    fn get_name(&self, py: Python) -> String {
+        let descr = self
+            .items_validators
+            .iter()
+            .map(|v| v.get_name(py))
+            .collect::<Vec<_>>()
+            .join(", ");
+        format!("{}[{}]", Self::EXPECTED_TYPE, descr)
     }
 }
 

src/validators/union.rs

@@ -66,7 +66,13 @@ impl Validator for UnionValidator {
         Err(ValError::LineErrors(errors))
     }
 
-    fn get_name(&self, _py: Python) -> String {
-        Self::EXPECTED_TYPE.to_string()
+    fn get_name(&self, py: Python) -> String {
+        let descr = self
+            .choices
+            .iter()
+            .map(|v| v.get_name(py))
+            .collect::<Vec<_>>()
+            .join(", ");
+        format!("{}[{}]", Self::EXPECTED_TYPE, descr)
     }
 }

tests/validators/test_frozenset.py

@@ -51,7 +51,7 @@ def test_frozenset_no_validators_both(py_or_json, input_value, expected):
         (frozenset([1, 2, 3, 2, 3]), {1, 2, 3}),
         ({'abc'}, Err('0\n  Value must be a valid integer')),
         ({1, 2, 'wrong'}, Err('Value must be a valid integer')),
-        ({1: 2}, Err('1 validation error for frozenset-int\n  Value must be a valid frozenset')),
+        ({1: 2}, Err('1 validation error for frozenset[int]\n  Value must be a valid frozenset')),
         ('abc', Err('Value must be a valid frozenset')),
         # Technically correct, but does anyone actually need this? I think needs a new type in pyo3
         pytest.param({1: 10, 2: 20, 3: 30}.keys(), {1, 2, 3}, marks=pytest.mark.xfail(raises=ValidationError)),
@@ -143,14 +143,14 @@ def test_union_frozenset_list(input_value, expected):
                 errors=[
                     {
                         'kind': 'int_type',
-                        'loc': ['frozenset-strict-int', 1],
+                        'loc': ['frozenset[strict-int]', 1],
                         'message': 'Value must be a valid integer',
                         'input_value': 'a',
                     },
                     # second because validation on the string choice comes second
                     {
                         'kind': 'str_type',
-                        'loc': ['frozenset-strict-str', 0],
+                        'loc': ['frozenset[strict-str]', 0],
                         'message': 'Value must be a valid string',
                         'input_value': 1,
                     },
@@ -189,7 +189,7 @@ def test_frozenset_as_dict_keys(py_or_json):
 def test_repr():
     v = SchemaValidator({'type': 'frozenset', 'strict': True, 'min_items': 42})
     assert repr(v) == (
-        'SchemaValidator(name="frozenset-any", validator=FrozenSet(\n'
+        'SchemaValidator(name="frozenset[any]", validator=FrozenSet(\n'
         '    FrozenSetValidator {\n'
         '        strict: true,\n'
         '        item_validator: Any(\n'

tests/validators/test_model.py

@@ -61,7 +61,7 @@ def test_missing_error():
     assert (
         str(exc_info.value)
         == """\
-1 validation error for Model
+1 validation error for model
 field_b
   Field required [kind=missing, input_value={'field_a': 123}, input_type=dict]"""
     )

tests/validators/test_set.py

@@ -62,7 +62,7 @@ def test_frozenset_no_validators_both(py_or_json, input_value, expected):
         ((), set()),
         (frozenset([1, 2, 3, 2, 3]), {1, 2, 3}),
         ({'abc'}, Err('0\n  Value must be a valid integer')),
-        ({1: 2}, Err('1 validation error for set-int\n  Value must be a valid set')),
+        ({1: 2}, Err('1 validation error for set[int]\n  Value must be a valid set')),
         ('abc', Err('Value must be a valid set')),
         # Technically correct, but does anyone actually need this? I think needs a new type in pyo3
         pytest.param({1: 10, 2: 20, 3: 30}.keys(), {1, 2, 3}, marks=pytest.mark.xfail(raises=ValidationError)),
@@ -147,14 +147,14 @@ def test_union_set_list(input_value, expected):
                 errors=[
                     {
                         'kind': 'int_type',
-                        'loc': ['set-strict-int', 1],
+                        'loc': ['set[strict-int]', 1],
                         'message': 'Value must be a valid integer',
                         'input_value': 'a',
                     },
                     # second because validation on the string choice comes second
                     {
                         'kind': 'str_type',
-                        'loc': ['set-strict-str', 0],
+                        'loc': ['set[strict-str]', 0],
                         'message': 'Value must be a valid string',
                         'input_value': 1,
                     },