Add support for multiple files - fixes #14

Author: SamVerschueren

package.json

@@ -40,9 +40,9 @@
 	],
 	"dependencies": {
 		"eslint-formatter-pretty": "^1.3.0",
+		"globby": "^9.1.0",
 		"meow": "^5.0.0",
 		"path-exists": "^3.0.0",
-		"pkg-conf": "^3.0.0",
 		"read-pkg-up": "^4.0.0",
 		"typescript": "^3.0.1",
 		"update-notifier": "^2.5.0"

readme.md

@@ -76,6 +76,21 @@ expectType<string>(await concat('foo', 'bar'));
 expectError(await concat(true, false));
 ```
 
+### Test directory
+
+When you have spread your tests over multiple files, you can store all those files in a test directory called `test-d`. If you want to use another directory name, you can change it in `package.json`.
+
+```json
+{
+	"name": "my-module",
+	"tsd-check": {
+		"directory": "my-test-dir"
+	}
+}
+```
+
+Now you can put all your test files in the `my-test-dir` directory.
+
 
 ## Assertions
 

source/lib/compiler.ts

@@ -1,103 +1,76 @@
 import * as path from 'path';
-import * as pkgConf from 'pkg-conf';
-import {
-	ScriptTarget,
-	ModuleResolutionKind,
-	flattenDiagnosticMessageText,
-	CompilerOptions,
-	createProgram,
-	JsxEmit,
-	SyntaxKind,
-	SourceFile,
-	Diagnostic as TSDiagnostic
-} from 'typescript';
-import {Diagnostic, DiagnosticCode, Context, Position} from './interfaces';
+import {flattenDiagnosticMessageText, createProgram, SyntaxKind, Diagnostic as TSDiagnostic, Program, SourceFile} from 'typescript';
+import {Diagnostic, DiagnosticCode, Context, Location} from './interfaces';
 
 // List of diagnostic codes that should be ignored
 const ignoredDiagnostics = new Set<number>([
 	DiagnosticCode.AwaitIsOnlyAllowedInAsyncFunction
 ]);
 
-const loadConfig = (cwd: string): CompilerOptions => {
-	const config = pkgConf.sync('tsd-check', {
-		cwd,
-		defaults: {
-			compilerOptions: {
-				strict: true,
-				jsx: JsxEmit.React,
-				target: ScriptTarget.ES2017
-			}
-		}
-	});
-
-	return {
-		...config.compilerOptions,
-		...{
-			moduleResolution: ModuleResolutionKind.NodeJs,
-			skipLibCheck: true
-		}
-	};
-};
+const diagnosticCodesToIgnore = new Set<DiagnosticCode>([
+	DiagnosticCode.ArgumentTypeIsNotAssignableToParameterType,
+	DiagnosticCode.PropertyDoesNotExistOnType,
+	DiagnosticCode.CannotAssignToReadOnlyProperty
+]);
 
 /**
  * Extract all the `expectError` statements and convert it to a range map.
  *
- * @param sourceFile - File to extract the statements from.
+ * @param program - The TypeScript program.
  */
-const extractExpectErrorRanges = (sourceFile: SourceFile) => {
-	const expectedErrors = new Map<Position, Pick<Diagnostic, 'fileName' | 'line' | 'column'>>();
+const extractExpectErrorRanges = (program: Program) => {
+	const expectedErrors = new Map<Location, Pick<Diagnostic, 'fileName' | 'line' | 'column'>>();
 
-	for (const statement of sourceFile.statements) {
-		if (statement.kind !== SyntaxKind.ExpressionStatement || !statement.getText().startsWith('expectError')) {
-			continue;
-		}
+	for (const sourceFile of program.getSourceFiles()) {
+		for (const statement of sourceFile.statements) {
+			if (statement.kind !== SyntaxKind.ExpressionStatement || !statement.getText().startsWith('expectError')) {
+				continue;
+			}
 
-		const position = {
-			start: statement.getStart(),
-			end: statement.getEnd()
-		};
+			const location = {
+				fileName: statement.getSourceFile().fileName,
+				start: statement.getStart(),
+				end: statement.getEnd()
+			};
 
-		const pos = statement.getSourceFile().getLineAndCharacterOfPosition(statement.getStart());
+			const pos = statement.getSourceFile().getLineAndCharacterOfPosition(statement.getStart());
 
-		expectedErrors.set(position, {
-			fileName: statement.getSourceFile().fileName,
-			line: pos.line + 1,
-			column: pos.character
-		});
+			expectedErrors.set(location, {
+				fileName: location.fileName,
+				line: pos.line + 1,
+				column: pos.character
+			});
+		}
 	}
 
 	return expectedErrors;
 };
 
-const diagnosticCodesToIgnore = [
-	DiagnosticCode.ArgumentTypeIsNotAssignableToParameterType,
-	DiagnosticCode.PropertyDoesNotExistOnType,
-	DiagnosticCode.CannotAssignToReadOnlyProperty
-];
-
 /**
  * Check if the provided diagnostic should be ignored.
  *
  * @param diagnostic - The diagnostic to validate.
  * @param expectedErrors - Map of the expected errors.
  * @return Boolean indicating if the diagnostic should be ignored or not.
  */
-const ignoreDiagnostic = (diagnostic: TSDiagnostic, expectedErrors: Map<Position, any>): boolean => {
+const ignoreDiagnostic = (diagnostic: TSDiagnostic, expectedErrors: Map<Location, any>): boolean => {
 	if (ignoredDiagnostics.has(diagnostic.code)) {
 		// Filter out diagnostics which are present in the `ignoredDiagnostics` set
 		return true;
 	}
 
-	if (!diagnosticCodesToIgnore.includes(diagnostic.code)) {
+	if (!diagnosticCodesToIgnore.has(diagnostic.code)) {
 		return false;
 	}
 
-	for (const [range] of expectedErrors) {
+	const diagnosticFileName = (diagnostic.file as SourceFile).fileName;
+
+	for (const [location] of expectedErrors) {
 		const start = diagnostic.start as number;
 
-		if (start > range.start && start < range.end) {
+		if (diagnosticFileName === location.fileName && start > location.start && start < location.end) {
 			// Remove the expected error from the Map so it's not being reported as failure
-			expectedErrors.delete(range);
+			expectedErrors.delete(location);
 			return true;
 		}
 	}
@@ -112,19 +85,17 @@ const ignoreDiagnostic = (diagnostic: TSDiagnostic, expectedErrors: Map<Position
  * @returns List of diagnostics
  */
 export const getDiagnostics = (context: Context): Diagnostic[] => {
-	const compilerOptions = loadConfig(context.cwd);
-
-	const fileName = path.join(context.cwd, context.testFile);
+	const fileNames = context.testFiles.map(fileName => path.join(context.cwd, fileName));
 
 	const result: Diagnostic[] = [];
 
-	const program = createProgram([fileName], compilerOptions);
+	const program = createProgram(fileNames, context.config.compilerOptions);
 
 	const diagnostics = program
 		.getSemanticDiagnostics()
 		.concat(program.getSyntacticDiagnostics());
 
-	const expectedErrors = extractExpectErrorRanges(program.getSourceFile(fileName) as SourceFile);
+	const expectedErrors = extractExpectErrorRanges(program);
 
 	for (const diagnostic of diagnostics) {
 		if (!diagnostic.file || ignoreDiagnostic(diagnostic, expectedErrors)) {

source/lib/config.ts

@@ -0,0 +1,31 @@
+import {JsxEmit, ScriptTarget, ModuleResolutionKind} from 'typescript';
+import {Config} from './interfaces';
+
+/**
+ * Load the configuration settings.
+ *
+ * @param pkg - The package.json object.
+ * @returns The config object.
+ */
+export default (pkg: any): Config => {
+	const config = {
+		directory: 'test-d',
+		compilerOptions: {
+			strict: true,
+			jsx: JsxEmit.React,
+			target: ScriptTarget.ES2017
+		},
+		...pkg['tsd-check']
+	};
+
+	return {
+		...config,
+		compilerOptions: {
+			...config.compilerOptions,
+			...{
+				moduleResolution: ModuleResolutionKind.NodeJs,
+				skipLibCheck: true
+			}
+		}
+	};
+};

source/lib/index.ts

@@ -1,9 +1,11 @@
 import * as path from 'path';
 import * as readPkgUp from 'read-pkg-up';
 import * as pathExists from 'path-exists';
+import globby from 'globby';
 import {getDiagnostics as getTSDiagnostics} from './compiler';
+import loadConfig from './config';
 import getCustomDiagnostics from './rules';
-import {Context} from './interfaces';
+import {Context, Config} from './interfaces';
 
 interface Options {
 	cwd: string;
@@ -21,16 +23,24 @@ const findTypingsFile = async (pkg: any, options: Options) => {
 	return typings;
 };
 
-const findTestFile = async (typingsFile: string, options: Options) => {
+const findTestFiles = async (typingsFile: string, options: Options & {config: Config}) => {
 	const testFile = typingsFile.replace(/\.d\.ts$/, '.test-d.ts');
+	const testDir = options.config.directory;
 
 	const testFileExists = await pathExists(path.join(options.cwd, testFile));
+	const testDirExists = await pathExists(path.join(options.cwd, testDir));
 
-	if (!testFileExists) {
+	if (!testFileExists && !testDirExists) {
 		throw new Error(`The test file \`${testFile}\` does not exist. Create one and try again.`);
 	}
 
