remove empty object placeholder, add tests

Author: ewaostrowska

modules/swagger-core/src/main/java/io/swagger/v3/core/jackson/ModelResolver.java

@@ -2682,11 +2682,6 @@ protected void resolveDiscriminatorProperty(JavaType type, ModelConverterContext
         }
     }
 
-    /** An empty object schema for the current OpenAPI version. */
-    private Schema newObjectSchema() {
-        return openapi31 ? new JsonSchema().typesItem("object") : new ObjectSchema();
-    }
-
     /*
      TODO partial implementation supporting WRAPPER_OBJECT with JsonTypeInfo.Id.CLASS and JsonTypeInfo.Id.NAME
 
@@ -2711,14 +2706,13 @@ protected Schema resolveWrapping(JavaType type, ModelConverterContext context, S
                 if (JsonTypeInfo.Id.NAME.equals(id) && name == null) {
                     name = type.getRawClass().getSimpleName();
                 }
-                // If the model already carries a oneOf (e.g. from @Schema(oneOf) or @JsonSubTypes),
-                // adding the wrapper property alongside it preserves the composition instead of
-                // nesting the whole model (and dropping the oneOf) inside a wrapper schema.
+                // A model that already carries a oneOf (e.g. from @Schema(oneOf) or @JsonSubTypes) is
+                // returned unchanged: nesting it inside a wrapper schema would hide the composition.
+                // TODO the per-subtype wrapper (e.g. {"Dog": {...}}) is not modelled for oneOf yet.
                 if (model.getOneOf() != null && !model.getOneOf().isEmpty()) {
-                    model.addProperties(name, newObjectSchema());
                     return model;
                 }
-                Schema wrapperSchema = newObjectSchema();
+                Schema wrapperSchema = openapi31 ? new JsonSchema().typesItem("object") : new ObjectSchema();
                 wrapperSchema.name(model.getName());
                 wrapperSchema.addProperties(name, model);
                 return wrapperSchema;

modules/swagger-core/src/test/java/io/swagger/v3/core/resolving/WrapperObjectOneOfTest.java

@@ -5,12 +5,16 @@
 import io.swagger.v3.core.converter.ModelConverterContextImpl;
 import io.swagger.v3.core.jackson.ModelResolver;
 import io.swagger.v3.core.util.Json;
+import io.swagger.v3.core.util.Json31;
 import io.swagger.v3.oas.models.media.ComposedSchema;
 import io.swagger.v3.oas.models.media.Schema;
 import org.testng.annotations.Test;
 
+import java.util.Collections;
+
 import static org.testng.Assert.assertEquals;
 import static org.testng.Assert.assertNotNull;
+import static org.testng.Assert.assertNull;
 import static org.testng.Assert.assertTrue;
 
 /**
@@ -19,34 +23,81 @@
  * <p>
  * {@code ModelResolver.resolveWrapping(...)} used to nest the whole model inside a new wrapper
  * schema, which dropped the {@code oneOf} (the wrapper only copied name + properties). The
- * composition is now preserved and the wrapper property is added alongside it.
+ * composition is now preserved: a model with a {@code oneOf} is returned unchanged.
+ * Per-subtype wrapping is not modelled yet.
  */
 public class WrapperObjectOneOfTest {
 
     @Test
     public void wrapperObjectPreservesOneOf() {
+        final Schema<?> model = resolve(new ModelResolver(Json.mapper()), WrappedOneOf.class);
+
+        assertTrue(model instanceof ComposedSchema,
+                "the explicit @Schema(oneOf) must produce a ComposedSchema, got: " + model.getClass().getName());
+        assertOneOfKept(model);
+    }
+
+    @Test
+    public void wrapperObjectDoesNotAddWrapperProperty() {
+        final Schema<?> model = resolve(new ModelResolver(Json.mapper()), WrappedOneOf.class);
+
+        // only the declared member is present: no property named after the base type is added next to oneOf
+        assertEquals(model.getProperties().keySet(), Collections.singleton("petType"));
+    }
+
+    @Test
+    public void wrapperObjectOneOfIsStableWhenResolvedTwice() {
         final ModelResolver modelResolver = new ModelResolver(Json.mapper());
         final ModelConverterContextImpl context = new ModelConverterContextImpl(modelResolver);
 
-        final Schema<?> model = context.resolve(new AnnotatedType(WrappedOneOf.class));
+        final Schema<?> first = context.resolve(new AnnotatedType(WrappedOneOf.class));
+        final Schema<?> second = context.resolve(new AnnotatedType(WrappedOneOf.class));
 
-        assertTrue(model instanceof ComposedSchema,
-                "the explicit @Schema(oneOf) must produce a ComposedSchema, got: " + model.getClass().getName());
-        final ComposedSchema composed = (ComposedSchema) model;
-        assertNotNull(composed.getOneOf(), "oneOf must be preserved when WRAPPER_OBJECT wrapping is applied");
-        assertEquals(composed.getOneOf().size(), 2, "oneOf should reference both subtypes");
-        assertEquals(composed.getOneOf().get(0).get$ref(), "#/components/schemas/Dog");
-        assertEquals(composed.getOneOf().get(1).get$ref(), "#/components/schemas/Cat");
-        // the WRAPPER_OBJECT property is added next to oneOf, not nested around it
-        assertNotNull(composed.getProperties(), "the wrapper property must be present alongside oneOf");
+        assertOneOfKept(first);
+        assertOneOfKept(second);
+        assertEquals(second.getProperties().keySet(), first.getProperties().keySet());
     }
 
-    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT, property = "pet")
+    @Test
+    public void wrapperObjectPreservesOneOfOpenApi31() {
+        final Schema<?> model = resolve(new ModelResolver(Json31.mapper()).openapi31(true), WrappedOneOf.class);
+
+        assertOneOfKept(model);
+        assertEquals(model.getProperties().keySet(), Collections.singleton("petType"));
+    }
+
+    @Test
+    public void wrapperObjectWithoutOneOfIsStillWrapped() {
+        final Schema<?> model = resolve(new ModelResolver(Json.mapper()), PlainWrapped.class);
+
+        assertNull(model.getOneOf(), "a model without oneOf must not gain one");
+        assertEquals(model.getProperties().keySet(), Collections.singleton("PlainWrapped"));
+        final Schema<?> inner = (Schema<?>) model.getProperties().get("PlainWrapped");
+        assertEquals(inner.getProperties().keySet(), Collections.singleton("value"));
+    }
+
+    private static Schema<?> resolve(ModelResolver modelResolver, Class<?> cls) {
+        return new ModelConverterContextImpl(modelResolver).resolve(new AnnotatedType(cls));
+    }
+
+    private static void assertOneOfKept(Schema<?> model) {
+        assertNotNull(model.getOneOf(), "oneOf must be preserved when WRAPPER_OBJECT wrapping is applied");
+        assertEquals(model.getOneOf().size(), 2, "oneOf should reference both subtypes");
+        assertEquals(model.getOneOf().get(0).get$ref(), "#/components/schemas/Dog");
+        assertEquals(model.getOneOf().get(1).get$ref(), "#/components/schemas/Cat");
+    }
+
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
     @io.swagger.v3.oas.annotations.media.Schema(oneOf = {Dog.class, Cat.class})
     static abstract class WrappedOneOf {
         public String petType;
     }
 
+    @JsonTypeInfo(use = JsonTypeInfo.Id.NAME, include = JsonTypeInfo.As.WRAPPER_OBJECT)
+    static class PlainWrapped {
+        public String value;
+    }
+
     static class Dog extends WrappedOneOf {
         public String bark;
     }