mirror of
https://github.com/denoland/deno.git
synced 2024-12-22 23:34:47 -05:00
425 lines
11 KiB
TypeScript
425 lines
11 KiB
TypeScript
// Copyright 2018-2020 the Deno authors. All rights reserved. MIT license.
|
|
import { gray, green, italic, red, yellow } from "./colors.ts";
|
|
import { exit } from "./ops/os.ts";
|
|
import { Console, stringifyArgs } from "./web/console.ts";
|
|
import { stdout } from "./files.ts";
|
|
import { TextEncoder } from "./web/text_encoding.ts";
|
|
import { metrics } from "./ops/runtime.ts";
|
|
import { resources } from "./ops/resources.ts";
|
|
import { assert } from "./util.ts";
|
|
|
|
const RED_FAILED = red("FAILED");
|
|
const GREEN_OK = green("ok");
|
|
const YELLOW_IGNORED = yellow("ignored");
|
|
const disabledConsole = new Console((_x: string, _isErr?: boolean): void => {});
|
|
|
|
function formatDuration(time = 0): string {
|
|
const timeStr = `(${time}ms)`;
|
|
return gray(italic(timeStr));
|
|
}
|
|
|
|
// Wrap `TestFunction` in additional assertion that makes sure
|
|
// the test case does not leak async "ops" - ie. number of async
|
|
// completed ops after the test is the same as number of dispatched
|
|
// ops. Note that "unref" ops are ignored since in nature that are
|
|
// optional.
|
|
function assertOps(fn: TestFunction): TestFunction {
|
|
return async function asyncOpSanitizer(): Promise<void> {
|
|
const pre = metrics();
|
|
await fn();
|
|
const post = metrics();
|
|
// We're checking diff because one might spawn HTTP server in the background
|
|
// that will be a pending async op before test starts.
|
|
const dispatchedDiff = post.opsDispatchedAsync - pre.opsDispatchedAsync;
|
|
const completedDiff = post.opsCompletedAsync - pre.opsCompletedAsync;
|
|
assert(
|
|
dispatchedDiff === completedDiff,
|
|
`Test case is leaking async ops.
|
|
Before:
|
|
- dispatched: ${pre.opsDispatchedAsync}
|
|
- completed: ${pre.opsCompletedAsync}
|
|
After:
|
|
- dispatched: ${post.opsDispatchedAsync}
|
|
- completed: ${post.opsCompletedAsync}`
|
|
);
|
|
};
|
|
}
|
|
|
|
// Wrap `TestFunction` in additional assertion that makes sure
|
|
// the test case does not "leak" resources - ie. resource table after
|
|
// the test has exactly the same contents as before the test.
|
|
function assertResources(fn: TestFunction): TestFunction {
|
|
return async function resourceSanitizer(): Promise<void> {
|
|
const pre = resources();
|
|
await fn();
|
|
const post = resources();
|
|
|
|
const preStr = JSON.stringify(pre, null, 2);
|
|
const postStr = JSON.stringify(post, null, 2);
|
|
const msg = `Test case is leaking resources.
|
|
Before: ${preStr}
|
|
After: ${postStr}`;
|
|
assert(preStr === postStr, msg);
|
|
};
|
|
}
|
|
|
|
export type TestFunction = () => void | Promise<void>;
|
|
|
|
export interface TestDefinition {
|
|
fn: TestFunction;
|
|
name: string;
|
|
ignore?: boolean;
|
|
disableOpSanitizer?: boolean;
|
|
disableResourceSanitizer?: boolean;
|
|
}
|
|
|
|
const TEST_REGISTRY: TestDefinition[] = [];
|
|
|
|
export function test(t: TestDefinition): void;
|
|
export function test(fn: TestFunction): void;
|
|
export function test(name: string, fn: TestFunction): void;
|
|
// Main test function provided by Deno, as you can see it merely
|
|
// creates a new object with "name" and "fn" fields.
|
|
export function test(
|
|
t: string | TestDefinition | TestFunction,
|
|
fn?: TestFunction
|
|
): void {
|
|
let testDef: TestDefinition;
|
|
|
|
if (typeof t === "string") {
|
|
if (!fn || typeof fn != "function") {
|
|
throw new TypeError("Missing test function");
|
|
}
|
|
if (!t) {
|
|
throw new TypeError("The test name can't be empty");
|
|
}
|
|
testDef = { fn: fn as TestFunction, name: t, ignore: false };
|
|
} else if (typeof t === "function") {
|
|
if (!t.name) {
|
|
throw new TypeError("The test function can't be anonymous");
|
|
}
|
|
testDef = { fn: t, name: t.name, ignore: false };
|
|
} else {
|
|
if (!t.fn) {
|
|
throw new TypeError("Missing test function");
|
|
}
|
|
if (!t.name) {
|
|
throw new TypeError("The test name can't be empty");
|
|
}
|
|
testDef = { ...t, ignore: Boolean(t.ignore) };
|
|
}
|
|
|
|
if (testDef.disableOpSanitizer !== true) {
|
|
testDef.fn = assertOps(testDef.fn);
|
|
}
|
|
|
|
if (testDef.disableResourceSanitizer !== true) {
|
|
testDef.fn = assertResources(testDef.fn);
|
|
}
|
|
|
|
TEST_REGISTRY.push(testDef);
|
|
}
|
|
|
|
interface TestStats {
|
|
filtered: number;
|
|
ignored: number;
|
|
measured: number;
|
|
passed: number;
|
|
failed: number;
|
|
}
|
|
|
|
export interface RunTestsOptions {
|
|
exitOnFail?: boolean;
|
|
failFast?: boolean;
|
|
only?: string | RegExp;
|
|
skip?: string | RegExp;
|
|
disableLog?: boolean;
|
|
reporter?: TestReporter;
|
|
}
|
|
|
|
enum TestStatus {
|
|
Passed = "passed",
|
|
Failed = "failed",
|
|
Ignored = "ignored"
|
|
}
|
|
|
|
interface TestResult {
|
|
name: string;
|
|
status: TestStatus;
|
|
duration: number;
|
|
error?: Error;
|
|
}
|
|
|
|
export enum TestEvent {
|
|
Start = "start",
|
|
TestStart = "testStart",
|
|
TestEnd = "testEnd",
|
|
End = "end"
|
|
}
|
|
|
|
interface TestEventStart {
|
|
kind: TestEvent.Start;
|
|
tests: number;
|
|
}
|
|
|
|
interface TestEventTestStart {
|
|
kind: TestEvent.TestStart;
|
|
name: string;
|
|
}
|
|
|
|
interface TestEventTestEnd {
|
|
kind: TestEvent.TestEnd;
|
|
result: TestResult;
|
|
}
|
|
|
|
interface TestEventEnd {
|
|
kind: TestEvent.End;
|
|
stats: TestStats;
|
|
duration: number;
|
|
results: TestResult[];
|
|
}
|
|
|
|
// TODO: already implements AsyncGenerator<RunTestsMessage>, but add as "implements to class"
|
|
// TODO: implements PromiseLike<TestsResult>
|
|
class TestApi {
|
|
readonly testsToRun: TestDefinition[];
|
|
readonly stats: TestStats = {
|
|
filtered: 0,
|
|
ignored: 0,
|
|
measured: 0,
|
|
passed: 0,
|
|
failed: 0
|
|
};
|
|
|
|
constructor(
|
|
public tests: TestDefinition[],
|
|
public filterFn: (def: TestDefinition) => boolean,
|
|
public failFast: boolean
|
|
) {
|
|
this.testsToRun = tests.filter(filterFn);
|
|
this.stats.filtered = tests.length - this.testsToRun.length;
|
|
}
|
|
|
|
async *[Symbol.asyncIterator](): AsyncIterator<
|
|
TestEventStart | TestEventTestStart | TestEventTestEnd | TestEventEnd
|
|
> {
|
|
yield {
|
|
kind: TestEvent.Start,
|
|
tests: this.testsToRun.length
|
|
};
|
|
|
|
const results: TestResult[] = [];
|
|
const suiteStart = +new Date();
|
|
for (const { name, fn, ignore } of this.testsToRun) {
|
|
const result: Partial<TestResult> = { name, duration: 0 };
|
|
yield { kind: TestEvent.TestStart, name };
|
|
if (ignore) {
|
|
result.status = TestStatus.Ignored;
|
|
this.stats.ignored++;
|
|
} else {
|
|
const start = +new Date();
|
|
try {
|
|
await fn();
|
|
result.status = TestStatus.Passed;
|
|
this.stats.passed++;
|
|
} catch (err) {
|
|
result.status = TestStatus.Failed;
|
|
result.error = err;
|
|
this.stats.failed++;
|
|
} finally {
|
|
result.duration = +new Date() - start;
|
|
}
|
|
}
|
|
yield { kind: TestEvent.TestEnd, result: result as TestResult };
|
|
results.push(result as TestResult);
|
|
if (this.failFast && result.error != null) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
const duration = +new Date() - suiteStart;
|
|
|
|
yield {
|
|
kind: TestEvent.End,
|
|
stats: this.stats,
|
|
results,
|
|
duration
|
|
};
|
|
}
|
|
}
|
|
|
|
function createFilterFn(
|
|
only: undefined | string | RegExp,
|
|
skip: undefined | string | RegExp
|
|
): (def: TestDefinition) => boolean {
|
|
return (def: TestDefinition): boolean => {
|
|
let passes = true;
|
|
|
|
if (only) {
|
|
if (only instanceof RegExp) {
|
|
passes = passes && only.test(def.name);
|
|
} else {
|
|
passes = passes && def.name.includes(only);
|
|
}
|
|
}
|
|
|
|
if (skip) {
|
|
if (skip instanceof RegExp) {
|
|
passes = passes && !skip.test(def.name);
|
|
} else {
|
|
passes = passes && !def.name.includes(skip);
|
|
}
|
|
}
|
|
|
|
return passes;
|
|
};
|
|
}
|
|
|
|
interface TestReporter {
|
|
start(msg: TestEventStart): Promise<void>;
|
|
testStart(msg: TestEventTestStart): Promise<void>;
|
|
testEnd(msg: TestEventTestEnd): Promise<void>;
|
|
end(msg: TestEventEnd): Promise<void>;
|
|
}
|
|
|
|
export class ConsoleTestReporter implements TestReporter {
|
|
private encoder: TextEncoder;
|
|
|
|
constructor() {
|
|
this.encoder = new TextEncoder();
|
|
}
|
|
|
|
private log(msg: string, noNewLine = false): Promise<void> {
|
|
if (!noNewLine) {
|
|
msg += "\n";
|
|
}
|
|
|
|
// Using `stdout` here because it doesn't force new lines
|
|
// compared to `console.log`; `core.print` on the other hand
|
|
// is line-buffered and doesn't output message without newline
|
|
stdout.writeSync(this.encoder.encode(msg));
|
|
return Promise.resolve();
|
|
}
|
|
|
|
start(event: TestEventStart): Promise<void> {
|
|
this.log(`running ${event.tests} tests`);
|
|
return Promise.resolve();
|
|
}
|
|
|
|
testStart(event: TestEventTestStart): Promise<void> {
|
|
const { name } = event;
|
|
|
|
this.log(`test ${name} ... `, true);
|
|
return Promise.resolve();
|
|
}
|
|
|
|
testEnd(event: TestEventTestEnd): Promise<void> {
|
|
const { result } = event;
|
|
|
|
switch (result.status) {
|
|
case TestStatus.Passed:
|
|
this.log(`${GREEN_OK} ${formatDuration(result.duration)}`);
|
|
break;
|
|
case TestStatus.Failed:
|
|
this.log(`${RED_FAILED} ${formatDuration(result.duration)}`);
|
|
break;
|
|
case TestStatus.Ignored:
|
|
this.log(`${YELLOW_IGNORED} ${formatDuration(result.duration)}`);
|
|
break;
|
|
}
|
|
|
|
return Promise.resolve();
|
|
}
|
|
|
|
end(event: TestEventEnd): Promise<void> {
|
|
const { stats, duration, results } = event;
|
|
// Attempting to match the output of Rust's test runner.
|
|
const failedTests = results.filter(r => r.error);
|
|
|
|
if (failedTests.length > 0) {
|
|
this.log(`\nfailures:\n`);
|
|
|
|
for (const result of failedTests) {
|
|
this.log(`${result.name}`);
|
|
this.log(`${stringifyArgs([result.error!])}`);
|
|
this.log("");
|
|
}
|
|
|
|
this.log(`failures:\n`);
|
|
|
|
for (const result of failedTests) {
|
|
this.log(`\t${result.name}`);
|
|
}
|
|
}
|
|
|
|
this.log(
|
|
`\ntest result: ${stats.failed ? RED_FAILED : GREEN_OK}. ` +
|
|
`${stats.passed} passed; ${stats.failed} failed; ` +
|
|
`${stats.ignored} ignored; ${stats.measured} measured; ` +
|
|
`${stats.filtered} filtered out ` +
|
|
`${formatDuration(duration)}\n`
|
|
);
|
|
|
|
return Promise.resolve();
|
|
}
|
|
}
|
|
|
|
export async function runTests({
|
|
exitOnFail = true,
|
|
failFast = false,
|
|
only = undefined,
|
|
skip = undefined,
|
|
disableLog = false,
|
|
reporter = undefined
|
|
}: RunTestsOptions = {}): Promise<{
|
|
results: TestResult[];
|
|
stats: TestStats;
|
|
duration: number;
|
|
}> {
|
|
const filterFn = createFilterFn(only, skip);
|
|
const testApi = new TestApi(TEST_REGISTRY, filterFn, failFast);
|
|
|
|
if (!reporter) {
|
|
reporter = new ConsoleTestReporter();
|
|
}
|
|
|
|
// @ts-ignore
|
|
const originalConsole = globalThis.console;
|
|
|
|
if (disableLog) {
|
|
// @ts-ignore
|
|
globalThis.console = disabledConsole;
|
|
}
|
|
|
|
let endMsg: TestEventEnd;
|
|
|
|
for await (const testMsg of testApi) {
|
|
switch (testMsg.kind) {
|
|
case TestEvent.Start:
|
|
await reporter.start(testMsg);
|
|
continue;
|
|
case TestEvent.TestStart:
|
|
await reporter.testStart(testMsg);
|
|
continue;
|
|
case TestEvent.TestEnd:
|
|
await reporter.testEnd(testMsg);
|
|
continue;
|
|
case TestEvent.End:
|
|
endMsg = testMsg;
|
|
delete endMsg!.kind;
|
|
await reporter.end(testMsg);
|
|
continue;
|
|
}
|
|
}
|
|
|
|
if (disableLog) {
|
|
// @ts-ignore
|
|
globalThis.console = originalConsole;
|
|
}
|
|
|
|
if (endMsg!.stats.failed > 0 && exitOnFail) {
|
|
exit(1);
|
|
}
|
|
|
|
return endMsg!;
|
|
}
|