Add expectError assertion - fixes #2

Author: SamVerschueren

readme.md

@@ -66,12 +66,14 @@ If we don't change the test file and we run the `tsd-check` command again, the t
 If your method returns a `Promise`, you can use top-level `await` to resolve the value instead of wrapping it in an `async` [IIFE](https://developer.mozilla.org/en-US/docs/Glossary/IIFE).
 
 ```ts
-import {expectType} from 'tsd-check';
+import {expectType, expectError} from 'tsd-check';
 import concat from '.';
 
 expectType<Promise<string>>(concat('foo', 'bar'));
 
 expectType<string>(await concat('foo', 'bar'));
+
+expectError(await concat(true, false));
 ```
 
 
@@ -81,6 +83,14 @@ expectType<string>(await concat('foo', 'bar'));
 
 Check if a value is of a specific type.
 
+### expectError(function)
+
+Check if the function call has argument type errors.
+
+### expectError<T>(value)
+
+Check if a value is of the provided type `T`.
+
 
 ## License
 

source/lib/assert.ts

@@ -5,5 +5,15 @@
  */
 // @ts-ignore
 export const expectType = <T>(value: T) => {		// tslint:disable-line:no-unused
-	// Do nothing, the TypeScript compiler handles this for use
+	// Do nothing, the TypeScript compiler handles this for us
+};
+
+/**
+ * Assert the value to throw an argument error.
+ *
+ * @param value - Value that should be checked.
+ */
+// @ts-ignore
+export const expectError = <T = any>(value: T) => {		// tslint:disable-line:no-unused
+	// Do nothing, the TypeScript compiler handles this for us
 };

source/lib/compiler.ts

@@ -6,13 +6,16 @@ import {
 	flattenDiagnosticMessageText,
 	CompilerOptions,
 	createProgram,
-	JsxEmit
+	JsxEmit,
+	SyntaxKind,
+	SourceFile,
+	Diagnostic as TSDiagnostic
 } from 'typescript';
-import {Diagnostic, Context} from './interfaces';
+import {Diagnostic, DiagnosticCode, Context, Position} from './interfaces';
 
 // List of diagnostic codes that should be ignored
 const ignoredDiagnostics = new Set<number>([
-	1308 // Support top-level `await`
+	DiagnosticCode.AwaitIsOnlyAllowedInAsyncFunction
 ]);
 
 const loadConfig = (cwd: string): CompilerOptions => {
@@ -36,6 +39,66 @@ const loadConfig = (cwd: string): CompilerOptions => {
 	};
 };
 
+/**
+ * Extract all the `expectError` statements and convert it to a range map.
+ *
+ * @param sourceFile - File to extract the statements from.
+ */
+const extractExpectErrorRanges = (sourceFile: SourceFile) => {
+	const expectedErrors = new Map<Position, Pick<Diagnostic, 'fileName' | 'line' | 'column'>>();
+
+	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 pos = statement.getSourceFile().getLineAndCharacterOfPosition(statement.getStart());
+
+		expectedErrors.set(position, {
+			fileName: statement.getSourceFile().fileName,
+			line: pos.line + 1,
+			column: pos.character
+		});
+	}
+
+	return expectedErrors;
+};
+
+/**
+ * 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 => {
+	if (ignoredDiagnostics.has(diagnostic.code)) {
+		// Filter out diagnostics which are present in the `ignoredDiagnostics` set
+		return true;
+	}
+
+	if (diagnostic.code !== DiagnosticCode.ArgumentTypeIsNotAssignableToParameterType) {
+		return false;
+	}
+
+	for (const [range] of expectedErrors) {
+		const start = diagnostic.start as number;
+
+		if (start > range.start && start < range.end) {
+			// Remove the expected error from the Map so it's not being reported as failure
+			expectedErrors.delete(range);
+			return true;
+		}
+	}
+
+	return false;
+};
+
 /**
  * Get a list of TypeScript diagnostics within the current context.
  *
@@ -55,14 +118,14 @@ export const getDiagnostics = (context: Context): Diagnostic[] => {
 		.getSemanticDiagnostics()
 		.concat(program.getSyntacticDiagnostics());
 
+	const expectedErrors = extractExpectErrorRanges(program.getSourceFile(fileName) as SourceFile);
+
 	for (const diagnostic of diagnostics) {
-		if (!diagnostic.file || ignoredDiagnostics.has(diagnostic.code)) {
+		if (!diagnostic.file || ignoreDiagnostic(diagnostic, expectedErrors)) {
 			continue;
 		}
 
-		const position = diagnostic.file.getLineAndCharacterOfPosition(
-			diagnostic.start as number
-		);
+		const position = diagnostic.file.getLineAndCharacterOfPosition(diagnostic.start as number);
 
 		result.push({
 			fileName: diagnostic.file.fileName,
@@ -73,5 +136,13 @@ export const getDiagnostics = (context: Context): Diagnostic[] => {
 		});
 	}
 
+	for (const [, diagnostic] of expectedErrors) {
+		result.push({
+			...diagnostic,
+			message: 'Expected an error, but found none.',
+			severity: 'error'
+		});
+	}
+
 	return result;
 };

source/lib/interfaces.ts

@@ -5,10 +5,20 @@ export interface Context {
 	testFile: string;
 }
 
+export enum DiagnosticCode {
+	AwaitIsOnlyAllowedInAsyncFunction = 1308,
+	ArgumentTypeIsNotAssignableToParameterType = 2345
+}
+
 export interface Diagnostic {
 	fileName: string;
 	message: string;
 	severity: 'error' | 'warning';
 	line?: number;
 	column?: number;
 }
+
+export interface Position {
+	start: number;
+	end: number;
+}

source/test/fixtures/expect-error/functions/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/expect-error/functions/index.js

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

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

@@ -0,0 +1,5 @@
+import {expectError} from '../../../..';
+import one from '.';
+
+expectError(one(true, true));
+expectError(one('foo', 'bar'));

source/test/fixtures/expect-error/functions/package.json

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

source/test/fixtures/expect-error/syntax/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/expect-error/syntax/index.js

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