fixing and adding tests

Author: sydney-runkle

python/pydantic_core/core_schema.py

@@ -2525,7 +2525,6 @@ def union_schema(
     custom_error_message: str | None = None,
     custom_error_context: dict[str, str | int] | None = None,
     mode: Literal['smart', 'left_to_right'] | None = None,
-    strict: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
@@ -2551,7 +2550,6 @@ def union_schema(
         mode: How to select which choice to return
             * `smart` (default) will try to return the choice which is the closest match to the input value
             * `left_to_right` will return the first choice in `choices` which succeeds validation
-        strict: Whether the underlying schemas should be validated with strict mode
         ref: optional unique identifier of the schema, used to reference the schema in other places
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
@@ -2564,7 +2562,6 @@ def union_schema(
         custom_error_message=custom_error_message,
         custom_error_context=custom_error_context,
         mode=mode,
-        strict=strict,
         ref=ref,
         metadata=metadata,
         serialization=serialization,

tests/benchmarks/test_micro_benchmarks.py

@@ -686,16 +686,18 @@ def test_smart_union_coerce_core(self, benchmark):
     def test_strict_union_core(self, benchmark):
         v = SchemaValidator(
             schema=core_schema.union_schema(
-                strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()]
-            )
+                choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()]
+            ),
+            config=CoreConfig(strict=True),
         )
 
         benchmark(v.validate_python, 1)
 
     @pytest.mark.benchmark(group='strict-union-error')
     def test_strict_union_error_core(self, benchmark):
         v = SchemaValidator(
-            schema=core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.str_schema()])
+            schema=core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.str_schema()]),
+            config=CoreConfig(strict=True),
         )
 
         def validate_with_expected_error():

tests/validators/test_bytes.py

@@ -91,7 +91,7 @@ def test_constrained_bytes(py_and_json: PyAndJson, opts: dict[str, Any], input,
 
 
 def test_union():
-    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.bytes_schema()], strict=True))
+    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(strict=True), cs.bytes_schema(strict=True)]))
     assert v.validate_python('oh, a string') == 'oh, a string'
     assert v.validate_python(b'oh, bytes') == b'oh, bytes'
 

tests/validators/test_definitions_recursive.py

@@ -611,11 +611,11 @@ def test_union_cycle(strict: bool):
                                 'foobar': core_schema.typed_dict_field(
                                     core_schema.list_schema(core_schema.definition_reference_schema('root-schema'))
                                 )
-                            }
+                            },
+                            strict=strict,
                         )
                     ],
                     auto_collapse=False,
-                    strict=strict,
                     ref='root-schema',
                 )
             ],
@@ -700,11 +700,11 @@ def f(input_value, info):
                         )
                     ],
                     auto_collapse=False,
-                    strict=strict,
                     ref='root-schema',
                 )
             ],
-        )
+        ),
+        config=CoreConfig(strict=strict),
     )
 
     with pytest.raises(ValidationError) as exc_info:

tests/validators/test_union.py

@@ -8,7 +8,7 @@
 import pytest
 from dirty_equals import IsFloat, IsInt
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import plain_repr
 
@@ -262,16 +262,47 @@ def test_one_choice():
     assert v.validate_python('hello') == 'hello'
 
 
-def test_strict_union():
+def test_strict_union_flag() -> None:
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()]))
+    assert v.validate_python(1, strict=True) == 1
+    assert v.validate_python(123, strict=True) == 123
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python('123', strict=True)
+
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'bool_type', 'loc': ('bool',), 'msg': 'Input should be a valid boolean', 'input': '123'},
+        {'type': 'int_type', 'loc': ('int',), 'msg': 'Input should be a valid integer', 'input': '123'},
+    ]
+
+
+def test_strict_union_config_level() -> None:
     v = SchemaValidator(
-        core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema()])
+        core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()]),
+        config=CoreConfig(strict=True),
     )
+
     assert v.validate_python(1) == 1
     assert v.validate_python(123) == 123
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('123')
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'bool_type', 'loc': ('bool',), 'msg': 'Input should be a valid boolean', 'input': '123'},
+        {'type': 'int_type', 'loc': ('int',), 'msg': 'Input should be a valid integer', 'input': '123'},
+    ]
 
+
+def test_strict_union_member_level() -> None:
+    v = SchemaValidator(
+        core_schema.union_schema(choices=[core_schema.bool_schema(strict=True), core_schema.int_schema(strict=True)])
+    )
+
+    assert v.validate_python(1) == 1
+    assert v.validate_python(123) == 123
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python('123')
     assert exc_info.value.errors(include_url=False) == [
         {'type': 'bool_type', 'loc': ('bool',), 'msg': 'Input should be a valid boolean', 'input': '123'},
         {'type': 'int_type', 'loc': ('int',), 'msg': 'Input should be a valid integer', 'input': '123'},
@@ -469,10 +500,10 @@ def test_left_to_right_union():
 
 
 def test_left_to_right_union_strict():
-    choices = [core_schema.int_schema(), core_schema.float_schema()]
+    choices = [core_schema.int_schema(strict=True), core_schema.float_schema(strict=True)]
 
     # left_to_right union will select not cast if int first (strict int will not accept float)
-    v = SchemaValidator(core_schema.union_schema(choices, mode='left_to_right', strict=True))
+    v = SchemaValidator(core_schema.union_schema(choices, mode='left_to_right'))
     out = v.validate_python(1)
     assert out == 1
     assert isinstance(out, int)
@@ -482,7 +513,12 @@ def test_left_to_right_union_strict():
     assert isinstance(out, float)
 
     # reversing union will select float always (as strict float will accept int)
-    v = SchemaValidator(core_schema.union_schema(list(reversed(choices)), mode='left_to_right', strict=True))
+    v = SchemaValidator(
+        core_schema.union_schema(
+            list(reversed(choices)),
+            mode='left_to_right',
+        )
+    )
     out = v.validate_python(1.0)
     assert out == 1.0
     assert isinstance(out, float)