Merge pull request #1329 from iushankin/issue-1304-part3

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

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

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<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()]));
+    }
+}

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

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

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

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