clean up version check

Author: martinabeleda

src/uuid.rs

@@ -46,7 +46,8 @@ impl PyUuid {
 
     #[getter]
     pub fn urn(&self) -> &str {
-        // self.lib_uuid.urn().encode_lower(&mut Uuid::encode_buffer())
+        let mut buffer = Uuid::encode_buffer();
+        self.lib_uuid.urn().encode_lower(&mut buffer);
         "foo"
     }
 

src/validators/uuid.rs

@@ -8,6 +8,7 @@ use crate::build_tools::SchemaDict;
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::Input;
 use crate::recursion_guard::RecursionGuard;
+use crate::uuid::PyUuid;
 
 use super::{BuildValidator, CombinedValidator, Definitions, DefinitionsBuilder, Extra, Validator};
 
@@ -41,8 +42,10 @@ impl Validator for UuidValidator {
         _definitions: &'data Definitions<CombinedValidator>,
         _recursion_guard: &'s mut RecursionGuard,
     ) -> ValResult<'data, PyObject> {
-        // Ok(input.clone().into_py(py))
-        Ok(input.to_object(py))
+        match self.get_uuid(input) {
+            Ok(lib_uuid) => Ok(PyUuid::new(lib_uuid).into_py(py)),
+            Err(error_type) => Err(error_type),
+        }
     }
 
     fn different_strict_behavior(
@@ -64,7 +67,7 @@ impl Validator for UuidValidator {
 
 #[allow(dead_code)]
 impl UuidValidator {
-    fn get_uuid<'s, 'data>(&'s self, input: &'data impl Input<'data>, _strict: bool) -> ValResult<'data, Uuid> {
+    fn get_uuid<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValResult<'data, Uuid> {
         if let Some(py_uuid) = input.input_as_uuid() {
             let lib_uuid = py_uuid.into_uuid();
             self.check_version(input, lib_uuid)?;
@@ -76,33 +79,19 @@ impl UuidValidator {
 
     fn check_version<'s, 'data>(&self, input: &'data impl Input<'data>, uuid: Uuid) -> ValResult<'data, ()> {
         if let Some(schema_version) = self.version {
-            match uuid.get_version() {
-                Some(_version) => {
-                    // TODO(martinabeleda): need to map `uuid::Version` enum to usize
-                    let version = 4;
-                    if version == schema_version {
-                        return Ok(());
-                    } else {
-                        return Err(ValError::new(
-                            ErrorType::UuidVersionMismatch {
-                                version,
-                                schema_version,
-                            },
-                            input,
-                        ));
-                    }
-                }
-                None => {
-                    return Err(ValError::new(
-                        ErrorType::UuidParsing {
-                            error: "Could not find version for uuid".to_string(),
-                        },
-                        input,
-                    ));
-                }
+            let version = uuid.get_version_num();
+            if schema_version == version {
+                return Ok(());
+            } else {
+                return Err(ValError::new(
+                    ErrorType::UuidVersionMismatch {
+                        version,
+                        schema_version,
+                    },
+                    input,
+                ));
             }
         }
-
         Ok(())
     }
 }

tests/test_errors.py

@@ -280,6 +280,9 @@ def f(input_value, info):
     ('url_syntax_violation', 'Input violated strict URL syntax rules, Foobar', {'error': 'Foobar'}),
     ('url_too_long', 'URL should have at most 42 characters', {'max_length': 42}),
     ('url_scheme', 'URL scheme should be "foo", "bar" or "spam"', {'expected_schemes': '"foo", "bar" or "spam"'}),
+    ('uuid_type', 'Input should be a string', None),
+    ('uuid_parsing', 'Input should be a valid UUID, Foobar', {'error': 'Foobar'}),
+    ('uuid_version_mismatch', 'UUID version 2 does not match expected version: 4', {'version': 2, 'schema_version': 4}),
 ]
 
 
@@ -294,11 +297,6 @@ def test_error_type(error_type, message, context):
 def test_all_errors_covered():
     listed_types = set(error_type for error_type, *_ in all_errors)
     actual_types = {e['type'] for e in list_all_errors()}
-
-    # TODO(martinabeleda): cover these
-    actual_types.remove('uuid_type')
-    actual_types.remove('uuid_parsing')
-    actual_types.remove('uuid_version_mismatch')
     assert actual_types == listed_types
 
 

tests/validators/test_uuid.py

@@ -0,0 +1,26 @@
+from pydantic_core import Uuid, core_schema
+
+from ..conftest import PyAndJson
+
+
+def test_uuid_ok(py_and_json: PyAndJson):
+    v = py_and_json(core_schema.uuid_schema())
+    uuid = v.validate_test('12345678-1234-5678-1234-567812345678')
+
+    assert isinstance(uuid, Uuid)
+    assert str(uuid) == '12345678-1234-5678-1234-567812345678'
+    assert repr(uuid) == "Uuid('12345678-1234-5678-1234-567812345678')"
+    assert uuid.version == 4
+    assert uuid.urn == 'foo'
+    assert uuid.variant == 'bar'
+
+
+def test_uuid_from_constructor_ok():
+    uuid = Uuid('12345678-1234-5678-1234-567812345678')
+
+    assert isinstance(uuid, Uuid)
+    assert str(uuid) == '12345678-1234-5678-1234-567812345678'
+    assert repr(uuid) == "Uuid('12345678-1234-5678-1234-567812345678')"
+    assert uuid.version == 4
+    assert uuid.urn == 'foo'
+    assert uuid.variant == 'bar'