@travetto/test 3.0.0-rc.4 → 3.0.0-rc.7

package/bin/cli-test.ts

@@ -1,121 +0,0 @@
-import * as os from 'os';
-import { readFileSync } from 'fs';
-
-import { FsUtil, PathUtil, ScanFs } from '@travetto/boot';
-import { CliCommand, OptionConfig } from '@travetto/cli/src/command';
-import { EnvInit } from '@travetto/base/bin/init';
-
-import type { RunState } from '../src/execute/types';
-
-const modes = ['single', 'standard'] as const;
-
-type Options = {
-  format: OptionConfig<string>;
-  concurrency: OptionConfig<number>;
-  isolated: OptionConfig<boolean>;
-  mode: OptionConfig<'single' | 'standard'>;
-};
-
-/**
- * Launch test framework and execute tests
- */
-export class TestCommand extends CliCommand<Options> {
-  name = 'test';
-  _types: string[];
-
-  getTypes(): string[] {
-    if (!this._types) {
-      this._types = ScanFs.scanDirSync({},
-        PathUtil.resolveUnix(__dirname, '..', 'src/consumer/types/')
-      )
-        .filter(x => x.stats?.isFile())
-        .map(x => readFileSync(x.file, 'utf8').match(/@Consumable[(]'([^']+)/)?.[1])
-        .filter((x?: string): x is string => !!x);
-    }
-    return this._types;
-  }
-
-  getOptions(): Options {
-    return {
-      format: this.choiceOption({ desc: 'Output format for test results', def: 'tap', choices: this.getTypes() }),
-      concurrency: this.intOption({ desc: 'Number of tests to run concurrently', lower: 1, upper: 32, def: Math.min(4, os.cpus().length - 1) }),
-      isolated: this.boolOption({ desc: 'Isolated mode' }),
-      mode: this.choiceOption({ desc: 'Test run mode', def: 'standard', choices: [...modes] })
-    };
-  }
-
-  envInit(): void {
-    EnvInit.init({
-      debug: '0',
-      set: { TRV_LOG_TIME: '0' },
-      append: {
-        TRV_RESOURCES: 'test/resources',
-        TRV_PROFILES: 'test',
-        TRV_SRC_LOCAL: '^test',
-        TRV_SRC_COMMON: '^test-support'
-      }
-    });
-  }
-
-  getArgs(): string {
-    return '[regexes...]';
-  }
-
-  async isFile(file: string, errorIfNot?: string): Promise<true | undefined> {
-    try {
-      const stat = await FsUtil.exists(file);
-      const res = stat?.isFile();
-      if (res) {
-        return true;
-      }
-    } catch { }
-
-    if (errorIfNot) {
-      await this.showHelp(errorIfNot);
-    }
-  }
-
-  async onSingle(state: Partial<RunState>, file: string): Promise<void> {
-    await this.isFile(file, 'You must specify a proper test file to run in single mode');
-    state.mode = 'single';
-  }
-
-  async onStandard(state: Partial<RunState>, first: string): Promise<void> {
-    const isFile = await this.isFile(first);
-
-    if (!first) {
-      state.args = state.isolated ? ['test-isolated/.*'] : ['test/.*'];
-      state.concurrency = (state.isolated ? 1 : undefined) ?? state.concurrency;
-    } else if (isFile) { // If is a single file
-      if (first.startsWith('test-')) {
-        state.isolated = true;
-      }
-      if (/test(\-[^-]+)?\//.test(first)) {
-        await this.onSingle(state, first);
-      } else {
-        await this.showHelp('Only files in the test/ and test-*/ folders are permitted to be run');
-      }
-    }
-  }
-
-  async action(regexes: string[]): Promise<void> {
-    const { runTests } = await import('./lib/run');
-
-    const [first] = regexes;
-
-    const state: RunState = {
-      args: regexes,
-      mode: this.cmd.mode,
-      concurrency: +this.cmd.concurrency,
-      isolated: this.cmd.isolated,
-      format: this.cmd.format
-    };
-
-    switch (state.mode) {
-      case 'single': await this.onSingle(state, first); break;
-      case 'standard': await this.onStandard(state, first); break;
-    }
-
-    await runTests(state);
-  }
-}

package/bin/test-child.ts

@@ -1,38 +0,0 @@
-import { createWriteStream } from 'fs';
-
-import { AppCache } from '@travetto/boot';
-import { EnvInit } from '@travetto/base/bin/init';
-
-export async function customLogs(): Promise<void> {
-  const { ConsoleManager } = await import('@travetto/base');
-
-  const c = new console.Console({
-    stdout: createWriteStream(AppCache.toEntryName(`test-worker.${process.pid}.log`), { flags: 'a' }),
-    inspectOptions: { depth: 4 },
-  });
-
-  ConsoleManager.set({
-    onLog: (level, ctx, args: unknown[]) => c[level](process.pid, ctx, ...args)
-  });
-}
-
-export async function main(): Promise<void> {
-  EnvInit.init({
-    debug: '0',
-    set: { TRV_LOG_TIME: '0' },
-    append: {
-      TRV_RESOURCES: 'test/resources',
-      TRV_PROFILES: 'test',
-      TRV_SRC_LOCAL: '^test',
-      TRV_SRC_COMMON: '^test-support'
-    }
-  });
-
-  await customLogs();
-
-  const { PhaseManager } = await import('@travetto/base');
-  await PhaseManager.run('init', '@trv:base/load');
-
-  const { TestChildWorker } = await import('../src/worker/child');
-  return new TestChildWorker().activate();
-}

