Clean up tests, add test for alias ref, fixes YousefED#77

Author: domoritz

Diff for: test/programs/interface-recursion/schema.json

@@ -7,7 +7,11 @@
             "properties":{
                 "propA":{"type":"number"},
                 "propB":{"$ref": "#/definitions/MyObject"}
-            }
+            },
+            "required": [
+                "propA",
+                "propB"
+            ]
         }
     }
 }

Diff for: test/programs/type-alias-single/main.ts

@@ -0,0 +1 @@
+type MyString = string;

Diff for: test/programs/type-alias-single/schema.json

@@ -0,0 +1,4 @@
+{
+    "$schema": "http://json-schema.org/draft-04/schema#",
+    "type": "string"
+}

Diff for: test/programs/type-aliases/main.ts

@@ -1 +1,11 @@
 type MyString = string;
+
+interface MySubObject {
+    propA: number;
+    propB: number;
+}
+
+interface MyObject {
+    primitive: MyString;
+    object: MySubObject;
+}

Diff for: test/programs/type-aliases/schema.json

@@ -1,4 +1,36 @@
 {
     "$schema": "http://json-schema.org/draft-04/schema#",
-    "type": "string"
+    "definitions": {
+        "MyString": {
+            "type": "string"
+        },
+        "MySubObject": {
+            "properties": {
+                "propA": {
+                    "type": "number"
+                },
+                "propB": {
+                    "type": "number"
+                }
+            },
+            "type": "object",
+            "required": [
+                "propA",
+                "propB"
+            ]
+        }
+    },
+    "properties": {
+        "object": {
+            "$ref": "#/definitions/MySubObject"
+        },
+        "primitive": {
+            "$ref": "#/definitions/MyString"
+        }
+    },
+    "required": [
+        "primitive",
+        "object"
+    ],
+    "type": "object"
 }

Diff for: test/schema.test.ts

@@ -9,11 +9,15 @@ const ajv = new Ajv();
 
 const base = "test/programs/";
 
-export function assertSchema(group: string, name: string, type: string, settings?: any, compilerOptions?: CompilerOptions) {
+export function assertSchema(group: string, name: string, type: string, settings: any = {}, compilerOptions?: CompilerOptions) {
     it(group + " should create correct schema", function() {
-        if (!settings) {
-            settings = TJS.getDefaultArgs();
-            settings.generateRequired = true;
+        const defaults = TJS.getDefaultArgs();
+        defaults.generateRequired = true;
+
+        for (let pref in defaults) {
+            if (!(pref in settings)) {
+                settings[pref] = defaults[pref];
+            }
         }
 
         const actual = TJS.generateSchema(TJS.getProgramFromFiles([resolve(base + group + "/" + name)], compilerOptions), type, settings);
@@ -37,9 +41,9 @@ describe("schema", function () {
     assertSchema("interface-single", "main.ts", "MyObject");
     assertSchema("interface-multi", "main.ts", "MyObject");
 
-    let settings = TJS.getDefaultArgs();
-    settings.useRootRef = true;
-    assertSchema("interface-recursion", "main.ts", "MyObject", settings); // this sample needs rootRef
+    assertSchema("interface-recursion", "main.ts", "MyObject", {
+        useRootRef: true
+    });
 
     assertSchema("module-interface-single", "main.ts", "MyObject");
 
@@ -62,7 +66,10 @@ describe("schema", function () {
     assertSchema("type-union", "main.ts", "MyObject");
     assertSchema("type-intersection", "main.ts", "MyObject");
 
-    assertSchema("type-aliases", "main.ts", "MyString");
+    assertSchema("type-alias-single", "main.ts", "MyString");
+    assertSchema("type-aliases", "main.ts", "MyObject", {
+        useTypeAliasRef: true
+    });
     assertSchema("type-aliases-fixed-size-array", "main.ts", "MyFixedSizeArray");
     assertSchema("type-aliases-multitype-array", "main.ts", "MyArray");
     assertSchema("type-anonymous", "main.ts", "MyObject");

Diff for: typescript-json-schema.ts

@@ -6,6 +6,9 @@ import * as stringify from "json-stable-stringify";
 
 const vm = require("vm");
 
+const REGEX_FILE_NAME = /".*"\./;
+const REGEX_TJS_JSDOC = /^-([\w]+)\s([\w]+)/g;
+
 export function getDefaultArgs() {
     return {
         useRef: true,
@@ -119,7 +122,7 @@ export class JsonSchemaGenerator {
         const jsdocs = symbol.getJsDocTags();
         jsdocs.forEach(doc => {
             // if we have @TJS-... annotations, we have to parse them
-            const [name, text] = doc.name === "TJS" ? /^-([\w]+)\s([\w]+)/g.exec(doc.text).slice(1,3) : [doc.name, doc.text];
+            const [name, text] = doc.name === "TJS" ? new RegExp(REGEX_TJS_JSDOC).exec(doc.text).slice(1,3) : [doc.name, doc.text];
             if (JsonSchemaGenerator.validationKeywords[name]) {
                 definition[name] = this.parseValue(text);
             } else {
@@ -577,16 +580,16 @@ export class JsonSchemaGenerator {
         const asTypeAliasRef = asRef && reffedType && (this.args.useTypeAliasRef || isStringEnum);
         if (!asTypeAliasRef) {
             if (isRawType || typ.getFlags() & ts.TypeFlags.Object && (<ts.ObjectType>typ).objectFlags & ts.ObjectFlags.Anonymous) {
-                asRef = false; // raw types and inline types cannot be reffed,
+                asRef = false;  // raw types and inline types cannot be reffed,
                                 // unless we are handling a type alias
             }
         }
 
         let fullTypeName = "";
-        if (asRef) {
+        if (asTypeAliasRef) {
+            fullTypeName = tc.getFullyQualifiedName(reffedType).replace(REGEX_FILE_NAME, "");
+        } else if (asRef) {
             fullTypeName = tc.typeToString(typ, undefined, ts.TypeFormatFlags.UseFullyQualifiedType);
-        } else if (asTypeAliasRef) {
-            fullTypeName = tc.getFullyQualifiedName(reffedType);
         }
 
         if (asRef) {