diff --git a/boat-maven-plugin/src/main/java/com/backbase/oss/boat/GenerateMojo.java b/boat-maven-plugin/src/main/java/com/backbase/oss/boat/GenerateMojo.java index 8202545cc..233cdabe1 100644 --- a/boat-maven-plugin/src/main/java/com/backbase/oss/boat/GenerateMojo.java +++ b/boat-maven-plugin/src/main/java/com/backbase/oss/boat/GenerateMojo.java @@ -771,30 +771,30 @@ public void execute() throws MojoExecutionException, MojoFailureException { GlobalSettings.setProperty(CodegenConstants.WITH_XML, withXml.toString()); if (configOptions != null) { - // Retained for backwards-compataibility with configOptions -> instantiation-types + // Retained for backwards-compatibility with configOptions -> instantiation-types if (instantiationTypes == null && configOptions.containsKey(INSTANTIATION_TYPES)) { applyInstantiationTypesKvp(configOptions.get(INSTANTIATION_TYPES).toString(), configurator); } - // Retained for backwards-compataibility with configOptions -> import-mappings + // Retained for backwards-compatibility with configOptions -> import-mappings if (importMappings == null && configOptions.containsKey(IMPORT_MAPPINGS)) { applyImportMappingsKvp(configOptions.get(IMPORT_MAPPINGS).toString(), configurator); } - // Retained for backwards-compataibility with configOptions -> type-mappings + // Retained for backwards-compatibility with configOptions -> type-mappings if (typeMappings == null && configOptions.containsKey(TYPE_MAPPINGS)) { applyTypeMappingsKvp(configOptions.get(TYPE_MAPPINGS).toString(), configurator); } - // Retained for backwards-compataibility with configOptions -> language-specific-primitives + // Retained for backwards-compatibility with configOptions -> language-specific-primitives if (languageSpecificPrimitives == null && configOptions.containsKey(LANGUAGE_SPECIFIC_PRIMITIVES)) { applyLanguageSpecificPrimitivesCsv(configOptions .get(LANGUAGE_SPECIFIC_PRIMITIVES).toString(), configurator); } - // Retained for backwards-compataibility with configOptions -> additional-properties + // Retained for backwards-compatibility with configOptions -> additional-properties if (additionalProperties == null && configOptions.containsKey(ADDITIONAL_PROPERTIES)) { applyAdditionalPropertiesKvp(configOptions.get(ADDITIONAL_PROPERTIES).toString(), configurator); @@ -804,7 +804,7 @@ public void execute() throws MojoExecutionException, MojoFailureException { applyServerVariablesKvp(configOptions.get(SERVER_VARIABLES).toString(), configurator); } - // Retained for backwards-compataibility with configOptions -> reserved-words-mappings + // Retained for backwards-compatibility with configOptions -> reserved-words-mappings if (reservedWordsMappings == null && configOptions.containsKey(RESERVED_WORDS_MAPPINGS)) { applyReservedWordsMappingsKvp(configOptions.get(RESERVED_WORDS_MAPPINGS) .toString(), configurator); @@ -960,8 +960,8 @@ protected Collection getGeneratorSpecificSupportingFiles() { /** * Calculate openapi specification file hash. If specification is hosted on remote resource it is downloaded first * - * @param inputSpecFile - Openapi specification input file to calculate it's hash. - * Does not taken into account if input spec is hosted on remote resource + * @param inputSpecFile - Openapi specification input file to calculate its hash. + * Does not take into account if input spec is hosted on remote resource * @return openapi specification file hash * @throws IOException When cannot read the file */ @@ -1019,8 +1019,8 @@ private URL inputSpecRemoteUrl() { /** * Get specification hash file. * - * @param inputSpecFile - Openapi specification input file to calculate it's hash. - * Does not taken into account if input spec is hosted on remote resource + * @param inputSpecFile - Openapi specification input file to calculate its hash. + * Does not take into account if input spec is hosted on remote resource * @return a file with previously calculated hash */ private File getHashFile(File inputSpecFile) { @@ -1073,7 +1073,7 @@ private void addCompileSourceRootIfConfigured() { * config.additionalProperties (configuration/configOptions) to proper booleans. * This enables mustache files to handle the properties better. * - * @param config GodeGen config + * @param config CodeGen config */ private void adjustAdditionalProperties(final CodegenConfig config) { Map configAdditionalProperties = config.additionalProperties(); diff --git a/boat-scaffold/src/main/java/org/openapitools/codegen/languages/BoatSwift5Codegen.java b/boat-scaffold/src/main/java/org/openapitools/codegen/languages/BoatSwift5Codegen.java index 860269e62..ea31eb691 100644 --- a/boat-scaffold/src/main/java/org/openapitools/codegen/languages/BoatSwift5Codegen.java +++ b/boat-scaffold/src/main/java/org/openapitools/codegen/languages/BoatSwift5Codegen.java @@ -4,6 +4,7 @@ import io.swagger.v3.oas.models.media.Schema; import org.openapitools.codegen.CodegenConfig; import org.openapitools.codegen.CodegenModel; +import org.openapitools.codegen.CodegenProperty; import org.openapitools.codegen.SupportingFile; import org.openapitools.codegen.meta.GeneratorMetadata; import org.openapitools.codegen.meta.Stability; @@ -31,6 +32,12 @@ public BoatSwift5Codegen() { // Set the default template directory embeddedTemplateDir = templateDir = getName(); + + // Type mappings // + this.typeMapping.remove("object"); + this.typeMapping.remove("AnyType"); + this.typeMapping.put("object", "Any"); + this.typeMapping.put("AnyType", "Any"); } @Override @@ -62,6 +69,53 @@ public String getTypeDeclaration(Schema p) { return super.getTypeDeclaration(p); } + @Override + public CodegenModel fromModel(String name, Schema model) { + Map allDefinitions = ModelUtils.getSchemas(this.openAPI); + CodegenModel codegenModel = super.fromModel(name, model); + if (codegenModel.description != null) { + codegenModel.imports.add("ApiModel"); + } + + fixAllFreeFormObject(codegenModel); + + return codegenModel; + } + + /* + This is added as a compatibility requirement for API specs containing free form objects + missing `additionalProperties` property + */ + private void fixAllFreeFormObject(CodegenModel codegenModel) { + this.fixFreeFormObject(codegenModel.vars); + this.fixFreeFormObject(codegenModel.optionalVars); + this.fixFreeFormObject(codegenModel.requiredVars); + this.fixFreeFormObject(codegenModel.parentVars); + this.fixFreeFormObject(codegenModel.allVars); + this.fixFreeFormObject(codegenModel.readOnlyVars); + this.fixFreeFormObject(codegenModel.readWriteVars); + } + + /* + If a property has both isFreeFormObject and isMapContainer true make isFreeFormObject false + This way when we have a free form object in the spec that has a typed value it will be + treated as a Dictionary + */ + private void fixFreeFormObject(List codegenProperties) { + for (CodegenProperty codegenProperty : codegenProperties) { + if (codegenProperty.isFreeFormObject && codegenProperty.isMap && !codegenProperty.items.isFreeFormObject) { + codegenProperty.isFreeFormObject = false; + } + + if (codegenProperty.isArray && codegenProperty.items.isFreeFormObject) { + codegenProperty.isFreeFormObject = true; + if (codegenProperty.additionalProperties == null) { + codegenProperty.isMap = false; + } + } + } + } + // Fix for inheritance bug @Override public Map postProcessAllModels(Map objs) { @@ -113,7 +167,7 @@ private void fixInheritance(CodegenModel codegenModel, CodegenModel parentModel) @Override public void postProcess() { System.out.println("################################################################################"); - System.out.println("# Thanks for using BOAT Swift OpenAPI Generator. #"); + System.out.println("# Thanks for using BOAT Swift 5 OpenAPI Generator. #"); System.out.println("################################################################################"); } diff --git a/boat-scaffold/src/main/templates/boat-swift5/api_operation_parameter_model.mustache b/boat-scaffold/src/main/templates/boat-swift5/api_operation_parameter_model.mustache index deded1b7a..853f5e489 100644 --- a/boat-scaffold/src/main/templates/boat-swift5/api_operation_parameter_model.mustache +++ b/boat-scaffold/src/main/templates/boat-swift5/api_operation_parameter_model.mustache @@ -1,33 +1,33 @@ {{#allParams}} -{{#isEnum}} - {{> modelInlineEnumDeclaration}} -{{/isEnum}} + {{#isEnum}} + {{> modelInlineEnumDeclaration}} + {{/isEnum}} {{/allParams}} {{#allParams}} -{{#isEnum}} - {{#description}}/** {{description}} */ - {{/description}}{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} let {{paramName}}: {{{datatypeWithEnum}}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}} -{{/isEnum}} -{{^isEnum}} - {{#description}}/** {{description}} */ - {{/description}}{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} let {{paramName}}: {{{dataType}}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}} - {{#objcCompatible}} - {{#vendorExtensions.x-swift-optional-scalar}} - {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} var {{paramName}}Num: NSNumber? { - get { - return {{paramName}}.map({ return NSNumber(value: $0) }) - } - } - {{/vendorExtensions.x-swift-optional-scalar}} - {{/objcCompatible}} -{{/isEnum}} + {{#isEnum}} + {{#description}}/** {{description}} */ + {{/description}}{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} let {{paramName}}: {{{datatypeWithEnum}}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}} + {{/isEnum}} + {{^isEnum}} + {{#description}}/** {{description}} */ + {{/description}}{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} let {{paramName}}: {{{dataType}}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}} + {{#objcCompatible}} + {{#vendorExtensions.x-swift-optional-scalar}} + {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} var {{paramName}}Num: NSNumber? { + get { + return {{paramName}}.map({ return NSNumber(value: $0) }) + } + } + {{/vendorExtensions.x-swift-optional-scalar}} + {{/objcCompatible}} + {{/isEnum}} {{/allParams}} {{#hasParams}} internal init({{#allParams}}{{paramName}}: {{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{^required}}?{{/required}}{{^-last}}, {{/-last}}{{/allParams}}) { - {{#allParams}} + {{#allParams}} self.{{paramName}} = {{paramName}} - {{/allParams}} + {{/allParams}} } {{/hasParams}} {{#hasParams}} @@ -36,47 +36,47 @@ {{#allParams}} {{#description}}/** {{description}} */ {{/description}}{{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} {{#required}}let{{/required}}{{^required}}private(set) var{{/required}} {{> api_param_builder}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{#defaultValue}} = {{{defaultValue}}}{{/defaultValue}}{{/required}} - {{^isEnum}} - {{#objcCompatible}} - {{#vendorExtensions.x-swift-optional-scalar}} - {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} var {{paramName}}Num: NSNumber? { - get { - return {{paramName}}.map({ return NSNumber(value: $0) }) - } - } - {{/vendorExtensions.x-swift-optional-scalar}} - {{/objcCompatible}} - {{/isEnum}} + {{^isEnum}} + {{#objcCompatible}} + {{#vendorExtensions.x-swift-optional-scalar}} + {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} var {{paramName}}Num: NSNumber? { + get { + return {{paramName}}.map({ return NSNumber(value: $0) }) + } + } + {{/vendorExtensions.x-swift-optional-scalar}} + {{/objcCompatible}} + {{/isEnum}} {{/allParams}} - {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} init({{#requiredParams}}{{^-first}}, {{/-first}}{{> api_param_builder}}{{#defaultValue}} = {{{defaultValue}}}{{/defaultValue}}{{/requiredParams}}) { - {{#requiredParams}} - self.{{paramName}} = {{paramName}} - {{/requiredParams}} - } + {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} init({{#requiredParams}}{{^-first}}, {{/-first}}{{> api_param_builder}}{{#defaultValue}} = {{{defaultValue}}}{{/defaultValue}}{{/requiredParams}}) { + {{#requiredParams}} + self.{{paramName}} = {{paramName}} + {{/requiredParams}} + } {{#optionalParams}} /// Setter method for {{paramName}} property. {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} func set({{> api_param_builder}}?) -> Self { - self.{{paramName}} = {{paramName}} - return self + self.{{paramName}} = {{paramName}} + return self } {{/optionalParams}} - /// Builder initializer method for {{operationIdCamelCase}}RequestParams DTO. - {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} func build() -> {{operationIdCamelCase}}RequestParams { - return {{operationIdCamelCase}}RequestParams({{#allParams}}{{paramName}}: {{paramName}}{{^-last}}, - {{/-last}}{{/allParams}}) - } + /// Builder initializer method for {{operationIdCamelCase}}RequestParams DTO. + {{#nonPublicApi}}internal{{/nonPublicApi}}{{^nonPublicApi}}public{{/nonPublicApi}} func build() -> {{operationIdCamelCase}}RequestParams { + return {{operationIdCamelCase}}RequestParams({{#allParams}}{{paramName}}: {{paramName}}{{^-last}}, + {{/-last}}{{/allParams}}) + } - public static func ==(lhs: Builder, rhs: Builder) -> Bool { - return {{^hasParams}}true{{/hasParams}}{{#allParams}}{{#isFreeFormObject}}{{#isMap}}lhs.{{paramName}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}}.mapValues { AnyCodable($0) } == rhs.{{paramName}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}}.mapValues { AnyCodable($0) }{{/isMap}}{{^isMap}}AnyCodable(lhs.{{paramName}}) == AnyCodable(rhs.{{paramName}}){{/isMap}}{{/isFreeFormObject}}{{^isFreeFormObject}}lhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}} == rhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}}{{/isFreeFormObject}}{{^-last}} && - {{/-last}}{{/allParams}} - } + public static func ==(lhs: Builder, rhs: Builder) -> Bool { + return {{^hasParams}}true{{/hasParams}}{{#allParams}}{{#isFreeFormObject}}AnyCodable(lhs.{{paramName}}) == AnyCodable(rhs.{{paramName}}){{/isFreeFormObject}}{{^isFreeFormObject}}lhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}} == rhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}}{{/isFreeFormObject}}{{^-last}} && + {{/-last}}{{/allParams}} + } } {{/hasParams}} - public static func ==(lhs: Self, rhs: Self) -> Bool { - return {{^hasParams}}true{{/hasParams}}{{#allParams}}{{#isFreeFormObject}}{{#isMap}}lhs.{{paramName}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}}.mapValues { AnyCodable($0) } == rhs.{{paramName}}{{#required}}{{#isNullable}}?{{/isNullable}}{{/required}}{{^required}}?{{/required}}.mapValues { AnyCodable($0) }{{/isMap}}{{^isMap}}AnyCodable(lhs.{{paramName}}) == AnyCodable(rhs.{{paramName}}){{/isMap}}{{/isFreeFormObject}}{{^isFreeFormObject}}lhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}} == rhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}}{{/isFreeFormObject}}{{^-last}} && - {{/-last}}{{/allParams}} - } \ No newline at end of file +public static func ==(lhs: Self, rhs: Self) -> Bool { +return {{^hasParams}}true{{/hasParams}}{{#allParams}}{{#isFreeFormObject}}AnyCodable(lhs.{{paramName}}) == AnyCodable(rhs.{{paramName}}){{/isFreeFormObject}}{{^isFreeFormObject}}lhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}} == rhs.{{paramName}}{{#isArray}}{{^required}}?{{/required}}.description{{/isArray}}{{/isFreeFormObject}}{{^-last}} && +{{/-last}}{{/allParams}} +} \ No newline at end of file diff --git a/boat-scaffold/src/test/java/org/openapitools/codegen/languages/BoatSwift5CodegenTests.java b/boat-scaffold/src/test/java/org/openapitools/codegen/languages/BoatSwift5CodegenTests.java index 71d8c9317..d943c9cac 100644 --- a/boat-scaffold/src/test/java/org/openapitools/codegen/languages/BoatSwift5CodegenTests.java +++ b/boat-scaffold/src/test/java/org/openapitools/codegen/languages/BoatSwift5CodegenTests.java @@ -1,14 +1,26 @@ package org.openapitools.codegen.languages; -import io.swagger.v3.oas.models.media.ArraySchema; -import io.swagger.v3.oas.models.media.StringSchema; - +import io.swagger.parser.OpenAPIParser; +import io.swagger.v3.oas.models.Components; +import io.swagger.v3.oas.models.OpenAPI; +import io.swagger.v3.oas.models.Paths; +import io.swagger.v3.oas.models.info.Info; +import io.swagger.v3.oas.models.media.*; + +import io.swagger.v3.oas.models.media.Schema; +import io.swagger.v3.oas.models.servers.Server; +import io.swagger.v3.parser.core.models.ParseOptions; + +import io.swagger.v3.parser.util.SchemaTypeUtil; import org.junit.jupiter.api.Test; import org.openapitools.codegen.CodegenModel; import org.openapitools.codegen.CodegenProperty; +import org.openapitools.codegen.InlineModelResolver; import org.openapitools.codegen.model.ModelMap; import org.openapitools.codegen.model.ModelsMap; +import org.openapitools.codegen.utils.ModelUtils; +import java.lang.reflect.Array; import java.util.*; import static org.junit.jupiter.api.Assertions.*; @@ -28,14 +40,9 @@ public void testGetHelpMessage() { @Test public void testProcessOptsSetDBSDataProvider() { - boatSwift5CodeGen.setLibrary("dbsDataProvider"); - boatSwift5CodeGen.processOpts(); boatSwift5CodeGen.postProcess(); - -// assertThat(boatSwift5CodeGen.additionalProperties(), hasEntry("useDBSDataProvider", true)); - } @Test public void testGetTypeDeclaration() { @@ -131,18 +138,14 @@ public void suffixExceptionTest() { @Test public void prefixTest() { - boatSwift5CodeGen.setModelNamePrefix("API"); - final String result = boatSwift5CodeGen.toModelName("MyType"); assertEquals(result, "APIMyType"); } @Test public void suffixTest() { - boatSwift5CodeGen.setModelNameSuffix("API"); - final String result = boatSwift5CodeGen.toModelName("MyType"); assertEquals(result, "MyTypeAPI"); } @@ -150,10 +153,8 @@ public void suffixTest() { @Test public void testDefaultPodAuthors() throws Exception { // Given - // When boatSwift5CodeGen.processOpts(); - // Then final String podAuthors = (String) boatSwift5CodeGen.additionalProperties().get(Swift5ClientCodegen.POD_AUTHORS); assertEquals(podAuthors, Swift5ClientCodegen.DEFAULT_POD_AUTHORS); @@ -173,6 +174,111 @@ public void testPodAuthors() throws Exception { assertEquals(podAuthors, openAPIDevs); } + @Test + public void testFromModel() { + + final ObjectSchema objectSchema = new ObjectSchema(); + objectSchema.setDescription("Sample ObjectSchema"); + + final ArraySchema nestedArraySchema = new ArraySchema().items(new ObjectSchema()); + + final MapSchema mapSchema = new MapSchema(); + mapSchema.additionalProperties(objectSchema); + + final MapSchema mapSchema1 = new MapSchema(); + mapSchema1.setDescription("Sample ObjectSchema"); + mapSchema1.additionalProperties(new StringSchema()); + + final Schema schema = new Schema() + .description("a sample model") + .addProperty("id", new IntegerSchema().format(SchemaTypeUtil.INTEGER64_FORMAT)) + .addProperty("name", new StringSchema()) + .addProperty("content", objectSchema) + .addProperty("nested", nestedArraySchema) + .addProperty("map", mapSchema) + .addProperty("secondMap", mapSchema1) + .addRequiredItem("id") + .addRequiredItem("name") + .name("sample") + .discriminator(new Discriminator().propertyName("test")); + + OpenAPI openAPI = createOpenAPIWithOneSchema("sample", schema); + boatSwift5CodeGen.setOpenAPI(openAPI); + final CodegenModel cm = boatSwift5CodeGen.fromModel("sample", schema); + + assertEquals(cm.name, "sample"); + assertEquals(cm.classname, "Sample"); + assertEquals(cm.description, "a sample model"); + assertEquals(cm.vars.size(), 6); + assertEquals(cm.getDiscriminatorName(),"test"); + + final CodegenProperty property1 = cm.vars.get(0); + assertEquals(property1.baseName, "id"); + assertEquals(property1.dataType, "Int64"); + assertEquals(property1.name, "id"); + assertNull(property1.defaultValue); + assertEquals(property1.baseType, "Int64"); + assertTrue(property1.required); + assertTrue(property1.isPrimitiveType); + assertFalse(property1.isContainer); + + final CodegenProperty property2 = cm.vars.get(1); + assertEquals(property2.baseName, "name"); + assertEquals(property2.dataType, "String"); + assertEquals(property2.name, "name"); + assertNull(property2.defaultValue); + assertEquals(property2.baseType, "String"); + assertTrue(property2.required); + assertTrue(property2.isPrimitiveType); + assertFalse(property2.isContainer); + + final CodegenProperty property3 = cm.vars.get(2); + assertEquals(property3.baseName, "content"); + assertEquals(property3.dataType, "Any"); + assertEquals(property3.name, "content"); + assertNull(property3.defaultValue); + assertEquals(property3.baseType, "Any"); + assertFalse(property3.required); + assertFalse(property3.isContainer); + assertTrue(property3.isFreeFormObject); + + final CodegenProperty property4 = cm.vars.get(3); + assertEquals(property4.baseName, "nested"); + assertEquals(property4.dataType, "[Any]"); + assertEquals(property4.name, "nested"); + assertNull(property4.defaultValue); + assertEquals(property4.baseType, "Array"); + assertFalse(property4.required); + assertTrue(property4.isContainer); + assertTrue(property4.isFreeFormObject); + assertTrue(property4.items.isFreeFormObject); + + final CodegenProperty property5 = cm.vars.get(4); + assertEquals(property5.baseName, "map"); + assertEquals(property5.dataType, "[String: Any]"); + assertEquals(property5.name, "map"); + assertNull(property5.defaultValue); + assertEquals(property5.baseType, "Dictionary"); + assertFalse(property5.required); + assertTrue(property5.isContainer); + assertTrue(property5.isFreeFormObject); + assertTrue(property5.isMap); + assertTrue(property5.items.isFreeFormObject); + + final CodegenProperty property6 = cm.vars.get(5); + assertEquals(property6.baseName, "secondMap"); + assertEquals(property6.dataType, "[String: String]"); + assertEquals(property6.name, "secondMap"); + assertNull(property6.defaultValue); + assertEquals(property6.baseType, "Dictionary"); + assertFalse(property6.required); + assertTrue(property6.isContainer); + assertTrue(property6.isMap); + assertFalse(property6.isFreeFormObject); + assertFalse(property6.items.isFreeFormObject); + + } + @Test public void testPostProcessAllModels() { final CodegenModel parent = new CodegenModel(); @@ -212,4 +318,27 @@ static ModelsMap createCodegenModelWrapper(CodegenModel cm) { objs.setModels(modelMaps); return objs; } + + static OpenAPI createOpenAPIWithOneSchema(String name, Schema schema) { + OpenAPI openAPI = createOpenAPI(); + openAPI.setComponents(new Components()); + openAPI.getComponents().addSchemas(name, schema); + return openAPI; + } + static OpenAPI createOpenAPI() { + OpenAPI openAPI = new OpenAPI(); + openAPI.setComponents(new Components()); + openAPI.setPaths(new Paths()); + + final Info info = new Info(); + info.setDescription("API under test"); + info.setVersion("1.0.7"); + info.setTitle("My title"); + openAPI.setInfo(info); + + final Server server = new Server(); + server.setUrl("https://localhost:9999/root"); + openAPI.setServers(Collections.singletonList(server)); + return openAPI; + } }