package/bin/test-direct.ts

@@ -1,23 +0,0 @@
-import { EnvInit } from '@travetto/base/bin/init';
-import { runTests } from './lib/run';
-
-// Direct entry point
-export function main(...args: string[]): Promise<void> {
-  EnvInit.init({
-    debug: '0',
-    set: { TRV_LOG_TIME: '0' },
-    append: {
-      TRV_RESOURCES: 'test/resources',
-      TRV_PROFILES: 'test',
-      TRV_SRC_LOCAL: '^test',
-      TRV_SRC_COMMON: '^test-support'
-    }
-  });
-
-  return runTests({
-    args,
-    format: process.env.TRV_TEST_FORMAT ?? 'tap',
-    mode: 'single',
-    concurrency: 1
-  });
-}

package/bin/test-watch.ts

@@ -1,25 +0,0 @@
-import { EnvInit } from '@travetto/base/bin/init';
-
-export async function main(format: string = 'tap'): Promise<void> {
-  EnvInit.init({
-    debug: '0',
-    set: { TRV_LOG_TIME: '0' },
-    dynamic: true,
-    append: {
-      TRV_RESOURCES: 'test/resources',
-      TRV_PROFILES: 'test',
-      TRV_SRC_LOCAL: 'test',
-      TRV_SRC_COMMON: '^test-support'
-    }
-  });
-
-  // Compile everything inline, don't delegate
-  const { PhaseManager } = await import('@travetto/base');
-  await PhaseManager.run('init', '@trv:base/load');
-
-  // Trigger startup of transpiler
-  (await import('@travetto/compiler')).Compiler.getProgram();
-
-  const { TestWatcher } = await import('../src/execute/watcher');
-  await TestWatcher.watch(format);
-}

package/src/consumer/types/tap-summary.ts

@@ -1,78 +0,0 @@
-import { Writable } from 'stream';
-
-import { ColorUtil } from '@travetto/boot';
-
-import { SuitesSummary, TestConsumer } from '../types';
-import { Consumable } from '../registry';
-
-import { TestResultsEnhancer, COLOR_ENHANCER, DUMMY_ENHANCER } from '../enhancer';
-import { TestEvent } from '../../model/event';
-
-/**
-  * TAP Format consumer
- */
-@Consumable('summary')
-export class SummaryEmitter implements TestConsumer {
-
-  #stream: Writable;
-  #enhancer: TestResultsEnhancer;
-
-  constructor(
-    stream: Writable = process.stdout,
-    enhancer: TestResultsEnhancer = ColorUtil.colorize ? COLOR_ENHANCER : DUMMY_ENHANCER
-  ) {
-    this.#stream = stream;
-    this.#enhancer = enhancer;
-  }
-
-  protected log(message: string): void {
-    this.#stream.write(`${message}\n`);
-  }
-
-  onEvent(e: TestEvent): void {
-    // Do nothing
-  }
-
-  /**
-   * Summarize all results
-   */
-  onSummary(summary: SuitesSummary): void {
-    this.log(`${this.#enhancer.testNumber(1)}..${this.#enhancer.testNumber(summary.total)}`);
-
-    if (summary.errors.length) {
-      this.log('---\n');
-      for (const err of summary.errors) {
-        this.log(this.#enhancer.failure(err instanceof Error ? `${err.toJSON()}` : `${err}`));
-      }
-    }
-
-    const allPassed = summary.failed === 0;
-
-    this.log([
-      this.#enhancer[allPassed ? 'success' : 'failure']('Results'),
-      `${this.#enhancer.total(summary.passed)}/${this.#enhancer.total(summary.total)},`,
-      allPassed ? 'failed' : this.#enhancer.failure('failed'),
-      `${this.#enhancer.total(summary.failed)}`,
-      'skipped',
-      this.#enhancer.total(summary.skipped),
-      `# (Total Time: ${summary.duration}ms)`
-    ].join(' '));
-
-    if (!allPassed) {
-      for (const suite of summary.suites) {
-        if (suite.failed) {
-          for (const test of (suite.tests ?? [])) {
-            if (test.status === 'failed') {
-              this.log(`Test ${suite.classId}:${test.methodName}`);
-              for (const assert of (test.assertions ?? [])) {
-                if (assert.error) {
-                  this.log(`${assert.classId}:${assert.line} => ${assert.text}\n${assert.error.stack}\n`);
-                }
-              }
-            }
-          }
-        }
-      }
-    }
-  }
-}

package/src/worker/isolated.ts

@@ -1,19 +0,0 @@
-import { Worker } from '@travetto/worker';
-
-import { TestConsumer } from '../consumer/types';
-import { TestExecutor } from '../execute/executor';
-
-/**
- *  Produce a handler for the child worker
- */
-export function buildIsolatedTestManager(consumer: TestConsumer): () => Worker<string> {
-  let id = 0;
-  return (): Worker<string> => ({
-    id: id++,
-    active: true,
-    async destroy(): Promise<void> { },
-    async execute(file: string): Promise<void> {
-      await TestExecutor.executeIsolated(consumer, file);
-    }
-  });
-}

package/support/phase.reset.ts

@@ -1,12 +0,0 @@
-/**
- * Handle test reset
- */
-export const init = {
-  key: '@trv:test/rest',
-  before: ['@trv:registry/reset'],
-  action: async (): Promise<void> => {
-    const { SuiteRegistry } = await import('../src/registry/suite');
-    // Clear the registry
-    await SuiteRegistry.reset();
-  }
-};