Improve code coverage (#24)

Author: mrix

src/Error/BaseError.ts

@@ -1,12 +1,8 @@
 export abstract class BaseError implements Error {
-    private callStack: any;
+    public readonly stack: string;
 
-    public constructor() {
-        this.callStack = new Error().stack;
-    }
-
-    public get stack(): string {
-        return this.callStack;
+    protected constructor() {
+        Error.captureStackTrace(this, this.constructor);
     }
 
     public abstract get name(): string;

src/Error/UnknownNodeError.ts

@@ -10,7 +10,7 @@ export class UnknownNodeError extends BaseError {
         return "UnknownNodeError";
     }
     public get message(): string {
-        return `Unknown node "${this.node.getFullText()}`;
+        return `Unknown node "${this.node.getFullText()}"`;
     }
 
     public getNode(): ts.Node {

src/NodeParser/EnumNodeParser.ts

@@ -3,6 +3,8 @@ import { Context } from "../NodeParser";
 import { SubNodeParser } from "../SubNodeParser";
 import { BaseType } from "../Type/BaseType";
 import { EnumType, EnumValue } from "../Type/EnumType";
+import { UnknownNodeError } from "../Error/UnknownNodeError";
+import { assertDefined } from "../Utils/assert";
 
 export class EnumNodeParser implements SubNodeParser {
     public constructor(
@@ -20,24 +22,18 @@ export class EnumNodeParser implements SubNodeParser {
 
         return new EnumType(
             `enum-${node.getFullStart()}`,
-            members.map((member, index) => this.getMemberValue(member, index)),
+            members.map((member) => this.getMemberValue(member)),
         );
     }
 
-    private getMemberValue(member: ts.EnumMember, index: number): EnumValue {
+    private getMemberValue(member: ts.EnumMember): EnumValue {
         const constantValue = this.typeChecker.getConstantValue(member);
         if (constantValue !== undefined) {
             return constantValue;
         }
 
-        const initializer = member.initializer;
-        if (!initializer) {
-            return index;
-        } else if (initializer.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral) {
-            return member.name.getText();
-        } else {
-            return this.parseInitializer(initializer);
-        }
+        const initializer = assertDefined(member.initializer);
+        return this.parseInitializer(initializer);
     }
     private parseInitializer(initializer: ts.Node): EnumValue {
         if (initializer.kind === ts.SyntaxKind.TrueKeyword) {
@@ -46,16 +42,20 @@ export class EnumNodeParser implements SubNodeParser {
             return false;
         } else if (initializer.kind === ts.SyntaxKind.NullKeyword) {
             return null;
+        } else if (initializer.kind === ts.SyntaxKind.NumericLiteral) {
+            return parseFloat((initializer as ts.NumericLiteral).text);
         } else if (initializer.kind === ts.SyntaxKind.StringLiteral) {
-            return (initializer as ts.LiteralLikeNode).text;
+            return (initializer as ts.StringLiteral).text;
+        } else if (initializer.kind === ts.SyntaxKind.NoSubstitutionTemplateLiteral) {
+            return (initializer as ts.NoSubstitutionTemplateLiteral).text;
         } else if (initializer.kind === ts.SyntaxKind.ParenthesizedExpression) {
             return this.parseInitializer((initializer as ts.ParenthesizedExpression).expression);
         } else if (initializer.kind === ts.SyntaxKind.AsExpression) {
             return this.parseInitializer((initializer as ts.AsExpression).expression);
         } else if (initializer.kind === ts.SyntaxKind.TypeAssertionExpression) {
             return this.parseInitializer((initializer as ts.TypeAssertion).expression);
-        } else {
-            return initializer.getText();
         }
+
+        throw new UnknownNodeError(initializer);
     }
 }

src/Schema/Definition.ts

@@ -14,9 +14,7 @@ export interface Definition {
     format?: string;
     items?: Definition | Definition[];
     minItems?: number;
-    additionalItems?: {
-        anyOf: Definition[],
-    };
+    additionalItems?: false | Definition;
     enum?: (RawType | Definition)[];
     default?: RawType | Object;
     additionalProperties?: false | Definition;

src/TypeFormatter/LiteralUnionTypeFormatter.ts

@@ -8,7 +8,11 @@ import { uniqueArray } from "../Utils/uniqueArray";
 
 export class LiteralUnionTypeFormatter implements SubTypeFormatter {
     public supportsType(type: UnionType): boolean {
-        return type instanceof UnionType && this.isLiteralUnion(type);
+        return (
+            type instanceof UnionType &&
+            type.getTypes().length > 0 &&
+            this.isLiteralUnion(type)
+        );
     }
     public getDefinition(type: UnionType): Definition {
         const values = uniqueArray(type.getTypes().map((item: LiteralType | NullType) => this.getLiteralValue(item)));

src/TypeFormatter/PrimitiveUnionTypeFormatter.ts

@@ -13,7 +13,11 @@ import { NullType } from "../Type/NullType";
 
 export class PrimitiveUnionTypeFormatter implements SubTypeFormatter {
     public supportsType(type: UnionType): boolean {
-        return type instanceof UnionType && this.isPrimitiveUnion(type);
+        return (
+            type instanceof UnionType &&
+            type.getTypes().length > 0 &&
+            this.isPrimitiveUnion(type)
+        );
     }
     public getDefinition(type: UnionType): Definition {
         return {

src/TypeFormatter/TupleTypeFormatter.ts

@@ -3,6 +3,7 @@ import { SubTypeFormatter } from "../SubTypeFormatter";
 import { TupleType } from "../Type/TupleType";
 import { BaseType } from "../Type/BaseType";
 import { Definition } from "../Schema/Definition";
+import { UnionType } from "../Type/UnionType";
 
 export class TupleTypeFormatter implements SubTypeFormatter {
     public constructor(
@@ -14,14 +15,21 @@ export class TupleTypeFormatter implements SubTypeFormatter {
         return type instanceof TupleType;
     }
     public getDefinition(type: TupleType): Definition {
-        const tupleDefinitions = type.getTypes().map((item) => this.childTypeFormatter.getDefinition(item));
-
-        return {
-            type: "array",
-            items: tupleDefinitions,
-            minItems: tupleDefinitions.length,
-            ...(tupleDefinitions.length > 1 ? {additionalItems: {anyOf: tupleDefinitions}} : {}),
-        };
+        const itemTypes = type.getTypes();
+        if (itemTypes.length > 1) {
+            return {
+                type: "array",
+                items: itemTypes.map((item) => this.childTypeFormatter.getDefinition(item)),
+                minItems: itemTypes.length,
+                additionalItems: this.childTypeFormatter.getDefinition(new UnionType(itemTypes)),
+            };
+        } else {
+            return {
+                type: "array",
+                items: this.childTypeFormatter.getDefinition(itemTypes[0]),
+                minItems: 1,
+            };
+        }
     }
     public getChildren(type: TupleType): BaseType[] {
         return type.getTypes().reduce((result: BaseType[], item) => [

src/TypeFormatter/UnionTypeFormatter.ts

@@ -34,9 +34,13 @@ export class UnionTypeFormatter implements SubTypeFormatter {
             };
         }
 
-        return definitions.length > 1 ? {
-            anyOf: definitions,
-        } : definitions[0];
+        if (definitions.length === 0) {
+            return {not: {}};
+        } else if (definitions.length === 1) {
+            return definitions[0];
+        } else {
+            return {anyOf: definitions};
+        }
     }
     public getChildren(type: UnionType): BaseType[] {
         return type.getTypes().reduce((result: BaseType[], item) => [

test/config.test.ts

@@ -55,6 +55,7 @@ describe("config", () => {
     assertSchema("jsdoc-complex-basic", {type: "MyObject", expose: "export", topRef: true, jsDoc: "basic"});
     assertSchema("jsdoc-complex-extended", {type: "MyObject", expose: "export", topRef: true, jsDoc: "extended"});
     assertSchema("jsdoc-description-only", {type: "MyObject", expose: "export", topRef: true, jsDoc: "extended"});
+    assertSchema("jsdoc-empty-or-invalid", {type: "MyObject", expose: "export", topRef: true, jsDoc: "basic"});
 
     assertSchema("jsdoc-inheritance", {type: "MyObject", expose: "export", topRef: true, jsDoc: "extended"});
 });

test/config/jsdoc-empty-or-invalid/main.ts

@@ -0,0 +1,21 @@
+/**
+ * @title Some title here
+ * @description Some description here
+ */
+export interface MyObject {
+    /**
+     * @minLength 123
+     * @default {"abc": 123}
+     */
+    validJsDoc: any;
+    /**
+     * @minLength ABC
+     * @default {"abc": ABC}
+     */
+    invalidJsDoc: any;
+    /**
+     * @minLength
+     * @default
+     */
+    emptyJsDoc: any;
+}