diff --git a/modules/swagger-codegen/pom.xml b/modules/swagger-codegen/pom.xml index c62bf655b578..3ca7295a3c90 100644 --- a/modules/swagger-codegen/pom.xml +++ b/modules/swagger-codegen/pom.xml @@ -70,42 +70,6 @@ - - net.alchim31.maven - scala-maven-plugin - - - - add-source - compile - testCompile - - - - - incremental - - -Xmx384m - - - -target:jvm-1.6 - -deprecation - - - - run-scalatest - org.scalatest.tools.Runner - - -p - ${project.build.testOutputDirectory} - - - -Xmx512m - - - - - maven-compiler-plugin 3.0 @@ -140,15 +104,6 @@ 2.1 - - - - net.alchim31.maven - scala-maven-plugin - ${scala-maven-plugin-version} - - - @@ -156,43 +111,6 @@ true - - - - net.alchim31.maven - scala-maven-plugin - - - - compile - testCompile - - - - - ${scala-version} - - - - org.codehaus.mojo - build-helper-maven-plugin - - - add-source - prepare-package - - add-source - - - - src/main/scala - - - - - - - release-sign-artifacts @@ -238,11 +156,6 @@ - - net.alchim31.maven - scala-maven-plugin - ${scala-maven-plugin-version} - org.apache.maven.plugins maven-jxr-plugin @@ -327,18 +240,6 @@ commons-cli ${commons-cli-version} - - org.scalatest - scalatest_2.11 - ${scala-test-version} - test - - - org.scala-lang - scala-library - ${scala-version} - test - org.testng testng diff --git a/modules/swagger-codegen/src/test/java/io/swagger/codegen/CodegenTest.java b/modules/swagger-codegen/src/test/java/io/swagger/codegen/CodegenTest.java new file mode 100644 index 000000000000..ee70b427bfdf --- /dev/null +++ b/modules/swagger-codegen/src/test/java/io/swagger/codegen/CodegenTest.java @@ -0,0 +1,142 @@ +package io.swagger.codegen; + +import io.swagger.models.Operation; +import io.swagger.models.Swagger; +import io.swagger.models.properties.Property; +import io.swagger.parser.SwaggerParser; + +import org.testng.Assert; +import org.testng.annotations.Test; + +import java.util.List; + +public class CodegenTest { + + @Test(description = "read a file upload param from a 2.0 spec") + public void fileUploadParamTest() { + final Swagger model = new SwaggerParser().read("src/test/resources/2_0/petstore.json"); + final DefaultCodegen codegen = new DefaultCodegen(); + final String path = "/pet/{petId}/uploadImage"; + final Operation p = model.getPaths().get(path).getPost(); + final CodegenOperation op = codegen.fromOperation(path, "post", p, model.getDefinitions()); + + Assert.assertEquals(op.operationId, "uploadFile"); + Assert.assertEquals(op.httpMethod, "POST"); + Assert.assertTrue(op.hasConsumes); + Assert.assertEquals(op.consumes.size(), 1); + Assert.assertEquals(op.consumes.get(0).get("mediaType"), "multipart/form-data"); + Assert.assertTrue(op.hasProduces); + Assert.assertEquals(op.allParams.size(), 3); + Assert.assertEquals(op.formParams.size(), 2); + + final CodegenParameter file = op.formParams.get(1); + Assert.assertTrue(file.isFormParam); + Assert.assertEquals(file.dataType, "file"); + Assert.assertNull(file.required); + Assert.assertTrue(file.isFile); + Assert.assertNull(file.hasMore); + } + + @Test(description = "read formParam values from a 2.0 spec") + public void formParamTest() { + final Swagger model = new SwaggerParser().read("src/test/resources/2_0/petstore.json"); + final DefaultCodegen codegen = new DefaultCodegen(); + final String path = "/pet/{petId}"; + final Operation p = model.getPaths().get(path).getPost(); + final CodegenOperation op = codegen.fromOperation(path, "post", p, model.getDefinitions()); + + Assert.assertEquals(op.operationId, "updatePetWithForm"); + Assert.assertEquals(op.httpMethod, "POST"); + Assert.assertTrue(op.hasConsumes); + Assert.assertEquals(op.consumes.size(), 1); + Assert.assertEquals(op.consumes.get(0).get("mediaType"), "application/x-www-form-urlencoded"); + Assert.assertTrue(op.hasProduces); + Assert.assertEquals(op.produces.size(), 2); + Assert.assertEquals(op.produces.get(0).get("mediaType"), "application/json"); + Assert.assertEquals(op.produces.get(0).get("hasMore"), "true"); + Assert.assertEquals(op.produces.get(1).get("mediaType"), "application/xml"); + Assert.assertEquals(op.pathParams.size(), 1); + + final CodegenParameter idParam = op.pathParams.get(0); + Assert.assertTrue(idParam.isPathParam); + Assert.assertEquals(idParam.dataType, "String"); + Assert.assertTrue(idParam.required); + Assert.assertNull(idParam.hasMore); + + Assert.assertEquals(op.allParams.size(), 3); + Assert.assertEquals(op.formParams.size(), 2); + + final CodegenParameter nameParam = op.formParams.get(0); + Assert.assertTrue(nameParam.isFormParam); + Assert.assertTrue(nameParam.notFile); + Assert.assertEquals(nameParam.dataType, "String"); + Assert.assertNull(nameParam.required); + Assert.assertTrue(nameParam.hasMore); + + final CodegenParameter statusParam = op.formParams.get(1); + Assert.assertTrue(statusParam.isFormParam); + Assert.assertTrue(statusParam.notFile); + Assert.assertEquals(statusParam.dataType, "String"); + Assert.assertNull(statusParam.required); + Assert.assertNull(statusParam.hasMore); + } + + @Test(description = "handle required parameters from a 2.0 spec as required when figuring out Swagger types") + public void requiredParametersTest() { + final Swagger model = new SwaggerParser().read("src/test/resources/2_0/requiredTest.json"); + + final DefaultCodegen codegen = new DefaultCodegen() { + public String getSwaggerType(Property p) { + if (p != null && !p.getRequired()) { + return "Optional<" + super.getSwaggerType(p) + ">"; + } + return super.getSwaggerType(p); + } + }; + final String path = "/tests/requiredParams"; + final Operation p = model.getPaths().get(path).getGet(); + final CodegenOperation op = codegen.fromOperation(path, "get", p, model.getDefinitions()); + + final List formParams = op.formParams; + Assert.assertEquals(formParams.size(), 2); + Assert.assertEquals(formParams.get(0).dataType, "Long"); + Assert.assertEquals(formParams.get(1).dataType, "Optional"); + Assert.assertEquals(op.returnType, "Long"); + } + + @Test(description = "select main response from a 2.0 spec using the lowest 2XX code") + public void responseSelectionTest1() { + final Swagger model = new SwaggerParser().read("src/test/resources/2_0/responseSelectionTest.json"); + final DefaultCodegen codegen = new DefaultCodegen(); + final String path = "/tests/withTwoHundredAndDefault"; + final Operation p = model.getPaths().get(path).getGet(); + final CodegenOperation op = codegen.fromOperation(path, "get", p, model.getDefinitions()); + + Assert.assertEquals(op.returnType, "String"); + } + + @Test(description = "select main response from a 2.0 spec using the default keyword when no 2XX code") + public void responseSelectionTest2() { + final Swagger model = new SwaggerParser().read("src/test/resources/2_0/responseSelectionTest.json"); + final DefaultCodegen codegen = new DefaultCodegen(); + final String path = "/tests/withoutTwoHundredButDefault"; + final Operation p = model.getPaths().get(path).getGet(); + final CodegenOperation op = codegen.fromOperation(path, "get", p, model.getDefinitions()); + + Assert.assertEquals(op.returnType, "String"); + } + + @Test(description = "return byte array when response format is byte") + public void binaryDataTest() { + final Swagger model = new SwaggerParser().read("src/test/resources/2_0/binaryDataTest.json"); + final DefaultCodegen codegen = new DefaultCodegen(); + final String path = "/tests/binaryResponse"; + final Operation p = model.getPaths().get(path).getPost(); + final CodegenOperation op = codegen.fromOperation(path, "post", p, model.getDefinitions()); + + Assert.assertEquals(op.returnType, "byte[]"); + Assert.assertEquals(op.bodyParam.dataType, "byte[]"); + Assert.assertTrue(op.bodyParam.isBinary); + Assert.assertTrue(op.responses.get(0).isBinary); + } +} diff --git a/modules/swagger-codegen/src/test/java/io/swagger/codegen/ExampleGeneratorTest.java b/modules/swagger-codegen/src/test/java/io/swagger/codegen/ExampleGeneratorTest.java new file mode 100644 index 000000000000..339b77badbd4 --- /dev/null +++ b/modules/swagger-codegen/src/test/java/io/swagger/codegen/ExampleGeneratorTest.java @@ -0,0 +1,72 @@ +package io.swagger.codegen; + +import io.swagger.codegen.examples.ExampleGenerator; +import io.swagger.models.Model; +import io.swagger.models.ModelImpl; +import io.swagger.models.Xml; +import io.swagger.models.properties.ArrayProperty; +import io.swagger.models.properties.RefProperty; +import io.swagger.models.properties.StringProperty; + +import com.google.common.collect.ImmutableMap; +import com.google.common.collect.Sets; +import org.testng.Assert; +import org.testng.annotations.Test; + +import java.util.Arrays; +import java.util.List; +import java.util.Map; +import java.util.Set; + +public class ExampleGeneratorTest { + + @Test(description = "check handling of recursive models") + public void recursiveModelsTest() { + final String JSON = "application/json"; + final String XML = "application/xml"; + final String nodeType = "Node"; + final RefProperty ref = new RefProperty(nodeType); + final Model node = new ModelImpl().name(nodeType).property("name", new StringProperty()) + .property("parent", ref) + .property("children", new ArrayProperty(ref)) + .property("wrappedChildren", new ArrayProperty(ref).xml(new Xml().wrapped(true))); + final String pairType = "Pair"; + final ModelImpl pair = new ModelImpl().name(pairType); + for (Map.Entry item : ImmutableMap.of("first", "First", "second", "Second").entrySet()) { + final RefProperty property = new RefProperty(nodeType); + property.setXml(new Xml().name(item.getValue())); + pair.property(item.getKey(), property); + + } + final Set types = Sets.newHashSet(); + final List expectedTypes = Arrays.asList(JSON, XML); + + final ExampleGenerator eg = new ExampleGenerator(ImmutableMap.of(nodeType, node, pairType, pair)); + for (Map item : eg.generate(null, expectedTypes, new RefProperty(pairType))) { + final String example = item.get("example"); + final String contentType = item.get("contentType"); + if (XML.equals(contentType)) { + types.add(XML); + Assert.assertEquals(example, "\n" + + " \n" + + " string\n" + + " \n" + + " \n" + + " \n" + + " \n" + + " string\n" + + " \n" + + " \n" + + " \n" + + ""); + } else if (JSON.equals(contentType)) { + types.add(JSON); + // TODO - add JSON validation + Assert.assertNotNull(example); + } + } + + Assert.assertEqualsNoOrder(types.toArray(new String[types.size()]), + expectedTypes.toArray(new String[expectedTypes.size()])); + } +} diff --git a/modules/swagger-codegen/src/test/java/io/swagger/codegen/scala/ScalaModelTest.java b/modules/swagger-codegen/src/test/java/io/swagger/codegen/scala/ScalaModelTest.java new file mode 100644 index 000000000000..81290c473872 --- /dev/null +++ b/modules/swagger-codegen/src/test/java/io/swagger/codegen/scala/ScalaModelTest.java @@ -0,0 +1,250 @@ +package io.swagger.codegen.scala; + +import io.swagger.codegen.CodegenModel; +import io.swagger.codegen.CodegenProperty; +import io.swagger.codegen.DefaultCodegen; +import io.swagger.codegen.languages.ScalaClientCodegen; +import io.swagger.models.ArrayModel; +import io.swagger.models.Model; +import io.swagger.models.ModelImpl; +import io.swagger.models.properties.ArrayProperty; +import io.swagger.models.properties.DateTimeProperty; +import io.swagger.models.properties.LongProperty; +import io.swagger.models.properties.MapProperty; +import io.swagger.models.properties.RefProperty; +import io.swagger.models.properties.StringProperty; + +import com.google.common.collect.Sets; +import org.testng.Assert; +import org.testng.annotations.Test; + +public class ScalaModelTest { + + @Test(description = "convert a simple scala model") + public void simpleModelTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("id", new LongProperty()) + .property("name", new StringProperty()) + .property("createdAt", new DateTimeProperty()) + .required("id") + .required("name"); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 3); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "id"); + Assert.assertEquals(property1.getter, "getId"); + Assert.assertEquals(property1.setter, "setId"); + Assert.assertEquals(property1.datatype, "Long"); + Assert.assertEquals(property1.name, "id"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "Long"); + Assert.assertTrue(property1.hasMore); + Assert.assertTrue(property1.required); + Assert.assertTrue(property1.isNotContainer); + + final CodegenProperty property2 = cm.vars.get(1); + Assert.assertEquals(property2.baseName, "name"); + Assert.assertEquals(property2.getter, "getName"); + Assert.assertEquals(property2.setter, "setName"); + Assert.assertEquals(property2.datatype, "String"); + Assert.assertEquals(property2.name, "name"); + Assert.assertEquals(property2.defaultValue, "null"); + Assert.assertEquals(property2.baseType, "String"); + Assert.assertTrue(property2.hasMore); + Assert.assertTrue(property2.required); + Assert.assertTrue(property2.isNotContainer); + + final CodegenProperty property3 = cm.vars.get(2); + Assert.assertEquals(property3.baseName, "createdAt"); + Assert.assertEquals(property3.getter, "getCreatedAt"); + Assert.assertEquals(property3.setter, "setCreatedAt"); + Assert.assertEquals(property3.datatype, "DateTime"); + Assert.assertEquals(property3.name, "createdAt"); + Assert.assertEquals(property3.defaultValue, "null"); + Assert.assertEquals(property3.baseType, "DateTime"); + Assert.assertNull(property3.hasMore); + Assert.assertNull(property3.required); + Assert.assertTrue(property3.isNotContainer); + } + + @Test(description = "convert a model with list property") + public void listPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("id", new LongProperty()) + .property("urls", new ArrayProperty() + .items(new StringProperty())) + .required("id"); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 2); + + final CodegenProperty property1 = cm.vars.get(1); + Assert.assertEquals(property1.baseName, "urls"); + Assert.assertEquals(property1.getter, "getUrls"); + Assert.assertEquals(property1.setter, "setUrls"); + Assert.assertEquals(property1.datatype, "List[String]"); + Assert.assertEquals(property1.name, "urls"); + Assert.assertEquals(property1.defaultValue, "new ListBuffer[String]() "); + Assert.assertEquals(property1.baseType, "List"); + Assert.assertEquals(property1.containerType, "array"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isContainer); + } + + @Test(description = "convert a model with a map property") + public void mapPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("translations", new MapProperty() + .additionalProperties(new StringProperty())) + .required("id"); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "translations"); + Assert.assertEquals(property1.getter, "getTranslations"); + Assert.assertEquals(property1.setter, "setTranslations"); + Assert.assertEquals(property1.datatype, "Map[String, String]"); + Assert.assertEquals(property1.name, "translations"); + Assert.assertEquals(property1.defaultValue, "new HashMap[String, String]() "); + Assert.assertEquals(property1.baseType, "Map"); + Assert.assertEquals(property1.containerType, "map"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isContainer); + } + + @Test(description = "convert a model with complex properties") + public void complexPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.getter, "getChildren"); + Assert.assertEquals(property1.setter, "setChildren"); + Assert.assertEquals(property1.datatype, "Children"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "Children"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isNotContainer); + } + + @Test(description = "convert a model with complex list property") + public void complexListPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new ArrayProperty() + .items(new RefProperty("#/definitions/Children"))); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.complexType, "Children"); + Assert.assertEquals(property1.getter, "getChildren"); + Assert.assertEquals(property1.setter, "setChildren"); + Assert.assertEquals(property1.datatype, "List[Children]"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.defaultValue, "new ListBuffer[Children]() "); + Assert.assertEquals(property1.baseType, "List"); + Assert.assertEquals(property1.containerType, "array"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isContainer); + } + + @Test(description = "convert a model with complex map property") + public void complexMapPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new MapProperty() + .additionalProperties(new RefProperty("#/definitions/Children"))); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + Assert.assertEquals(Sets.intersection(cm.imports, Sets.newHashSet("Children")).size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.complexType, "Children"); + Assert.assertEquals(property1.getter, "getChildren"); + Assert.assertEquals(property1.setter, "setChildren"); + Assert.assertEquals(property1.datatype, "Map[String, Children]"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.defaultValue, "new HashMap[String, Children]() "); + Assert.assertEquals(property1.baseType, "Map"); + Assert.assertEquals(property1.containerType, "map"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isContainer); + Assert.assertNull(property1.isNotContainer); + } + + @Test(description = "convert an array model") + public void arrayModelTest() { + final Model model = new ArrayModel() + .description("an array model") + .items(new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "an array model"); + Assert.assertEquals(cm.vars.size(), 0); + Assert.assertEquals(cm.parent, "ListBuffer[Children]"); + Assert.assertEquals(cm.imports.size(), 2); + Assert.assertEquals(Sets.intersection(cm.imports, Sets.newHashSet("ListBuffer", "Children")).size(), 2); + } + + @Test(description = "convert an map model") + public void mapModelTest() { + final Model model = new ModelImpl() + .description("a map model") + .additionalProperties(new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new ScalaClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a map model"); + Assert.assertEquals(cm.vars.size(), 0); + Assert.assertEquals(cm.parent, "HashMap[String, Children]"); + Assert.assertEquals(cm.imports.size(), 2); + Assert.assertEquals(Sets.intersection(cm.imports, Sets.newHashSet("HashMap", "Children")).size(), 2); + } +} diff --git a/modules/swagger-codegen/src/test/java/io/swagger/codegen/staticDocs/StaticOperationTest.java b/modules/swagger-codegen/src/test/java/io/swagger/codegen/staticDocs/StaticOperationTest.java new file mode 100644 index 000000000000..f3e08e805417 --- /dev/null +++ b/modules/swagger-codegen/src/test/java/io/swagger/codegen/staticDocs/StaticOperationTest.java @@ -0,0 +1,61 @@ +package io.swagger.codegen.staticDocs; + +import io.swagger.codegen.CodegenProperty; +import io.swagger.codegen.DefaultCodegen; +import io.swagger.codegen.languages.StaticDocCodegen; +import io.swagger.models.properties.ArrayProperty; +import io.swagger.models.properties.RefProperty; +import io.swagger.models.properties.StringProperty; + +import org.testng.Assert; +import org.testng.annotations.Test; + +public class StaticOperationTest { + + @Test(description = "convert a string parameter") + public void stringParameterTest() { + final StringProperty property = new StringProperty(); + final DefaultCodegen codegen = new StaticDocCodegen(); + final CodegenProperty cp = codegen.fromProperty("property", property); + + Assert.assertEquals(cp.baseName, "property"); + Assert.assertEquals(cp.datatype, "String"); + Assert.assertEquals(cp.name, "property"); + Assert.assertEquals(cp.baseType, "string"); + Assert.assertTrue(cp.isNotContainer); + } + + @Test(description = "convert a complex parameter") + public void complexParameterTest() { + final RefProperty property = new RefProperty("Children"); + final DefaultCodegen codegen = new StaticDocCodegen(); + final CodegenProperty cp = codegen.fromProperty("property", property); + + Assert.assertEquals(cp.baseName, "property"); + Assert.assertEquals(cp.complexType, "Children"); + Assert.assertEquals(cp.getter, "getProperty"); + Assert.assertEquals(cp.setter, "setProperty"); + Assert.assertEquals(cp.datatype, "Children"); + Assert.assertEquals(cp.name, "property"); + Assert.assertEquals(cp.defaultValue, "null"); + Assert.assertEquals(cp.baseType, "Children"); + Assert.assertTrue(cp.isNotContainer); + } + + @Test(description = "convert a complex list parameter") + public void listParameterTest() { + final ArrayProperty property = new ArrayProperty().items(new RefProperty("Children")); + final DefaultCodegen codegen = new StaticDocCodegen(); + final CodegenProperty cp = codegen.fromProperty("property", property); + + Assert.assertEquals(cp.baseName, "property"); + Assert.assertEquals(cp.complexType, "Children"); + Assert.assertEquals(cp.getter, "getProperty"); + Assert.assertEquals(cp.setter, "setProperty"); + Assert.assertEquals(cp.datatype, "List"); + Assert.assertEquals(cp.name, "property"); + Assert.assertEquals(cp.baseType, "array"); + Assert.assertEquals(cp.containerType, "array"); + Assert.assertTrue(cp.isContainer); + } +} diff --git a/modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptangular/TypeScriptAngularModelTest.java b/modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptangular/TypeScriptAngularModelTest.java new file mode 100644 index 000000000000..55bbbeffdba4 --- /dev/null +++ b/modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptangular/TypeScriptAngularModelTest.java @@ -0,0 +1,181 @@ +package io.swagger.codegen.typescriptangular; + +import io.swagger.codegen.CodegenModel; +import io.swagger.codegen.CodegenProperty; +import io.swagger.codegen.DefaultCodegen; +import io.swagger.codegen.languages.TypeScriptAngularClientCodegen; +import io.swagger.models.ArrayModel; +import io.swagger.models.Model; +import io.swagger.models.ModelImpl; +import io.swagger.models.properties.ArrayProperty; +import io.swagger.models.properties.DateTimeProperty; +import io.swagger.models.properties.LongProperty; +import io.swagger.models.properties.RefProperty; +import io.swagger.models.properties.StringProperty; + +import com.google.common.collect.Sets; +import org.testng.Assert; +import org.testng.annotations.Test; + +public class TypeScriptAngularModelTest { + + @Test(description = "convert a simple TypeScript Angular model") + public void simpleModelTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("id", new LongProperty()) + .property("name", new StringProperty()) + .property("createdAt", new DateTimeProperty()) + .required("id") + .required("name"); + final DefaultCodegen codegen = new TypeScriptAngularClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 3); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "id"); + Assert.assertEquals(property1.datatype, "number"); + Assert.assertEquals(property1.name, "id"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "number"); + Assert.assertTrue(property1.hasMore); + Assert.assertTrue(property1.required); + Assert.assertTrue(property1.isNotContainer); + + final CodegenProperty property2 = cm.vars.get(1); + Assert.assertEquals(property2.baseName, "name"); + Assert.assertEquals(property2.datatype, "string"); + Assert.assertEquals(property2.name, "name"); + Assert.assertEquals(property2.defaultValue, "null"); + Assert.assertEquals(property2.baseType, "string"); + Assert.assertTrue(property2.hasMore); + Assert.assertTrue(property2.required); + Assert.assertTrue(property2.isNotContainer); + + final CodegenProperty property3 = cm.vars.get(2); + Assert.assertEquals(property3.baseName, "createdAt"); + Assert.assertEquals(property3.complexType, "Date"); + Assert.assertEquals(property3.datatype, "Date"); + Assert.assertEquals(property3.name, "createdAt"); + Assert.assertEquals(property3.defaultValue, "null"); + Assert.assertNull(property3.hasMore); + Assert.assertNull(property3.required); + Assert.assertTrue(property3.isNotContainer); + } + + @Test(description = "convert a model with list property") + public void listPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("id", new LongProperty()) + .property("urls", new ArrayProperty().items(new StringProperty())) + .required("id"); + final DefaultCodegen codegen = new TypeScriptAngularClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 2); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "id"); + Assert.assertEquals(property1.datatype, "number"); + Assert.assertEquals(property1.name, "id"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "number"); + Assert.assertTrue(property1.hasMore); + Assert.assertTrue(property1.required); + Assert.assertTrue(property1.isNotContainer); + + final CodegenProperty property2 = cm.vars.get(1); + Assert.assertEquals(property2.baseName, "urls"); + Assert.assertEquals(property2.datatype, "Array"); + Assert.assertEquals(property2.name, "urls"); + Assert.assertEquals(property2.baseType, "Array"); + Assert.assertNull(property2.hasMore); + Assert.assertNull(property2.required); + Assert.assertTrue(property2.isContainer); + } + + @Test(description = "convert a model with complex property") + public void complexPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new TypeScriptAngularClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.datatype, "Children"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "Children"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isNotContainer); + } + + @Test(description = "convert a model with complex list property") + public void complexListPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new ArrayProperty() + .items(new RefProperty("#/definitions/Children"))); + final DefaultCodegen codegen = new TypeScriptAngularClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.complexType, "Children"); + Assert.assertEquals(property1.datatype, "Array"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.baseType, "Array"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isContainer); + } + + @Test(description = "convert an array model") + public void arrayModelTest() { + final Model model = new ArrayModel() + .description("an array model") + .items(new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new TypeScriptAngularClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "an array model"); + Assert.assertEquals(cm.vars.size(), 0); + } + + @Test(description = "convert a map model") + public void mapModelTest() { + final Model model = new ModelImpl() + .description("a map model") + .additionalProperties(new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new TypeScriptAngularClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a map model"); + Assert.assertEquals(cm.vars.size(), 0); + Assert.assertEquals(cm.imports.size(), 1); + Assert.assertEquals(Sets.intersection(cm.imports, Sets.newHashSet("Children")).size(), 1); + } +} diff --git a/modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptnode/TypeScriptNodeModelTest.java b/modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptnode/TypeScriptNodeModelTest.java new file mode 100644 index 000000000000..a932ac2b5aea --- /dev/null +++ b/modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptnode/TypeScriptNodeModelTest.java @@ -0,0 +1,180 @@ +package io.swagger.codegen.typescriptnode; + +import io.swagger.codegen.CodegenModel; +import io.swagger.codegen.CodegenProperty; +import io.swagger.codegen.DefaultCodegen; +import io.swagger.codegen.languages.TypeScriptNodeClientCodegen; +import io.swagger.models.ArrayModel; +import io.swagger.models.Model; +import io.swagger.models.ModelImpl; +import io.swagger.models.properties.ArrayProperty; +import io.swagger.models.properties.DateTimeProperty; +import io.swagger.models.properties.LongProperty; +import io.swagger.models.properties.RefProperty; +import io.swagger.models.properties.StringProperty; + +import com.google.common.collect.Sets; +import org.testng.Assert; +import org.testng.annotations.Test; + +public class TypeScriptNodeModelTest { + + @Test(description = "convert a simple TypeScript Node model") + public void simpleModelTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("id", new LongProperty()) + .property("name", new StringProperty()) + .property("createdAt", new DateTimeProperty()) + .required("id") + .required("name"); + final DefaultCodegen codegen = new TypeScriptNodeClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 3); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "id"); + Assert.assertEquals(property1.datatype, "number"); + Assert.assertEquals(property1.name, "id"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "number"); + Assert.assertTrue(property1.hasMore); + Assert.assertTrue(property1.required); + Assert.assertTrue(property1.isNotContainer); + + final CodegenProperty property2 = cm.vars.get(1); + Assert.assertEquals(property2.baseName, "name"); + Assert.assertEquals(property2.datatype, "string"); + Assert.assertEquals(property2.name, "name"); + Assert.assertEquals(property2.defaultValue, "null"); + Assert.assertEquals(property2.baseType, "string"); + Assert.assertTrue(property2.hasMore); + Assert.assertTrue(property2.required); + Assert.assertTrue(property2.isNotContainer); + + final CodegenProperty property3 = cm.vars.get(2); + Assert.assertEquals(property3.baseName, "createdAt"); + Assert.assertEquals(property3.complexType, "Date"); + Assert.assertEquals(property3.datatype, "Date"); + Assert.assertEquals(property3.name, "createdAt"); + Assert.assertEquals(property3.defaultValue, "null"); + Assert.assertNull(property3.hasMore); + Assert.assertNull(property3.required); + Assert.assertTrue(property3.isNotContainer); + } + + @Test(description = "convert a model with list property") + public void listPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("id", new LongProperty()) + .property("urls", new ArrayProperty().items(new StringProperty())) + .required("id"); + final DefaultCodegen codegen = new TypeScriptNodeClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 2); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "id"); + Assert.assertEquals(property1.datatype, "number"); + Assert.assertEquals(property1.name, "id"); + Assert.assertEquals(property1.defaultValue, "null"); + Assert.assertEquals(property1.baseType, "number"); + Assert.assertTrue(property1.hasMore); + Assert.assertTrue(property1.required); + Assert.assertTrue(property1.isNotContainer); + + final CodegenProperty property2 = cm.vars.get(1); + Assert.assertEquals(property2.baseName, "urls"); + Assert.assertEquals(property2.datatype, "Array"); + Assert.assertEquals(property2.name, "urls"); + Assert.assertEquals(property2.baseType, "Array"); + Assert.assertNull(property2.hasMore); + Assert.assertNull(property2.required); + Assert.assertTrue(property2.isContainer); + } + + @Test(description = "convert a model with complex property") + public void complexPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new TypeScriptNodeClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.datatype, "Children"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.baseType, "Children"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isNotContainer); + } + + @Test(description = "convert a model with complex list property") + public void complexListPropertyTest() { + final Model model = new ModelImpl() + .description("a sample model") + .property("children", new ArrayProperty() + .items(new RefProperty("#/definitions/Children"))); + final DefaultCodegen codegen = new TypeScriptNodeClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a sample model"); + Assert.assertEquals(cm.vars.size(), 1); + + final CodegenProperty property1 = cm.vars.get(0); + Assert.assertEquals(property1.baseName, "children"); + Assert.assertEquals(property1.complexType, "Children"); + Assert.assertEquals(property1.datatype, "Array"); + Assert.assertEquals(property1.name, "children"); + Assert.assertEquals(property1.baseType, "Array"); + Assert.assertNull(property1.required); + Assert.assertTrue(property1.isContainer); + } + + @Test(description = "convert an array model") + public void arrayModelTest() { + final Model model = new ArrayModel() + .description("an array model") + .items(new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new TypeScriptNodeClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "an array model"); + Assert.assertEquals(cm.vars.size(), 0); + } + + @Test(description = "convert a map model") + public void mapModelTest() { + final Model model = new ModelImpl() + .description("a map model") + .additionalProperties(new RefProperty("#/definitions/Children")); + final DefaultCodegen codegen = new TypeScriptNodeClientCodegen(); + final CodegenModel cm = codegen.fromModel("sample", model); + + Assert.assertEquals(cm.name, "sample"); + Assert.assertEquals(cm.classname, "Sample"); + Assert.assertEquals(cm.description, "a map model"); + Assert.assertEquals(cm.vars.size(), 0); + Assert.assertEquals(cm.imports.size(), 1); + Assert.assertEquals(Sets.intersection(cm.imports, Sets.newHashSet("Children")).size(), 1); + } +} diff --git a/modules/swagger-codegen/src/test/scala/CodegenTest.scala b/modules/swagger-codegen/src/test/scala/CodegenTest.scala deleted file mode 100644 index 015932948de6..000000000000 --- a/modules/swagger-codegen/src/test/scala/CodegenTest.scala +++ /dev/null @@ -1,157 +0,0 @@ -import io.swagger.codegen.DefaultCodegen -import io.swagger.models.properties.Property -import io.swagger.parser._ -import org.junit.runner.RunWith -import org.scalatest.junit.JUnitRunner -import org.scalatest.{FlatSpec, Matchers} - -@RunWith(classOf[JUnitRunner]) -class CodegenTest extends FlatSpec with Matchers { - behavior of "Codegen" - - it should "read a file upload param from a 2.0 spec" in { - val model = new SwaggerParser() - .read("src/test/resources/2_0/petstore.json") - - val codegen = new DefaultCodegen() - val path = "/pet/{petId}/uploadImage" - val p = model.getPaths().get(path).getPost() - val op = codegen.fromOperation(path, "post", p, model.getDefinitions()) - - op.operationId should be("uploadFile") - op.httpMethod should be("POST") - op.hasConsumes should equal(true) - op.consumes.size should be(1) - op.consumes.get(0).get("mediaType") should be("multipart/form-data") - - op.hasProduces should equal(true) - val allParams = op.allParams - allParams.size should be(3) - - val formParams = op.formParams - formParams.size should be(2) - - val file = formParams.get(1) - file.isFormParam should equal(true) - file.dataType should be("file") - file.required should equal(null) - file.isFile should equal(true) - file.hasMore should be(null) - } - - it should "read formParam values from a 2.0 spec" in { - val model = new SwaggerParser() - .read("src/test/resources/2_0/petstore.json") - - val codegen = new DefaultCodegen() - val path = "/pet/{petId}" - val p = model.getPaths().get(path).getPost() - val op = codegen.fromOperation(path, "post", p, model.getDefinitions()) - - op.operationId should be("updatePetWithForm") - op.httpMethod should be("POST") - op.hasConsumes should equal(true) - op.consumes.size should be(1) - op.consumes.get(0).get("mediaType") should be("application/x-www-form-urlencoded") - - op.hasProduces should equal(true) - op.produces.size should be(2) - op.produces.get(0).get("mediaType") should be("application/json") - op.produces.get(0).get("hasMore") should be("true") - op.produces.get(1).get("mediaType") should be("application/xml") - - val pathParams = op.pathParams - pathParams.size should be(1) - - val idParam = pathParams.get(0) - idParam.isPathParam should equal(true) - idParam.dataType should be("String") - idParam.required should equal(true) - idParam.hasMore should be(null) - - val allParams = op.allParams - allParams.size should be(3) - - val formParams = op.formParams - formParams.size should be(2) - val nameParam = formParams.get(0) - nameParam.isFormParam should equal(true) - nameParam.notFile should equal(true) - nameParam.dataType should be("String") - nameParam.required should equal(null) - nameParam.hasMore should equal(true) - - val statusParam = formParams.get(1) - statusParam.isFormParam should equal(true) - statusParam.notFile should equal(true) - statusParam.dataType should be("String") - statusParam.required should equal(null) - statusParam.hasMore should be(null) - } - - it should "handle required parameters from a 2.0 spec as required when figuring out Swagger types" in { - val model = new SwaggerParser() - .read("src/test/resources/2_0/requiredTest.json") - - val codegen = new DefaultCodegen() { - override def getSwaggerType(p: Property) = Option(p) match { - case Some(property) if !property.getRequired => - "Optional<" + super.getSwaggerType(p) + ">" - case other => super.getSwaggerType(p) - } - } - val path = "/tests/requiredParams" - val p = model.getPaths().get(path).getGet() - val op = codegen.fromOperation(path, "get", p, model.getDefinitions) - - val formParams = op.formParams - formParams.size should be(2) - val requiredParam = formParams.get(0) - requiredParam.dataType should be("Long") - - val optionalParam = formParams.get(1) - optionalParam.dataType should be("Optional") - - op.returnType should be("Long") - } - - it should "select main response from a 2.0 spec using the lowest 2XX code" in { - val model = new SwaggerParser() - .read("src/test/resources/2_0/responseSelectionTest.json") - - val codegen = new DefaultCodegen() - - val path = "/tests/withTwoHundredAndDefault" - val p = model.getPaths().get(path).getGet() - val op = codegen.fromOperation(path, "get", p, model.getDefinitions()) - op.returnType should be("String") - - } - - it should "select main response from a 2.0 spec using the default keyword when no 2XX code" in { - val model = new SwaggerParser() - .read("src/test/resources/2_0/responseSelectionTest.json") - - val codegen = new DefaultCodegen() - - val path = "/tests/withoutTwoHundredButDefault" - val p = model.getPaths().get(path).getGet() - val op = codegen.fromOperation(path, "get", p, model.getDefinitions()) - op.returnType should be("String") - } - - it should "return byte array when response format is byte" in { - val model = new SwaggerParser() - .read("src/test/resources/2_0/binaryDataTest.json") - System.err.println("model is " + model); - val codegen = new DefaultCodegen() - - val path = "/tests/binaryResponse" - val p = model.getPaths().get(path).getPost() - val op = codegen.fromOperation(path, "post", p, model.getDefinitions()) - op.returnType should be("byte[]") - op.bodyParam.dataType should be ("byte[]") - op.bodyParam.isBinary should equal (true); - op.responses.get(0).isBinary should equal(true); - } -} \ No newline at end of file diff --git a/modules/swagger-codegen/src/test/scala/ExampleGeneratorTest.scala b/modules/swagger-codegen/src/test/scala/ExampleGeneratorTest.scala deleted file mode 100644 index 51cc5978dda5..000000000000 --- a/modules/swagger-codegen/src/test/scala/ExampleGeneratorTest.scala +++ /dev/null @@ -1,59 +0,0 @@ -import io.swagger.codegen.examples.ExampleGenerator -import io.swagger.models.{Model, ModelImpl, Xml} -import io.swagger.models.properties.{ArrayProperty, RefProperty, StringProperty} -import org.junit.runner.RunWith -import org.scalatest.{FlatSpec, Matchers} -import org.scalatest.junit.JUnitRunner - -import scala.collection.JavaConverters.{asScalaBufferConverter, mapAsJavaMapConverter, seqAsJavaListConverter} - -@RunWith(classOf[JUnitRunner]) -class ExampleGeneratorTest extends FlatSpec with Matchers { - val json = "application/json" - val xml = "application/xml" - - it should "check handling of recursive models" in { - val nodeType = "Node" - val ref = new RefProperty(nodeType) - val node = new ModelImpl().name(nodeType).property("name", new StringProperty()) - node.property("parent", ref) - node.property("children", new ArrayProperty(ref)) - node.property("wrappedChildren", new ArrayProperty(ref).xml(new Xml().wrapped(true))) - val pairType = "Pair" - val pair = new ModelImpl().name(pairType) - for (item <- Map("first" -> "First", "second" -> "Second")) { - val property = new RefProperty(nodeType) - property.setXml(new Xml().name(item._2)) - pair.property(item._1, property); - } - val types = scala.collection.mutable.Buffer[String]() - val expectedTypes = List(json, xml) - val eg = new ExampleGenerator(Map[String, Model](nodeType -> node, pairType -> pair).asJava) - for (item <- eg.generate(null, expectedTypes.asJava, new RefProperty(pairType)).asScala) { - val example = item.get("example") - item.get("contentType") match { - case `xml` => { - types += xml - example should be("\n" + - " \n" + - " string\n" + - " \n" + - " \n" + - " \n" + - " \n" + - " string\n" + - " \n" + - " \n" + - " \n" + - "") - } - case `json` => { - types += json - // TODO - add JSON validation - example should not be (null) - } - } - } - types should be(expectedTypes) - } -} diff --git a/modules/swagger-codegen/src/test/scala/scala/ScalaModelTest.scala b/modules/swagger-codegen/src/test/scala/scala/ScalaModelTest.scala deleted file mode 100644 index cf99149c49c1..000000000000 --- a/modules/swagger-codegen/src/test/scala/scala/ScalaModelTest.scala +++ /dev/null @@ -1,238 +0,0 @@ -package Scala - -import io.swagger.codegen.languages.ScalaClientCodegen -import io.swagger.models._ -import io.swagger.models.properties._ -import org.junit.runner.RunWith -import org.scalatest.{FlatSpec, Matchers} -import org.scalatest.junit.JUnitRunner - -import scala.collection.JavaConverters._ - -@RunWith(classOf[JUnitRunner]) -class ScalaModelTest extends FlatSpec with Matchers { - - it should "convert a simple scala model" in { - val model = new ModelImpl() - .description("a sample model") - .property("id", new LongProperty()) - .property("name", new StringProperty()) - .property("createdAt", new DateTimeProperty()) - .required("id") - .required("name") - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(3) - - val vars = cm.vars - vars.get(0).baseName should be("id") - vars.get(0).getter should be("getId") - vars.get(0).setter should be("setId") - vars.get(0).datatype should be("Long") - vars.get(0).name should be("id") - vars.get(0).defaultValue should be("null") - vars.get(0).baseType should be("Long") - vars.get(0).hasMore should equal(true) - vars.get(0).required should equal(true) - vars.get(0).isNotContainer should equal(true) - - vars.get(1).baseName should be("name") - vars.get(1).getter should be("getName") - vars.get(1).setter should be("setName") - vars.get(1).datatype should be("String") - vars.get(1).name should be("name") - vars.get(1).defaultValue should be("null") - vars.get(1).baseType should be("String") - vars.get(1).hasMore should equal(true) - vars.get(1).required should equal(true) - vars.get(1).isNotContainer should equal(true) - - vars.get(2).baseName should be("createdAt") - vars.get(2).getter should be("getCreatedAt") - vars.get(2).setter should be("setCreatedAt") - vars.get(2).datatype should be("DateTime") - vars.get(2).name should be("createdAt") - vars.get(2).defaultValue should be("null") - vars.get(2).baseType should be("DateTime") - vars.get(2).hasMore should equal(null) - vars.get(2).required should equal(null) - vars.get(2).isNotContainer should equal(true) - } - - it should "convert a model with list property" in { - val model = new ModelImpl() - .description("a sample model") - .property("id", new LongProperty()) - .property("urls", new ArrayProperty() - .items(new StringProperty())) - .required("id") - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(2) - - val vars = cm.vars - vars.get(1).baseName should be("urls") - vars.get(1).getter should be("getUrls") - vars.get(1).setter should be("setUrls") - vars.get(1).datatype should be("List[String]") - vars.get(1).name should be("urls") - vars.get(1).defaultValue should be("new ListBuffer[String]() ") - vars.get(1).baseType should be("List") - vars.get(1).containerType should be("array") - vars.get(1).required should equal(null) - vars.get(1).isContainer should equal(true) - } - - it should "convert a model with a map property" in { - val model = new ModelImpl() - .description("a sample model") - .property("translations", new MapProperty() - .additionalProperties(new StringProperty())) - .required("id") - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("translations") - vars.get(0).getter should be("getTranslations") - vars.get(0).setter should be("setTranslations") - vars.get(0).datatype should be("Map[String, String]") - vars.get(0).name should be("translations") - vars.get(0).defaultValue should be("new HashMap[String, String]() ") - vars.get(0).baseType should be("Map") - vars.get(0).containerType should be("map") - vars.get(0).required should equal(null) - vars.get(0).isContainer should equal(true) - } - - it should "convert a model with complex properties" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new RefProperty("#/definitions/Children")) - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).getter should be("getChildren") - vars.get(0).setter should be("setChildren") - vars.get(0).datatype should be("Children") - vars.get(0).name should be("children") - vars.get(0).defaultValue should be("null") - vars.get(0).baseType should be("Children") - vars.get(0).required should equal(null) - vars.get(0).isNotContainer should equal(true) - } - - it should "convert a model with complex list property" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new ArrayProperty() - .items(new RefProperty("#/definitions/Children"))) - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).complexType should be("Children") - vars.get(0).getter should be("getChildren") - vars.get(0).setter should be("setChildren") - vars.get(0).datatype should be("List[Children]") - vars.get(0).name should be("children") - vars.get(0).defaultValue should be("new ListBuffer[Children]() ") - vars.get(0).baseType should be("List") - vars.get(0).containerType should be("array") - vars.get(0).required should equal(null) - vars.get(0).isContainer should equal(true) - } - - it should "convert a model with complex map property" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new MapProperty() - .additionalProperties(new RefProperty("#/definitions/Children"))) - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - (cm.imports.asScala.toSet & Set("Children")).size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).complexType should be("Children") - vars.get(0).getter should be("getChildren") - vars.get(0).setter should be("setChildren") - vars.get(0).datatype should be("Map[String, Children]") - vars.get(0).name should be("children") - vars.get(0).defaultValue should be("new HashMap[String, Children]() ") - vars.get(0).baseType should be("Map") - vars.get(0).containerType should be("map") - vars.get(0).required should equal(null) - vars.get(0).isContainer should equal(true) - vars.get(0).isNotContainer should be(null) - } - - it should "convert an array model" in { - val model = new ArrayModel() - .description("an array model") - .items(new RefProperty("#/definitions/Children")) - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("an array model") - cm.vars.size should be(0) - cm.parent should be("ListBuffer[Children]") - cm.imports.size should be(2) - (cm.imports.asScala.toSet & Set("ListBuffer", "Children")).size should be(2) - } - - it should "convert an map model" in { - val model = new ModelImpl() - .description("an map model") - .additionalProperties(new RefProperty("#/definitions/Children")) - - val codegen = new ScalaClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("an map model") - cm.vars.size should be(0) - cm.parent should be("HashMap[String, Children]") - cm.imports.size should be(2) - (cm.imports.asScala.toSet & Set("HashMap", "Children")).size should be(2) - } -} \ No newline at end of file diff --git a/modules/swagger-codegen/src/test/scala/staticDocs/StaticOperationTest.scala b/modules/swagger-codegen/src/test/scala/staticDocs/StaticOperationTest.scala deleted file mode 100644 index f755361a3d43..000000000000 --- a/modules/swagger-codegen/src/test/scala/staticDocs/StaticOperationTest.scala +++ /dev/null @@ -1,59 +0,0 @@ -package staticDocs - -import io.swagger.codegen.languages.StaticDocCodegen -import io.swagger.models.properties._ -import org.junit.runner.RunWith -import org.scalatest.{FlatSpec, Matchers} -import org.scalatest.junit.JUnitRunner - -@RunWith(classOf[JUnitRunner]) -class StaticOperationTest extends FlatSpec with Matchers { - it should "convert a string parameter" in { - val property = new StringProperty() - - val codegen = new StaticDocCodegen() - val cp = codegen.fromProperty("property", property) - - cp.baseName should be("property") - cp.datatype should be("String") - cp.name should be("property") - cp.baseType should be("string") - cp.isNotContainer should equal(true) - } - - it should "convert a complex parameter" in { - val property = new RefProperty("Children") - - val codegen = new StaticDocCodegen() - val cp = codegen.fromProperty("property", property) - - cp.baseName should be("property") - cp.complexType should be("Children") - cp.getter should be("getProperty") - cp.setter should be("setProperty") - cp.datatype should be("Children") - cp.name should be("property") - cp.defaultValue should be("null") - cp.baseType should be("Children") - cp.isNotContainer should equal(true) - } - - it should "convert a complex list parameter" in { - val property = new ArrayProperty(). - items(new RefProperty("Children")) - - val codegen = new StaticDocCodegen() - val cp = codegen.fromProperty("property", property) - - cp.baseName should be("property") - cp.complexType should be("Children") - cp.getter should be("getProperty") - cp.setter should be("setProperty") - cp.datatype should be("List") - cp.name should be("property") - cp.baseType should be("array") - cp.containerType should be("array") - cp.isContainer should equal(true) - - } -} \ No newline at end of file diff --git a/modules/swagger-codegen/src/test/scala/typescriptangular/TypeScriptAngularModelTest.scala b/modules/swagger-codegen/src/test/scala/typescriptangular/TypeScriptAngularModelTest.scala deleted file mode 100644 index f82215253382..000000000000 --- a/modules/swagger-codegen/src/test/scala/typescriptangular/TypeScriptAngularModelTest.scala +++ /dev/null @@ -1,170 +0,0 @@ -package typescriptangular - -import io.swagger.codegen.languages.TypeScriptAngularClientCodegen -import io.swagger.models._ -import io.swagger.models.properties._ -import org.junit.runner.RunWith -import org.scalatest.{FlatSpec, Matchers} -import org.scalatest.junit.JUnitRunner - -import scala.collection.JavaConverters._ - -@RunWith(classOf[JUnitRunner]) -class TypeScriptAngularModelTest extends FlatSpec with Matchers { - - it should "convert a simple TypeScript Angular model" in { - val model = new ModelImpl() - .description("a sample model") - .property("id", new LongProperty()) - .property("name", new StringProperty()) - .property("createdAt", new DateTimeProperty()) - .required("id") - .required("name") - - val codegen = new TypeScriptAngularClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(3) - - val vars = cm.vars - vars.get(0).baseName should be("id") - vars.get(0).datatype should be("number") - vars.get(0).name should be("id") - vars.get(0).defaultValue should be("null") - vars.get(0).baseType should be("number") - vars.get(0).hasMore should equal(true) - vars.get(0).required should equal(true) - vars.get(0).isNotContainer should equal(true) - - vars.get(1).baseName should be("name") - vars.get(1).datatype should be("string") - vars.get(1).name should be("name") - vars.get(1).defaultValue should be("null") - vars.get(1).baseType should be("string") - vars.get(1).hasMore should equal(true) - vars.get(1).required should equal(true) - vars.get(1).isNotContainer should equal(true) - - vars.get(2).baseName should be("createdAt") - vars.get(2).complexType should be("Date") - vars.get(2).datatype should be("Date") - vars.get(2).name should be("createdAt") - vars.get(2).defaultValue should be("null") - vars.get(2).hasMore should equal(null) - vars.get(2).required should equal(null) - vars.get(2).isNotContainer should equal(true) - } - - it should "convert a model with list property" in { - val model = new ModelImpl() - .description("a sample model") - .property("id", new LongProperty()) - .property("urls", new ArrayProperty() - .items(new StringProperty())) - .required("id") - - val codegen = new TypeScriptAngularClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(2) - - val vars = cm.vars - vars.get(0).baseName should be("id") - vars.get(0).datatype should be("number") - vars.get(0).name should be("id") - vars.get(0).defaultValue should be("null") - vars.get(0).baseType should be("number") - vars.get(0).hasMore should equal(true) - vars.get(0).required should equal(true) - vars.get(0).isNotContainer should equal(true) - - vars.get(1).baseName should be("urls") - vars.get(1).datatype should be("Array") - vars.get(1).name should be("urls") - vars.get(1).baseType should be("Array") - vars.get(1).hasMore should be(null) - vars.get(1).required should equal(null) - vars.get(1).isContainer should equal(true) - } - - it should "convert a model with complex property" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new RefProperty("#/definitions/Children")) - - val codegen = new TypeScriptAngularClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).datatype should be("Children") - vars.get(0).name should be("children") - vars.get(0).baseType should be("Children") - vars.get(0).required should equal(null) - vars.get(0).isNotContainer should equal(true) - } - - it should "convert a model with complex list property" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new ArrayProperty() - .items(new RefProperty("#/definitions/Children"))) - - val codegen = new TypeScriptAngularClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).complexType should be("Children") - vars.get(0).datatype should be("Array") - vars.get(0).name should be("children") - vars.get(0).baseType should be("Array") - vars.get(0).required should equal(null) - vars.get(0).isContainer should equal(true) - } - - it should "convert an array model" in { - val model = new ArrayModel() - .description("an array model") - .items(new RefProperty("#/definitions/Children")) - val codegen = new TypeScriptAngularClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("an array model") - cm.vars.size should be(0) - } - - it should "convert an map model" in { - val model = new ModelImpl() - .description("an map model") - .additionalProperties(new RefProperty("#/definitions/Children")) - - val codegen = new TypeScriptAngularClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("an map model") - cm.vars.size should be(0) - cm.imports.size should be(1) - (cm.imports.asScala.toSet & Set("Children")).size should be(1) - } -} diff --git a/modules/swagger-codegen/src/test/scala/typescriptnode/TypeScriptNodeModelTest.scala b/modules/swagger-codegen/src/test/scala/typescriptnode/TypeScriptNodeModelTest.scala deleted file mode 100644 index 3ab26be651be..000000000000 --- a/modules/swagger-codegen/src/test/scala/typescriptnode/TypeScriptNodeModelTest.scala +++ /dev/null @@ -1,170 +0,0 @@ -package typescriptnode - -import io.swagger.codegen.languages.TypeScriptNodeClientCodegen -import io.swagger.models._ -import io.swagger.models.properties._ -import org.junit.runner.RunWith -import org.scalatest.{FlatSpec, Matchers} -import org.scalatest.junit.JUnitRunner - -import scala.collection.JavaConverters._ - -@RunWith(classOf[JUnitRunner]) -class TypeScriptNodeModelTest extends FlatSpec with Matchers { - - it should "convert a simple TypeScript Node model" in { - val model = new ModelImpl() - .description("a sample model") - .property("id", new LongProperty()) - .property("name", new StringProperty()) - .property("createdAt", new DateTimeProperty()) - .required("id") - .required("name") - - val codegen = new TypeScriptNodeClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(3) - - val vars = cm.vars - vars.get(0).baseName should be("id") - vars.get(0).datatype should be("number") - vars.get(0).name should be("id") - vars.get(0).defaultValue should be("null") - vars.get(0).baseType should be("number") - vars.get(0).hasMore should equal(true) - vars.get(0).required should equal(true) - vars.get(0).isNotContainer should equal(true) - - vars.get(1).baseName should be("name") - vars.get(1).datatype should be("string") - vars.get(1).name should be("name") - vars.get(1).defaultValue should be("null") - vars.get(1).baseType should be("string") - vars.get(1).hasMore should equal(true) - vars.get(1).required should equal(true) - vars.get(1).isNotContainer should equal(true) - - vars.get(2).baseName should be("createdAt") - vars.get(2).complexType should be("Date") - vars.get(2).datatype should be("Date") - vars.get(2).name should be("createdAt") - vars.get(2).defaultValue should be("null") - vars.get(2).hasMore should equal(null) - vars.get(2).required should equal(null) - vars.get(2).isNotContainer should equal(true) - } - - it should "convert a model with list property" in { - val model = new ModelImpl() - .description("a sample model") - .property("id", new LongProperty()) - .property("urls", new ArrayProperty() - .items(new StringProperty())) - .required("id") - - val codegen = new TypeScriptNodeClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(2) - - val vars = cm.vars - vars.get(0).baseName should be("id") - vars.get(0).datatype should be("number") - vars.get(0).name should be("id") - vars.get(0).defaultValue should be("null") - vars.get(0).baseType should be("number") - vars.get(0).hasMore should equal(true) - vars.get(0).required should equal(true) - vars.get(0).isNotContainer should equal(true) - - vars.get(1).baseName should be("urls") - vars.get(1).datatype should be("Array") - vars.get(1).name should be("urls") - vars.get(1).baseType should be("Array") - vars.get(1).hasMore should be(null) - vars.get(1).required should equal(null) - vars.get(1).isContainer should equal(true) - } - - it should "convert a model with complex property" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new RefProperty("#/definitions/Children")) - - val codegen = new TypeScriptNodeClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).datatype should be("Children") - vars.get(0).name should be("children") - vars.get(0).baseType should be("Children") - vars.get(0).required should equal(null) - vars.get(0).isNotContainer should equal(true) - } - - it should "convert a model with complex list property" in { - val model = new ModelImpl() - .description("a sample model") - .property("children", new ArrayProperty() - .items(new RefProperty("#/definitions/Children"))) - - val codegen = new TypeScriptNodeClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("a sample model") - cm.vars.size should be(1) - - val vars = cm.vars - vars.get(0).baseName should be("children") - vars.get(0).complexType should be("Children") - vars.get(0).datatype should be("Array") - vars.get(0).name should be("children") - vars.get(0).baseType should be("Array") - vars.get(0).required should equal(null) - vars.get(0).isContainer should equal(true) - } - - it should "convert an array model" in { - val model = new ArrayModel() - .description("an array model") - .items(new RefProperty("#/definitions/Children")) - val codegen = new TypeScriptNodeClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("an array model") - cm.vars.size should be(0) - } - - it should "convert an map model" in { - val model = new ModelImpl() - .description("an map model") - .additionalProperties(new RefProperty("#/definitions/Children")) - - val codegen = new TypeScriptNodeClientCodegen() - val cm = codegen.fromModel("sample", model) - - cm.name should be("sample") - cm.classname should be("Sample") - cm.description should be("an map model") - cm.vars.size should be(0) - cm.imports.size should be(1) - (cm.imports.asScala.toSet & Set("Children")).size should be(1) - } -}