add configuration test

src/models/Import.ts

@@ -1,54 +1,52 @@
-import { existsSync } from "fs";
-import { parse, resolve } from "path";
-import { L } from "../utils/logger";
+import { existsSync } from "fs"
+import { parse, resolve } from "path"
+import { L } from "../utils/logger"
 
 export class Import {
 	constructor(
 		/** the path of the file that contains the import declaration. */
 		private source: string,
 		/** the relative path to the target file of the import. */
-		private from: string,
+		public from: string,
 		/** the named exports (`import { named } from "./from"`). */
 		private named: Array<string>,
 		/** the default exports (`import default from "./from"`). */
 		private default_: string | null
 	) {}
 
 	public resolve() {
-		L.d(`<resolve>`, this.toString());
+		L.d(`<resolve>`, this.toString())
 
-		const { dir } = parse(this.source);
-		const pathToFile = resolve(dir, this.from);
-		const tsPath = `${pathToFile}.ts`;
-		const tsxPath = `${pathToFile}.tsx`;
+		const { dir } = parse(this.source)
+		const pathToFile = resolve(dir, this.from)
+		const tsPath = `${pathToFile}.ts`
+		const tsxPath = `${pathToFile}.tsx`
 
-		L.d(`<resolve>`, `trying if exists: ${tsPath}`);
+		L.d(`<resolve>`, `trying if exists: ${tsPath}`)
 
 		if (existsSync(tsPath)) {
-			L.d(`<resolve>`, `"${tsPath}" path exists`);
-			return tsPath;
+			L.d(`<resolve>`, `"${tsPath}" path exists`)
+			return tsPath
 		}
 
 		if (existsSync(tsxPath)) {
-			L.d(`<resolve>`, `"${tsPath}" path exists`);
-			return tsxPath;
+			L.d(`<resolve>`, `"${tsPath}" path exists`)
+			return tsxPath
 		}
 
 		// TODO node_modules
 		// TODO @types
 
-		throw new Error(
-			`Could not resolve import ${this.toString()} from "${this.from}".`
-		);
+		throw new UnresolvedImportError(this)
 	}
 
 	/**
 	 * Checks if the {@link Import} contains a specific identifier.
-	 * 
+	 *
 	 * For example: `import Jon, { Doe } from "./helloworld"`
-	 * 
+	 *
 	 * Would result in:
-	 * 
+	 *
 	 * ```ts
 	 * containsIdentifier("Jon") // true
 	 * containsIdentifier("Doe") // true
@@ -60,8 +58,22 @@ export class Import {
 	}
 
 	public toString() {
-		return `import ${this.default_ ? `${this.default_} ` : ""} ${
-			this.named.length > 0 ? `{ ${this.named.join(", ")} }` : ""
-		} from "${this.from}"`;
+		return `import ${this.default_ ? `${this.default_} ` : ""}${this.named.length > 0 ? `{ ${this.named.join(", ")} }` : ""} from "${this.from}"`
+	}
+}
+
+export class UnresolvedImportError extends Error {
+	constructor(imp: Import) {
+		super()
+		this.message = this.createMessage(imp)
+	}
+
+	private createMessage(imp: Import): string {
+		return [
+			`Could not resolve ${imp.toString()} from "${imp.from}".`,
+			"",
+			"It is possible to suppress this error when the 'breakOnUnresolvedImport' options is set to 'false'.",
+			"The type will resolve to unknown then.",
+		].join("\n")
 	}
 }

src/models/index.ts

@@ -0,0 +1,5 @@
+export { ArrayType } from "./ArrayType"
+export { ArrayTypeDeclaration } from "./ArrayTypeDeclaration"
+export { BooleanType } from "./BooleanType"
+export { EnumType } from "./EnumType"
+export { EnumTypeDeclaration } from "./EnumTypeDeclaration"

src/parser.ts

@@ -324,6 +324,11 @@ export class Parser {
 			return declaration
 		}
 
+		if (resolvedType instanceof TypeReference && this.config.doNotResolve.includes(resolvedType.identifier)) {
+			declaration.type = resolvedType
+			return declaration
+		}
+
 		if (resolvedType instanceof UnionType) {
 			// TODO remove the typescript node from the TypeLiteral class to prevent this
 			declaration.type = resolvedType
@@ -336,7 +341,8 @@ export class Parser {
 			return declaration
 		}
 
-		if (resolvedType instanceof TypeReference && this.config.doNotResolve.includes(resolvedType.identifier)) {
+		if (resolvedType instanceof UnknownType) {
+			// TODO remove the typescript node from the TypeLiteral class to prevent this
 			declaration.type = resolvedType
 			return declaration
 		}

tests/configuration.test.ts

@@ -0,0 +1,21 @@
+import test from "ava"
+import { resolve } from "path"
+import { UnresolvedImportError } from "../src/models/Import"
+import { UnknownType } from "../src/models/UnknownType"
+import { Parser } from "../src/parser"
+
+test("breakOnUnresolvedImports: true", (t) => {
+	const parser = new Parser(resolve(__dirname, "fixtures", "configurationTestTypes.ts"), { breakOnUnresolvedImports: true })
+	t.throws(
+		() => {
+			parser.resolve("UnresolvedImport")
+		},
+		{ instanceOf: UnresolvedImportError }
+	)
+})
+
+test("breakOnUnresolvedImports: false, should resolve to unknown", (t) => {
+	const parser = new Parser(resolve(__dirname, "fixtures", "configurationTestTypes.ts"), { breakOnUnresolvedImports: false })
+	const declaration = parser.resolve("UnresolvedImport")
+	t.assert(declaration.type instanceof UnknownType)
+})

tests/fixtures/configurationTestTypes.ts

@@ -0,0 +1,3 @@
+import { UnResolved } from "does-not-exist"
+
+type UnresolvedImport = UnResolved

tests/stringTypeDeclaration.test.ts

@@ -25,3 +25,11 @@ test("should parse the ExportedBasicString StringTypeDeclaration", (t) => {
 	t.assert(declaration instanceof StringTypeDeclaration)
 	t.assert(declaration?.type instanceof StringType)
 })
+
+// toString
+
+test("toString of BasicString", (t) => {
+	const parser = new Parser(resolve(__dirname, "fixtures", "stringType.ts"))
+	const declaration = parser.getDeclaration("BasicString")
+	t.is(declaration?.toString(), "type BasicString = string")
+})