Merge remote-tracking branch 'lundalogik/handle-one-of' into 15-fix-oneof-validation-handling

# Conflicts:
#	tests/test_dump.py
#   marshmallow_jsonschema/validation.py  # ruff caught / fix

Author: stretch4x4

marshmallow_jsonschema/validation.py

@@ -51,14 +51,14 @@ def handle_length(schema, field, validator, _parent_schema):
     return schema
 
 
-def handle_one_of(schema, _field, validator, _parent_schema):
+def handle_one_of(schema, field, validator, _parent_schema):
     """Adds the validation logic for ``marshmallow.validate.OneOf`` by setting
-    the JSONSchema `enum` property to the allowed choices in the validator.
+    the JSONSchema `oneOf` property to the allowed choices in the validator.
 
     Args:
         schema (dict): The original JSON schema we generated. This is what we
             want to post-process.
-        _field (fields.Field): The field that generated the original schema and
+        field (fields.Field): The field that generated the original schema and
             who this post-processor belongs to.
         validator (marshmallow.validate.OneOf): The validator attached to the
             passed in field.
@@ -69,8 +69,21 @@ def handle_one_of(schema, _field, validator, _parent_schema):
         dict: New JSON Schema that has been post processed and
             altered.
     """
-    schema["enum"] = list(validator.choices)
-    schema["enumNames"] = list(validator.labels)
+    if schema["type"] not in ["string", "number"]:
+        return schema
+
+    if "oneOf" in schema:
+        return schema
+
+    choices = [field._serialize(choice, field.name, None) for choice in validator.choices]
+    if not choices:
+        return schema
+
+    labels = validator.labels if validator.labels else choices
+    schema["oneOf"] = [
+        {"type": schema["type"], "title": label, "const": choice}
+        for choice, label in zip(choices, labels, strict=False)
+    ]
 
     return schema
 

tests/test_dump.py

@@ -549,8 +549,8 @@ class TestSchema(Schema):
     dumped = validate_and_dump(schema)
 
     assert dumped["definitions"]["TestSchema"]["properties"]["foo"] == {
-        "enum": list(mapping.values()),
-        "enumNames": list(mapping.keys()),
+        "oneOf": [{"type": "number", "title": k, "const": v} for k, v in mapping.items()],
+        "format": "integer",
         "title": "foo",
         "type": "integer",
     }

tests/test_validation.py

@@ -52,17 +52,11 @@ def test_one_of_validator():
 
     dumped = validate_and_dump(schema)
 
-    assert dumped["definitions"]["UserSchema"]["properties"]["sex"]["enum"] == [
-        "male",
-        "female",
-        "non_binary",
-        "other",
-    ]
-    assert dumped["definitions"]["UserSchema"]["properties"]["sex"]["enumNames"] == [
-        "Male",
-        "Female",
-        "Non-binary/fluid",
-        "Other",
+    assert dumped["definitions"]["UserSchema"]["properties"]["sex"]["oneOf"] == [
+        {"type": "string", "title": "Male", "const": "male"},
+        {"type": "string", "title": "Female", "const": "female"},
+        {"type": "string", "title": "Non-binary/fluid", "const": "non_binary"},
+        {"type": "string", "title": "Other", "const": "other"},
     ]
 
 
@@ -75,8 +69,35 @@ class TestSchema(Schema):
     dumped = validate_and_dump(schema)
 
     foo_property = dumped["definitions"]["TestSchema"]["properties"]["foo"]
-    assert foo_property["enum"] == []
-    assert foo_property["enumNames"] == []
+    assert "oneOf" not in foo_property
+
+
+def test_one_of_object():
+    class TestSchema(Schema):
+        foo = fields.Dict(validate=OneOf([{"a": 1}]))
+
+    schema = TestSchema()
+
+    dumped = validate_and_dump(schema)
+
+    foo_property = dumped["definitions"]["TestSchema"]["properties"]["foo"]
+    assert "oneOf" not in foo_property
+
+
+def test_one_of_custom_field():
+    class CustomField(fields.String):
+        def _jsonschema_type_mapping(self):
+            return {"type": "string", "oneOf": [{"const": "one"}, {"const": "two"}]}
+
+    class TestSchema(Schema):
+        foo = CustomField(validate=OneOf(["one", "two"]))
+
+    schema = TestSchema()
+
+    dumped = validate_and_dump(schema)
+
+    foo_property = dumped["definitions"]["TestSchema"]["properties"]["foo"]
+    assert foo_property["oneOf"] == [{"const": "one"}, {"const": "two"}]
 
 
 def test_range():