loafle/openapi-generator-original
3
0
Fork 1
mirror of https://github.com/OpenAPITools/openapi-generator.git synced 2025-07-08 08:30:56 +00:00
Code Issues Packages Projects Releases Wiki Activity

Fixed #1304: Migrate tests from the Scala to the plain Java. Part 3

Browse Source
This commit is contained in:
Ivan Ushankin 2015-10-02 16:18:13 +03:00
parent 2711e375cc
commit 4b62a94350
13 changed files with 886 additions and 952 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

99
modules/swagger-codegen/pom.xml
View File

@ -70,42 +70,6 @@
</execution>
</executions>
</plugin>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>add-source</goal>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
<configuration>
<recompileMode>incremental</recompileMode>
<jvmArgs>
<jvmArg>-Xmx384m</jvmArg>
</jvmArgs>
<args>
<arg>-target:jvm-1.6</arg>
<arg>-deprecation</arg>
</args>
<launchers>
<launcher>
<id>run-scalatest</id>
<mainClass>org.scalatest.tools.Runner</mainClass>
<args>
<arg>-p</arg>
<arg>${project.build.testOutputDirectory}</arg>
</args>
<jvmArgs>
<jvmArg>-Xmx512m</jvmArg>
</jvmArgs>
</launcher>
</launchers>
</configuration>
</plugin>
<plugin>
<artifactId>maven-compiler-plugin</artifactId>
<version>3.0</version>
@ -140,15 +104,6 @@
<version>2.1</version>
</plugin>
</plugins>
<pluginManagement>
<plugins>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>${scala-maven-plugin-version}</version>
</plugin>
</plugins>
</pluginManagement>
</build>
<profiles>
<profile>
@ -156,43 +111,6 @@
<properties>
<skipTests>true</skipTests>
</properties>
<build>
<plugins>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<executions>
<execution>
<goals>
<goal>compile</goal>
<goal>testCompile</goal>
</goals>
</execution>
</executions>
<configuration>
<scalaVersion>${scala-version}</scalaVersion>
</configuration>
</plugin>
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>build-helper-maven-plugin</artifactId>
<executions>
<execution>
<id>add-source</id>
<phase>prepare-package</phase>
<goals>
<goal>add-source</goal>
</goals>
<configuration>
<sources>
<source>src/main/scala</source>
</sources>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</profile>
<profile>
<id>release-sign-artifacts</id>
@ -238,11 +156,6 @@
<excludePackageNames/>
</configuration>
</plugin>
<plugin>
<groupId>net.alchim31.maven</groupId>
<artifactId>scala-maven-plugin</artifactId>
<version>${scala-maven-plugin-version}</version>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-jxr-plugin</artifactId>
@ -327,18 +240,6 @@
<artifactId>commons-cli</artifactId>
<version>${commons-cli-version}</version>
</dependency>
<dependency>
<groupId>org.scalatest</groupId>
<artifactId>scalatest_2.11</artifactId>
<version>${scala-test-version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.scala-lang</groupId>
<artifactId>scala-library</artifactId>
<version>${scala-version}</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>

142
modules/swagger-codegen/src/test/java/io/swagger/codegen/CodegenTest.java Normal file
View File

@ -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<CodegenParameter> formParams = op.formParams;
Assert.assertEquals(formParams.size(), 2);
Assert.assertEquals(formParams.get(0).dataType, "Long");
Assert.assertEquals(formParams.get(1).dataType, "Optional<string>");
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);
}
}

72
modules/swagger-codegen/src/test/java/io/swagger/codegen/ExampleGeneratorTest.java Normal file
View File

@ -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<String, String> 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<String> types = Sets.newHashSet();
final List<String> expectedTypes = Arrays.asList(JSON, XML);
final ExampleGenerator eg = new ExampleGenerator(ImmutableMap.of(nodeType, node, pairType, pair));
for (Map<String, String> 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, "<Pair>\n" +
" <Node>\n" +
" <name>string</name>\n" +
" <wrappedChildren>\n" +
" </wrappedChildren>\n" +
" </Node>\n" +
" <Node>\n" +
" <name>string</name>\n" +
" <wrappedChildren>\n" +
" </wrappedChildren>\n" +
" </Node>\n" +
"</Pair>");
} 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()]));
}
}

250
modules/swagger-codegen/src/test/java/io/swagger/codegen/scala/ScalaModelTest.java Normal file
View File

@ -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);
}
}

61
modules/swagger-codegen/src/test/java/io/swagger/codegen/staticDocs/StaticOperationTest.java Normal file
View File

@ -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);
}
}

181
modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptangular/TypeScriptAngularModelTest.java Normal file
View File

@ -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<string>");
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<Children>");
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);
}
}

180
modules/swagger-codegen/src/test/java/io/swagger/codegen/typescriptnode/TypeScriptNodeModelTest.java Normal file
View File

@ -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<string>");
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<Children>");
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);
}
}

157
modules/swagger-codegen/src/test/scala/CodegenTest.scala
View File

@ -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<string>")
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);
}
}

59
modules/swagger-codegen/src/test/scala/ExampleGeneratorTest.scala
View File

@ -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("<Pair>\n" +
" <Node>\n" +
" <name>string</name>\n" +
" <wrappedChildren>\n" +
" </wrappedChildren>\n" +
" </Node>\n" +
" <Node>\n" +
" <name>string</name>\n" +
" <wrappedChildren>\n" +
" </wrappedChildren>\n" +
" </Node>\n" +
"</Pair>")
}
case `json` => {
types += json
// TODO - add JSON validation
example should not be (null)
}
}
}
types should be(expectedTypes)
}
}

238
modules/swagger-codegen/src/test/scala/scala/ScalaModelTest.scala
View File

@ -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)
}
}

59
modules/swagger-codegen/src/test/scala/staticDocs/StaticOperationTest.scala
View File

@ -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)
}
}

170
modules/swagger-codegen/src/test/scala/typescriptangular/TypeScriptAngularModelTest.scala
View File

@ -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<string>")
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<Children>")
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)
}
}

170
modules/swagger-codegen/src/test/scala/typescriptnode/TypeScriptNodeModelTest.scala
View File

@ -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<string>")
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<Children>")
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)
}
}