Adds addComposedMappedModels and testComposedSchemaOneOfDiscriminatorMap

Uses inlineModelResolver on openapi spec

Adds ParseFlattenSpec

Referts DefaultCodegenTest.java

Adds null ref handling in addComposedMappedModels, adds test case

Adds recursive search of dscriminator when examining a schema

Author: spacether

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -1677,7 +1677,7 @@ public String toOneOfName(List<String> names, ComposedSchema composedSchema) {
 
     /**
      * Return a string representation of the schema type, resolving aliasing and references if necessary.
-     * 
+     *
      * @param schema
      * @return the string representation of the schema type.
      */
@@ -2141,12 +2141,102 @@ public int compare(CodegenProperty one, CodegenProperty another) {
         return m;
     }
 
+    /**
+     * Recursively look in Schema sc for the discriminator discPropName
+     * @param sc The Schema that may contain the discriminator
+     * @param discPropName The String that is the discriminator propertyName in the schema
+     */
+    private boolean discriminatorFound(Schema sc, String discPropName) {
+        Schema refSchema = ModelUtils.getReferencedSchema(this.openAPI, sc);
+        if (refSchema.getProperties() != null) {
+            Schema discSchema = (Schema) refSchema.getProperties().get(discPropName);
+            if (discSchema != null && ModelUtils.isStringSchema(discSchema)) {
+                return true;
+            }
+        }
+        if (ModelUtils.isComposedSchema(refSchema)) {
+            ComposedSchema composedSchema = (ComposedSchema) refSchema;
+            if (composedSchema.getAllOf() != null) {
+                // If our discriminator is in one of the allOf schemas break when we find it
+                for  (Schema allOf: composedSchema.getAllOf()) {
+                    if (discriminatorFound(allOf, discPropName)) {
+                        return true;
+                    }
+                }
+            }
+            if (composedSchema.getOneOf() != null && composedSchema.getOneOf().size() != 0) {
+                // All oneOf definitions must contain the discriminator
+                Integer hasDiscriminatorCnt = 0;
+                for  (Schema oneOf: composedSchema.getOneOf()) {
+                    if (discriminatorFound(oneOf, discPropName)) {
+                        hasDiscriminatorCnt++;
+                    }
+                }
+                if (hasDiscriminatorCnt == composedSchema.getOneOf().size()) {
+                    return true;
+                }
+            }
+            if (composedSchema.getAnyOf() != null && composedSchema.getAnyOf().size() != 0) {
+                // All anyOf definitions must contain the discriminator because a min of one must be selected
+                Integer hasDiscriminatorCnt = 0;
+                for  (Schema anyOf: composedSchema.getAnyOf()) {
+                    if (discriminatorFound(anyOf, discPropName)) {
+                        hasDiscriminatorCnt++;
+                    }
+                }
+                if (hasDiscriminatorCnt == composedSchema.getAnyOf().size()) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    /**
+     * Process oneOf and anyOf models in a composed schema and adds them into
+     * their parent's discriminator map if the oneOf and anyOf models contain
+     * the required discriminator. If they don't contain the required
+     * discriminator or the discriminator is the wrong type then an error is
+     * thrown
+     * @param discriminator The CodegenDiscriminator that we will add models to
+     * @param c The ComposedSchema that contains the discriminator and oneOf/anyOf schemas
+     * @param discPropName The String that is the discriminator propertyName in the schema
+     */
+    private void addComposedMappedModels(CodegenDiscriminator discriminator, ComposedSchema c, String discPropName) {
+        ArrayList<List<Schema>> listOLists = new ArrayList<List<Schema>>();
+        listOLists.add(c.getOneOf());
+        listOLists.add(c.getAnyOf());
+        for (List<Schema> schemaList: listOLists) {
+            if (schemaList == null) {
+                continue;
+            }
+            for  (Schema sc: schemaList) {
+                String ref = sc.get$ref();
+                if (ref == null) {
+                    // for schemas with no ref, it is not possible to build the discriminator map
+                    // because ref is how we get the model name
+                    // we only hit this use case for a schema with inline composed schemas, and one of those
+                    // schemas also has inline composed schemas
+                    continue;
+                }
+                Boolean discFound = discriminatorFound(sc, discPropName);
+                String modelName = ModelUtils.getSimpleRef(ref);
+                if (discFound == false) {
+                    LOGGER.error("schema {} is lacking the required string discriminator {}", modelName, discPropName);
+                }
+                MappedModel mappedModel = new MappedModel(modelName, toModelName(modelName));
+                discriminator.getMappedModels().add(mappedModel);
+            }
+        }
+    }
+
     protected CodegenDiscriminator createDiscriminator(String schemaName, Schema schema) {
         if (schema.getDiscriminator() == null) {
             return null;
         }
         CodegenDiscriminator discriminator = new CodegenDiscriminator();
-        discriminator.setPropertyName(toVarName(schema.getDiscriminator().getPropertyName()));
+        String discPropName = schema.getDiscriminator().getPropertyName();
+        discriminator.setPropertyName(toVarName(discPropName));
         discriminator.setPropertyBaseName(schema.getDiscriminator().getPropertyName());
         discriminator.setPropertyGetter(toGetter(discriminator.getPropertyName()));
         // FIXME: for now, we assume that the discriminator property is String
@@ -2160,16 +2250,23 @@ protected CodegenDiscriminator createDiscriminator(String schemaName, Schema sch
                 discriminator.getMappedModels().add(new MappedModel(e.getKey(), modelName));
             }
         } else {
-            Map<String, Schema> allDefinitions = ModelUtils.getSchemas(this.openAPI);
-            allDefinitions.forEach((childName, child) -> {
-                if (child instanceof ComposedSchema && ((ComposedSchema) child).getAllOf() != null) {
-
-                    final List<String> parentSchemas = ModelUtils.getAllParentsName((ComposedSchema) child, allDefinitions, true);
-                    if (parentSchemas.contains(schemaName)) {
-                        discriminator.getMappedModels().add(new MappedModel(childName, toModelName(childName)));
+            if (ModelUtils.isComposedSchema(schema)) {
+                // if all oneOf/amyOf schemas contain the discriminator, then use it when mapping
+                addComposedMappedModels(discriminator, (ComposedSchema) schema, discPropName);
+            } else {
+                // we have child models that include a parent with allOf: parent and the parent does NOT have composed schema
+                // If the parent has composed schema we go an infinite loop parent->child-> parent in getAllParentsName and addProperties
+                Map<String, Schema> allDefinitions = ModelUtils.getSchemas(this.openAPI);
+                allDefinitions.forEach((childName, child) -> {
+                    if (child instanceof ComposedSchema && ((ComposedSchema) child).getAllOf() != null) {
+
+                        final List<String> parentSchemas = ModelUtils.getAllParentsName((ComposedSchema) child, allDefinitions, true);
+                        if (parentSchemas.contains(schemaName)) {
+                            discriminator.getMappedModels().add(new MappedModel(childName, toModelName(childName)));
+                        }
                     }
-                }
-            });
+                });
+            }
         }
         return discriminator;
     }
@@ -2189,20 +2286,26 @@ protected void addProperties(Map<String, Schema> properties, List<String> requir
         if (schema instanceof ComposedSchema) {
             ComposedSchema composedSchema = (ComposedSchema) schema;
 
-            for (Schema component : composedSchema.getAllOf()) {
-                addProperties(properties, required, component);
+            if (composedSchema.getAllOf() != null) {
+                for (Schema component : composedSchema.getAllOf()) {
+                    addProperties(properties, required, component);
+                }
             }
 
             if (schema.getRequired() != null) {
                 required.addAll(schema.getRequired());
             }
 
             if (composedSchema.getOneOf() != null) {
-                throw new RuntimeException("Please report the issue: Cannot process oneOf (Composed Scheme) in addProperties: " + schema);
+                for (Schema component : composedSchema.getOneOf()) {
+                    addProperties(properties, required, component);
+                }
             }
 
             if (composedSchema.getAnyOf() != null) {
-                throw new RuntimeException("Please report the issue: Cannot process anyOf (Composed Schema) in addProperties: " + schema);
+                for (Schema component : composedSchema.getAnyOf()) {
+                    addProperties(properties, required, component);
+                }
             }
 
             return;

modules/openapi-generator/src/test/java/org/openapitools/codegen/TestUtils.java

@@ -32,6 +32,14 @@ public static OpenAPI parseSpec(String specFilePath) {
         return new OpenAPIParser().readLocation(specFilePath, null, new ParseOptions()).getOpenAPI();
     }
 
+    public static OpenAPI parseFlattenSpec(String specFilePath) {
+        OpenAPI openAPI = new OpenAPIParser().readLocation(specFilePath, null, new ParseOptions()).getOpenAPI();
+        // resolve inline models
+        InlineModelResolver inlineModelResolver = new InlineModelResolver();
+        inlineModelResolver.flatten(openAPI);
+        return openAPI;
+    }
+
     public static OpenAPI parseContent(String jsonOrYaml) {
         return new OpenAPIParser().readContents(jsonOrYaml, null, null).getOpenAPI();
     }

modules/openapi-generator/src/test/java/org/openapitools/codegen/java/JavaClientCodegenTest.java

@@ -37,18 +37,9 @@
 import io.swagger.v3.oas.models.responses.ApiResponse;
 import io.swagger.v3.parser.util.SchemaTypeUtil;
 
-import org.openapitools.codegen.ClientOptInput;
-import org.openapitools.codegen.CodegenConstants;
-import org.openapitools.codegen.CodegenModel;
-import org.openapitools.codegen.CodegenOperation;
-import org.openapitools.codegen.CodegenParameter;
-import org.openapitools.codegen.CodegenProperty;
-import org.openapitools.codegen.CodegenResponse;
-import org.openapitools.codegen.CodegenSecurity;
-import org.openapitools.codegen.DefaultGenerator;
-import org.openapitools.codegen.MockDefaultGenerator;
+import org.openapitools.codegen.*;
 import org.openapitools.codegen.MockDefaultGenerator.WrittenTemplateBasedFile;
-import org.openapitools.codegen.TestUtils;
+import org.openapitools.codegen.CodegenDiscriminator.MappedModel;
 import org.openapitools.codegen.config.CodegenConfigurator;
 import org.openapitools.codegen.languages.AbstractJavaCodegen;
 import org.openapitools.codegen.languages.JavaClientCodegen;
@@ -228,7 +219,7 @@ public void testPackageNamesSetInvokerDerivedFromModel() {
 
     @Test
     public void testGetSchemaTypeWithComposedSchemaWithAllOf() {
-        final OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/2_0/composed-allof.yaml");
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/2_0/composed-allof.yaml");
         final JavaClientCodegen codegen = new JavaClientCodegen();
 
         Operation operation = openAPI.getPaths().get("/ping").getPost();
@@ -450,7 +441,7 @@ public void testJdkHttpClient() throws Exception {
 
     @Test
     public void testReferencedHeader() {
-        final OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_0/issue855.yaml");
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/issue855.yaml");
         JavaClientCodegen codegen = new JavaClientCodegen();
         codegen.setOpenAPI(openAPI);
 
@@ -465,7 +456,7 @@ public void testReferencedHeader() {
 
     @Test
     public void testAuthorizationScopeValues_Issue392() {
-        final OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_0/issue392.yaml");
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/issue392.yaml");
 
         final DefaultGenerator defaultGenerator = new DefaultGenerator();
 
@@ -493,7 +484,7 @@ public void testAuthorizationScopeValues_Issue392() {
 
     @Test
     public void testAuthorizationsHasMoreWhenFiltered() {
-        final OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_0/issue4584.yaml");
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/issue4584.yaml");
 
         final DefaultGenerator defaultGenerator = new DefaultGenerator();
 
@@ -513,7 +504,7 @@ public void testAuthorizationsHasMoreWhenFiltered() {
 
     @Test
     public void testFreeFormObjects() {
-        final OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_0/issue796.yaml");
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/issue796.yaml");
         JavaClientCodegen codegen = new JavaClientCodegen();
 
         Schema test1 = openAPI.getComponents().getSchemas().get("MapTest1");
@@ -546,16 +537,102 @@ public void testFreeFormObjects() {
 
     @Test
     public void testBearerAuth() {
-        final OpenAPI openAPI = TestUtils.parseSpec("src/test/resources/3_0/pingBearerAuth.yaml");
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/pingBearerAuth.yaml");
         JavaClientCodegen codegen = new JavaClientCodegen();
-        
+
         List<CodegenSecurity> security = codegen.fromSecurity(openAPI.getComponents().getSecuritySchemes());
         Assert.assertEquals(security.size(), 1);
         Assert.assertEquals(security.get(0).isBasic, Boolean.TRUE);
         Assert.assertEquals(security.get(0).isBasicBasic, Boolean.FALSE);
         Assert.assertEquals(security.get(0).isBasicBearer, Boolean.TRUE);
     }
 
+    @Test
+    public void testComposedSchemaOneOfDiscriminatorMap() {
+        final OpenAPI openAPI = TestUtils.parseFlattenSpec("src/test/resources/3_0/oneoOfDiscriminator.yaml");
+        JavaClientCodegen codegen = new JavaClientCodegen();
+        codegen.setOpenAPI(openAPI);
+
+        String modelName;
+        Schema sc;
+        CodegenModel cm;
+        java.util.LinkedHashSet hs;
+        String mn;
+
+        // inline oneOf models
+        modelName = "FruitInlineDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        mn = "FruitInlineDisc_oneOf";
+        hs.add(new MappedModel(mn, codegen.toModelName(mn)));
+        mn = "FruitInlineDisc_oneOf_1";
+        hs.add(new MappedModel(mn, codegen.toModelName(mn)));
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+
+        // inline oneOf with inline oneOf model
+        modelName = "FruitInlineInlineDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+
+        // ref oneOf models with discriminator in properties in those models
+        modelName = "FruitReqDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        mn = "AppleReqDisc";
+        hs.add(new MappedModel(mn, mn));
+        mn = "BananaReqDisc";
+        hs.add(new MappedModel(mn, mn));
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+
+        // ref oneOf models with discriminator in allOf in those models
+        modelName = "FruitAllOfDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        mn = "AppleAllOfDisc";
+        hs.add(new MappedModel(mn, mn));
+        mn = "BananaAllOfDisc";
+        hs.add(new MappedModel(mn, mn));
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+
+        // ref oneOf models with discriminator in anyOf in those models
+        modelName = "FruitAnyOfDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        mn = "AppleAnyOfDisc";
+        hs.add(new MappedModel(mn, mn));
+        mn = "BananaAnyOfDisc";
+        hs.add(new MappedModel(mn, mn));
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+
+        // ref oneOf models with discriminator in oneOf in those models
+        modelName = "FruitOneOfDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        mn = "AppleOneOfDisc";
+        hs.add(new MappedModel(mn, mn));
+        mn = "BananaOneOfDisc";
+        hs.add(new MappedModel(mn, mn));
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+
+        // ref oneOf models with discriminator in the grandparent schemas of those oneof models
+        modelName = "FruitGrandparentDisc";
+        sc = openAPI.getComponents().getSchemas().get(modelName);
+        cm = codegen.fromModel(modelName, sc);
+        hs = new java.util.LinkedHashSet();
+        mn = "AppleGrandparentDisc";
+        hs.add(new MappedModel(mn, mn));
+        mn = "BananaGrandparentDisc";
+        hs.add(new MappedModel(mn, mn));
+        Assert.assertEquals(cm.discriminator.getMappedModels(), hs);
+    }
+
     private CodegenProperty codegenPropertyWithArrayOfIntegerValues() {
         CodegenProperty array = new CodegenProperty();
         final CodegenProperty items = new CodegenProperty();