-	return testFile;
+	let testFiles = [testFile];
+
+	if (!testFileExists) {
+		testFiles = await globby(`${testDir}/**/*.ts`, {cwd: options.cwd});
+	}
+
+	return testFiles;
 };
 
 /**
@@ -45,16 +55,22 @@ export default async (options: Options = {cwd: process.cwd()}) => {
 		throw new Error('No `package.json` file found. Make sure you are running the command in a Node.js project.');
 	}
 
+	const config = loadConfig(pkg);
+
 	// Look for a typings file, otherwise use `index.d.ts` in the root directory. If the file is not found, throw an error.
 	const typingsFile = await findTypingsFile(pkg, options);
 
-	const testFile = await findTestFile(typingsFile, options);
+	const testFiles = await findTestFiles(typingsFile, {
+		...options,
+		config
+	});
 
 	const context: Context = {
 		cwd: options.cwd,
 		pkg,
 		typingsFile,
-		testFile
+		testFiles,
+		config
 	};
 
 	return [

source/lib/interfaces.ts

@@ -1,8 +1,16 @@
+import {CompilerOptions} from 'typescript';
+
+export interface Config {
+	directory: string;
+	compilerOptions: CompilerOptions;
+}
+
 export interface Context {
 	cwd: string;
 	pkg: any;
 	typingsFile: string;
-	testFile: string;
+	testFiles: string[];
+	config: Config;
 }
 
 export enum DiagnosticCode {
@@ -20,7 +28,8 @@ export interface Diagnostic {
 	column?: number;
 }
 
-export interface Position {
+export interface Location {
+	fileName: string;
 	start: number;
 	end: number;
 }

source/test/fixtures/test-directory/custom/index.d.ts

@@ -0,0 +1,6 @@
+declare const one: {
+	(foo: string, bar: string): string;
+	(foo: number, bar: number): number;
+};
+
+export default one;

source/test/fixtures/test-directory/custom/index.js

@@ -0,0 +1,3 @@
+module.exports.default = (foo, bar) => {
+	return foo + bar;
+};

source/test/fixtures/test-directory/custom/test/unknown.ts

@@ -0,0 +1,4 @@
+import {expectError} from '../../../../..';
+import one from '..';
+
+expectError(one(1, 2));

source/test/fixtures/test-directory/default/index.d.ts

@@ -0,0 +1,6 @@
+declare const one: {
+	(foo: string, bar: string): string;
+	(foo: number, bar: number): number;
+};
+
+export default one;