package.json

@@ -1,6 +1,6 @@
 {
 	"name": "tsd-check",
-	"version": "0.5.0",
+	"version": "0.6.0",
 	"description": "Check TypeScript type definitions",
 	"license": "MIT",
 	"repository": "SamVerschueren/tsd-check",
@@ -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,18 +76,33 @@ 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
 
-### expectType<T>(value)
+### expectType&lt;T&gt;(value)
 
 Check if a value is of a specific type.
 
 ### expectError(function)
 
 Check if the function call has argument type errors.
 
-### expectError<T>(value)
+### expectError&lt;T&gt;(value)
 
 Check if a value is of the provided type `T`.
 

source/lib/compiler.ts

@@ -1,69 +1,46 @@
 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;
@@ -76,22 +53,24 @@ const extractExpectErrorRanges = (sourceFile: SourceFile) => {
  * @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 (diagnostic.code !== DiagnosticCode.ArgumentTypeIsNotAssignableToParameterType) {
+	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;
 		}
 	}
@@ -106,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,13 +1,23 @@
+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 {
 	AwaitIsOnlyAllowedInAsyncFunction = 1308,
-	ArgumentTypeIsNotAssignableToParameterType = 2345
+	PropertyDoesNotExistOnType = 2339,
+	ArgumentTypeIsNotAssignableToParameterType = 2345,
+	CannotAssignToReadOnlyProperty = 2540
 }
 
 export interface Diagnostic {
@@ -18,7 +28,8 @@ export interface Diagnostic {
 	column?: number;
 }
 
-export interface Position {
+export interface Location {
+	fileName: string;
 	start: number;
 	end: number;
 }

source/lib/rules/index.ts

@@ -1,11 +1,13 @@
 import filesProperty from './files-property';
+import typesProperty from './types-property';
 import {Diagnostic, Context} from '../interfaces';
 
 type RuleFunction = (context: Context) => Diagnostic[];
 
 // List of custom rules
 const rules = new Set<RuleFunction>([
-	filesProperty
+	filesProperty,
+	typesProperty
 ]);
 
 /**

source/lib/rules/types-property.ts

@@ -0,0 +1,29 @@
+import * as path from 'path';
+import * as fs from 'fs';
+import {Context, Diagnostic} from '../interfaces';
+import {getJSONPropertyPosition} from '../utils';
+
+/**
+ * Rule which enforces the use of a `types` property over a `typings` property.
+ *
+ * @param context - The context object.
+ * @returns A list of custom diagnostics.
+ */
+export default (context: Context): Diagnostic[] => {
+	const {pkg} = context;
+
+	if (!pkg.types && pkg.typings) {
+		const content = fs.readFileSync(path.join(context.cwd, 'package.json'), 'utf8');
+
+		return [
+			{
+				fileName: 'package.json',
+				message: 'Use property `types` instead of `typings`.',
+				severity: 'error',
+				...getJSONPropertyPosition(content, 'typings')
+			}
+		];
+	}
+
+	return [];
+};

source/test/fixtures/expect-error/values/index.test-d.ts

@@ -2,3 +2,10 @@ import {expectError} from '../../../..';
 
 expectError<string>(1);
 expectError<string>('fo');
+
+const foo: {readonly bar: string} = {
+	bar: 'baz'
+};
+
+expectError(foo.bar = 'quux');
+expectError(foo.quux);

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/package.json

@@ -0,0 +1,6 @@
+{
+	"name": "foo",
+	"tsd-check": {
+		"directory": "test"
+	}
+}

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;

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

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

source/test/fixtures/test-directory/default/package.json

@@ -0,0 +1,4 @@
+{
+	"name": "foo",
+	"types": "index.d.ts"
+}

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

@@ -0,0 +1,4 @@
+import {expectType} from '../../../../..';
+import one from '..';
+
+expectType<number>(one(1, 2));

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

@@ -0,0 +1,4 @@
+import {expectType} from '../../../../..';
+import one from '..';
+
+expectType<string>(one('foo', 'bar'));

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

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

source/test/fixtures/test-in-subdir/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "foo",
 	"main": "src/index.js",
-	"typings": "src/index.d.ts",
+	"types": "src/index.d.ts",
 	"files": [
 		"src/index.js",
 		"src/index.d.ts"

source/test/fixtures/test-non-barrel-main/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "foo",
 	"main": "foo.js",
-	"typings": "foo.d.ts",
+	"types": "foo.d.ts",
 	"files": [
 		"foo.js",
 		"foo.d.ts"

source/test/fixtures/types-property/no-property/package.json

@@ -0,0 +1,3 @@
+{
+	"name": "foo"
+}

source/test/fixtures/types-property/typings/package.json

@@ -0,0 +1,4 @@
+{
+	"name": "foo",
+	"typings": "index.d.ts"
+}

source/test/test.ts

@@ -43,6 +43,20 @@ test('fail if typings file is not part of `files` list', async t => {
 	]);
 });
 
+test('fail if `typings` property is used instead of `types`', async t => {
+	const diagnostics = await m({cwd: path.join(__dirname, 'fixtures/types-property/typings')});
+
+	t.deepEqual(diagnostics, [
+		{
+			fileName: 'package.json',
+			message: 'Use property `types` instead of `typings`.',
+			severity: 'error',
+			column: 1,
+			line: 3
+		}
+	]);
+});
+
 test('fail if tests don\'t pass in strict mode', async t => {
 	const diagnostics = await m({
 		cwd: path.join(__dirname, 'fixtures/failure-strict-null-checks')
@@ -98,6 +112,21 @@ test('support top-level await', async t => {
 	t.true(diagnostics.length === 0);
 });
 
+test('support default test directory', async t => {
+	const diagnostics = await m({cwd: path.join(__dirname, 'fixtures/test-directory/default')});
+
+	t.true(diagnostics.length === 0);
+});
+
+test('support setting a custom test directory', async t => {
+	const diagnostics = await m({cwd: path.join(__dirname, 'fixtures/test-directory/custom')});
+
+	t.true(diagnostics[0].column === 0);
+	t.true(diagnostics[0].line === 4);
+	t.true(diagnostics[0].message === 'Expected an error, but found none.');
+	t.true(diagnostics[0].severity === 'error');
+});
+
 test('expectError for functions', async t => {
 	const diagnostics = await m({cwd: path.join(__dirname, 'fixtures/expect-error/functions')});