@travetto/test 8.0.0-alpha.2 → 8.0.0-alpha.21

package/src/execute/run.ts

@@ -1,21 +1,21 @@
 import { createReadStream } from 'node:fs';
 import fs from 'node:fs/promises';
-import readline from 'node:readline/promises';
 import path from 'node:path';
+import readline from 'node:readline/promises';
 
-import { Env, ExecUtil, Util, RuntimeIndex, Runtime, TimeUtil, JSONUtil } from '@travetto/runtime';
-import { WorkPool } from '@travetto/worker';
 import { Registry } from '@travetto/registry';
+import { describeFunction, Env, ExecUtil, JSONUtil, Runtime, RuntimeIndex, TimeUtil, Util } from '@travetto/runtime';
+import { WorkPool } from '@travetto/worker';
 
-import type { TestConfig, TestRunInput, TestRun, TestGlobInput, TestDiffInput } from '../model/test.ts';
-import type { TestRemoveEvent } from '../model/event.ts';
-import type { TestConsumerShape } from '../consumer/types.ts';
-import { RunnableTestConsumer } from '../consumer/types/runnable.ts';
-import type { TestConsumerConfig } from './types.ts';
 import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
-import { TestExecutor } from './executor.ts';
-import { buildStandardTestManager } from '../worker/standard.ts';
+import { RunnableTestConsumer } from '../consumer/types/runnable.ts';
+import type { TestConsumerShape } from '../consumer/types.ts';
+import type { TestRemoveEvent } from '../model/event.ts';
+import type { TestConfig, TestDiffInput, TestGlobInput, TestRun, TestRunInput } from '../model/test.ts';
 import { SuiteRegistryIndex } from '../registry/registry-index.ts';
+import { buildStandardTestManager } from '../worker/standard.ts';
+import { TestExecutor } from './executor.ts';
+import type { TestConsumerConfig } from './types.ts';
 
 type RunState = {
   runs: TestRun[];
@@ -26,7 +26,6 @@ type RunState = {
  * Test Utilities for Running
  */
 export class RunUtil {
-
   /**
    * Determine if a given file path is a valid test file
    */
@@ -47,7 +46,7 @@ export class RunUtil {
   /**
    * Find all valid test files given the globs
    */
-  static async* getTestImports(globs?: string[]): AsyncIterable<string> {
+  static async *getTestImports(globs?: string[]): AsyncIterable<string> {
     const all = RuntimeIndex.find({
       module: module => module.roles.includes('test') || module.roles.includes('std'),
       folder: folder => folder === 'test',
@@ -60,7 +59,7 @@ export class RunUtil {
       for await (const item of fs.glob(globs)) {
         const source = Runtime.workspaceRelative(path.resolve(item));
         const match = allFiles.get(source);
-        if (match && await this.isTestFile(match.sourceFile)) {
+        if (match && (await this.isTestFile(match.sourceFile))) {
           yield match.import;
         }
       }
@@ -80,7 +79,7 @@ export class RunUtil {
   static async resolveGlobInput({ globs, tags, metadata }: TestGlobInput): Promise<TestRun[]> {
     const digestProcess = await ExecUtil.getResult(
       ExecUtil.spawnPackageCommand('trv', ['test:digest', '-o', 'json', ...globs], {
-        env: { ...process.env, ...Env.FORCE_COLOR.export(0), ...Env.NO_COLOR.export(true) },
+        env: { ...process.env, ...Env.FORCE_COLOR.export(0), ...Env.NO_COLOR.export(true) }
       }),
       { catch: true }
     );
@@ -89,20 +88,20 @@ export class RunUtil {
       throw new Error(digestProcess.stderr);
     }
 
-    const testFilter = tags?.length ?
-      Util.allowDeny<string, [TestConfig]>(
-        tags,
-        rule => rule,
-        (rule, core) => core.tags?.includes(rule) ?? false
-      ) :
-      ((): boolean => true);
+    const testFilter = tags?.length
+      ? Util.allowDeny<string, [TestConfig]>(
+          tags,
+          rule => rule,
+          (rule, core) => core.tags?.includes(rule) ?? false
+        )
+      : (): boolean => true;
 
     const parsed: TestConfig[] = JSONUtil.fromUTF8(digestProcess.stdout);
 
     const events = parsed.filter(testFilter).reduce((runs, test) => {
-      runs.getOrInsert(test.classId,
-        { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid(), metadata }
-      ).methodNames!.push(test.methodName);
+      runs
+        .getOrInsert(test.classId, { import: test.import, classId: test.classId, methodNames: [], runId: Util.uuid(), metadata })
+        .methodNames!.push(test.methodName);
       return runs;
     }, new Map<string, TestRun>());
 
@@ -126,6 +125,7 @@ export class RunUtil {
     const imported = await Registry.manualInit([importPath]);
     const classes = Object.fromEntries(
       imported
+        .filter(cls => !describeFunction(cls).abstract)
         .filter(cls => SuiteRegistryIndex.hasConfig(cls))
         .map(cls => [cls.Ⲑid, SuiteRegistryIndex.getConfig(cls)])
     );
@@ -140,18 +140,22 @@ export class RunUtil {
     // Looking at Diff
     for (const [clsId, config] of Object.entries(diff)) {
       const local = classes[clsId];
-      if (!local) { // Removed classes
+      if (!local) {
+        // Removed classes
         removeTest(clsId);
-      } else if (local.sourceHash !== config.sourceHash) { // Class changed or added
+      } else if (local.sourceHash !== config.sourceHash) {
+        // Class changed or added
         // Methods to run, defaults to newly added
         const methods: string[] = Object.keys(local.tests ?? {}).filter(key => !config.methods[key]);
         let didRemove = false;
         for (const key of Object.keys(config.methods)) {
           const localMethod = local.tests?.[key];
-          if (!localMethod) { // Test is removed
+          if (!localMethod) {
+            // Test is removed
             removeTest(clsId, key);
             didRemove = true;
-          } else if (localMethod.sourceHash !== config.methods[key]) { // Method changed or added
+          } else if (localMethod.sourceHash !== config.methods[key]) {
+            // Method changed or added
             methods.push(key);
           }
         }
@@ -161,7 +165,8 @@ export class RunUtil {
       }
     }
 
-    if (runs.length === 0 && removes.length === 0) { // Re-run entire file, classes unchanged
+    if (runs.length === 0 && removes.length === 0) {
+      // Re-run entire file, classes unchanged
       addRun(undefined);
     }
 
@@ -222,19 +227,15 @@ export class RunUtil {
     }
 
     if (runs.length === 1) {
-      await new TestExecutor(consumer).execute(runs[0]);
+      await new TestExecutor(consumer).execute(runs[0], true);
     } else {
-      await WorkPool.run(
-        run => buildStandardTestManager(consumer, run),
-        runs,
-        {
-          idleTimeoutMillis: TimeUtil.duration('10s', 'ms'),
-          min: 1,
-          max: consumerConfig.concurrency
-        }
-      );
+      await WorkPool.run(run => buildStandardTestManager(consumer, run), runs, {
+        idleTimeoutMillis: TimeUtil.duration('10s', 'ms'),
+        min: 1,
+        max: consumerConfig.concurrency
+      });
     }
 
     return consumer.summarizeAsBoolean();
   }
-}
+}

package/src/execute/watcher.ts

@@ -1,14 +1,14 @@
 import { ManifestModuleUtil } from '@travetto/manifest';
 import { Registry } from '@travetto/registry';
-import { WorkPool } from '@travetto/worker';
 import { AsyncQueue, TimeUtil, WatchUtil } from '@travetto/runtime';
+import { WorkPool } from '@travetto/worker';
 
-import { buildStandardTestManager } from '../worker/standard.ts';
 import { TestConsumerRegistryIndex } from '../consumer/registry-index.ts';
 import { CumulativeSummaryConsumer } from '../consumer/types/cumulative.ts';
 import type { TestDiffInput, TestRun } from '../model/test.ts';
-import { RunUtil } from './run.ts';
+import { buildStandardTestManager } from '../worker/standard.ts';
 import { isTestRunEvent, type TestReadyEvent } from '../worker/types.ts';
+import { RunUtil } from './run.ts';
 
 /**
  * Test Watcher.
@@ -16,7 +16,6 @@ import { isTestRunEvent, type TestReadyEvent } from '../worker/types.ts';
  * Runs all tests on startup, and then listens for changes to run tests again
  */
 export class TestWatcher {
-
   /**
    * Start watching all test files
    */
@@ -28,13 +27,11 @@ export class TestWatcher {
     const events: (TestRun | TestDiffInput)[] = [];
 
     if (runAllOnStart) {
-      events.push(...await RunUtil.resolveGlobInput({ globs: [] }));
+      events.push(...(await RunUtil.resolveGlobInput({ globs: [] })));
     }
 
     const queue = new AsyncQueue(events);
-    const consumer = new CumulativeSummaryConsumer(
-      await TestConsumerRegistryIndex.getInstance({ consumer: format })
-    );
+    const consumer = new CumulativeSummaryConsumer(await TestConsumerRegistryIndex.getInstance({ consumer: format }));
 
     process.on('message', event => {
       if (isTestRunEvent(event)) {
@@ -44,19 +41,15 @@ export class TestWatcher {
 
     process.send?.({ type: 'ready' } satisfies TestReadyEvent);
 
-    const queueProcessor = WorkPool.run(
-      buildStandardTestManager.bind(null, consumer),
-      queue,
-      {
-        idleTimeoutMillis: TimeUtil.duration('2m', 'ms'),
-        min: 2,
-        max: WorkPool.DEFAULT_SIZE
-      }
-    );
+    const queueProcessor = WorkPool.run(buildStandardTestManager.bind(null, consumer), queue, {
+      idleTimeoutMillis: TimeUtil.duration('2m', 'ms'),
+      min: 2,
+      max: WorkPool.DEFAULT_SIZE
+    });
 
     await WatchUtil.watchCompilerEvents('change', event => {
       const fileType = ManifestModuleUtil.getFileType(event.file);
-      if ((fileType === 'ts' || fileType === 'js')) {
+      if (fileType === 'ts' || fileType === 'js') {
         if (event.action === 'delete') {
           consumer.removeTest(event.import);
         } else {
@@ -69,4 +62,4 @@ export class TestWatcher {
     // Cleanup
     await queueProcessor;
   }
-}
+}

package/src/fixture.ts

@@ -2,11 +2,10 @@ import { FileLoader, Runtime } from '@travetto/runtime';
 
 export class TestFixtures extends FileLoader {
   constructor(modules: string[] = []) {
-    super([
-      '@#test/fixtures',
-      '@#support/fixtures',
-      ...modules.flat().map(module => `${module}#support/fixtures`),
-      '@@#support/fixtures'
-    ].map(value => Runtime.modulePath(value)));
+    super(
+      ['@#test/fixtures', '@#support/fixtures', ...modules.flat().map(module => `${module}#support/fixtures`), '@@#support/fixtures'].map(
+        value => Runtime.modulePath(value)
+      )
+    );
   }
-}
+}

package/src/model/common.ts

@@ -47,4 +47,4 @@ export interface TestCore extends SuiteCore {
    * For extended suites, this is where the test is declared
    */
   declarationImport?: string;
-}
+}

package/src/model/error.ts

@@ -3,9 +3,9 @@ import { RuntimeError } from '@travetto/runtime';
 /**
  * Represents an execution error
  */
-export class TestExecutionError extends RuntimeError { }
+export class TestExecutionError extends RuntimeError {}
 
 /**
  * Timeout execution error
  */
-export class TimeoutError extends TestExecutionError { }
+export class TimeoutError extends TestExecutionError {}

package/src/model/event.ts

@@ -1,5 +1,5 @@
-import type { Assertion, TestConfig, TestResult } from './test.ts';
 import type { SuiteConfig, SuiteResult } from './suite.ts';
+import type { Assertion, TestConfig, TestResult } from './test.ts';
 
 /**
  * Targets
@@ -11,17 +11,22 @@ export type EventEntity = 'test' | 'suite' | 'assertion';
  */
 export type EventPhase = 'before' | 'after';
 
-type EventTpl<T extends EventEntity, P extends EventPhase, V extends {}> =
-  { type: T, phase: P, metadata?: Record<string, unknown> } & V;
+type EventTpl<T extends EventEntity, P extends EventPhase, V extends {}> = { type: T; phase: P; metadata?: Record<string, unknown> } & V;
 
-export type TestRemoveEvent = { type: 'removeTest', import: string, classId?: string, methodName?: string, metadata?: Record<string, unknown> };
+export type TestRemoveEvent = {
+  type: 'removeTest';
+  import: string;
+  classId?: string;
+  methodName?: string;
+  metadata?: Record<string, unknown>;
+};
 
 /**
  * Different test event shapes
  */
 export type TestEvent =
-  EventTpl<'assertion', 'after', { assertion: Assertion }> |
-  EventTpl<'test', 'before', { test: TestConfig }> |
-  EventTpl<'test', 'after', { test: TestResult }> |
-  EventTpl<'suite', 'before', { suite: SuiteConfig }> |
-  EventTpl<'suite', 'after', { suite: SuiteResult }>;
+  | EventTpl<'assertion', 'after', { assertion: Assertion }>
+  | EventTpl<'test', 'before', { test: TestConfig }>
+  | EventTpl<'test', 'after', { test: TestResult }>
+  | EventTpl<'suite', 'before', { suite: SuiteConfig }>
+  | EventTpl<'suite', 'after', { suite: SuiteResult }>;

package/src/model/suite.ts

@@ -1,7 +1,7 @@
 import type { Any, Class } from '@travetto/runtime';
 
-import type { TestConfig, TestResult, TestStatus } from './test.ts';
 import type { Skip, SuiteCore } from './common.ts';
+import type { TestConfig, TestResult, TestStatus } from './test.ts';
 
 export type SuitePhase = 'beforeAll' | 'beforeEach' | 'afterAll' | 'afterEach';
 
@@ -19,10 +19,6 @@ export interface SuiteConfig extends SuiteCore {
    * Should this be skipped
    */
   skip: Skip;
-  /**
-   * Actual class instance
-   */
-  instance?: unknown;
   /**
    * Tests to run
    */
@@ -34,31 +30,37 @@ export interface SuiteConfig extends SuiteCore {
 }
 
 /**
- * All counts for the suite summary
+ * Test Counts
  */
-export interface Counts {
+export interface ResultsSummary {
+  /** Passing Test Count  */
   passed: number;
+  /** Skipped Test Count  */
   skipped: number;
+  /** Failed Test Count  */
   failed: number;
+  /** Errored Test Count  */
   errored: number;
+  /** Unknown Test Count  */
   unknown: number;
+  /** Total Test Count  */
   total: number;
+  /** Test Self Execution Duration  */
+  selfDuration: number;
+  /** Total Duration */
+  duration: number;
 }
 
 /**
  * Results of a suite run
  */
-export interface SuiteResult extends Counts, SuiteCore {
+export interface SuiteResult extends ResultsSummary, SuiteCore {
   /**
    * All test results
    */
   tests: Record<string, TestResult>;
-  /**
-   * Suite duration
-   */
-  duration: number;
   /**
    * Overall status
    */
   status: TestStatus;
-}
+}

package/src/model/test.ts

@@ -5,10 +5,13 @@ import type { Skip, TestCore } from './common.ts';
 export type ThrowableError = string | RegExp | Class<Error> | ((error: Error | string) => boolean | void | undefined);
 export type TestLog = Omit<ConsoleEvent, 'args' | 'scope'> & { message: string };
 
-export type TestDiffSource = Record<string, {
-  sourceHash: number;
-  methods: Record<string, number>;
-}>;
+export type TestDiffSource = Record<
+  string,
+  {
+    sourceHash: number;
+    methods: Record<string, number>;
+  }
+>;
 
 export type TestStatus = 'passed' | 'skipped' | 'errored' | 'failed' | 'unknown';
 
@@ -105,13 +108,13 @@ export interface TestResult extends TestCore {
    */
   assertions: Assertion[];
   /**
-   * Duration for the test
+   * Self Execution Duration
    */
-  duration: number;
+  selfDuration: number;
   /**
    * Total duration including before/after
    */
-  durationTotal: number;
+  duration: number;
   /**
    * Logging output
    */
@@ -184,4 +187,4 @@ export type TestGlobInput = {
   metadata?: Record<string, unknown>;
 };
 
-export type TestRunInput = TestRun | TestDiffInput | TestGlobInput;
+export type TestRunInput = TestRun | TestDiffInput | TestGlobInput;

package/src/model/util.ts

@@ -1,14 +1,107 @@
-import type { Counts } from './suite.ts';
-import type { TestStatus } from './test.ts';
+import path from 'node:path';
+
+import { asFull, RuntimeIndex } from '@travetto/runtime';
+
+import type { ResultsSummary, SuiteConfig, SuiteResult } from './suite.ts';
+import type { TestConfig, TestResult, TestRun, TestStatus } from './test.ts';
 
 export class TestModelUtil {
-  static countsToTestStatus(counts: Counts): TestStatus {
+  static computeTestStatus(summary: ResultsSummary): TestStatus {
     switch (true) {
-      case counts.errored > 0: return 'errored';
-      case counts.failed > 0: return 'failed';
-      case counts.skipped > 0: return 'skipped';
-      case counts.unknown > 0: return 'unknown';
-      default: return 'passed';
+      case summary.errored > 0:
+        return 'errored';
+      case summary.failed > 0:
+        return 'failed';
+      case summary.skipped > 0:
+        return 'skipped';
+      case summary.unknown > 0:
+        return 'unknown';
+      default:
+        return 'passed';
+    }
+  }
+
+  static buildSummary(): ResultsSummary {
+    return { passed: 0, failed: 0, skipped: 0, errored: 0, unknown: 0, total: 0, duration: 0, selfDuration: 0 };
+  }
+
+  static countTestResult<T extends ResultsSummary>(summary: T, tests: Pick<TestResult, 'status' | 'selfDuration' | 'duration'>[]): T {
+    for (const test of tests) {
+      summary[test.status] += 1;
+      summary.total += 1;
+      summary.selfDuration += test.selfDuration ?? 0;
+      summary.duration += test.duration ?? 0;
     }
+    return summary;
+  }
+
+  /**
+   * An empty suite result based on a suite config
+   */
+  static createSuiteResult(suite: SuiteConfig, override?: Partial<SuiteResult>): SuiteResult {
+    return {
+      ...TestModelUtil.buildSummary(),
+      status: 'unknown',
+      lineStart: suite.lineStart,
+      lineEnd: suite.lineEnd,
+      import: suite.import,
+      classId: suite.classId,
+      sourceHash: suite.sourceHash,
+      tests: {},
+      duration: 0,
+      selfDuration: 0,
+      ...override
+    };
+  }
+
+  /**
+   * An empty test result based on a suite and test config
+   */
+  static createTestResult(suite: SuiteConfig, test: TestConfig, override?: Partial<TestResult>): TestResult {
+    return {
+      methodName: test.methodName,
+      description: test.description,
+      classId: test.classId,
+      tags: test.tags,
+      suiteLineStart: suite.lineStart,
+      lineStart: test.lineStart,
+      lineEnd: test.lineEnd,
+      lineBodyStart: test.lineBodyStart,
+      import: test.import,
+      declarationImport: test.declarationImport,
+      sourceHash: test.sourceHash,
+      status: 'unknown',
+      assertions: [],
+      duration: 0,
+      selfDuration: 0,
+      output: [],
+      ...override
+    };
+  }
+
+  static createImportErrorSuiteResult(run: TestRun): SuiteResult {
+    const name = path.basename(run.import);
+    const classId = `${RuntimeIndex.getFromImport(run.import)?.id}#${name}`;
+    const common = { classId, duration: 0, lineStart: 1, lineEnd: 1, import: run.import } as const;
+    return asFull<SuiteResult>({
+      ...common,
+      status: 'errored',
+      errored: 1,
+      tests: {
+        impport: asFull<TestResult>({
+          ...common,
+          status: 'errored',
+          assertions: [
+            {
+              ...common,
+              line: common.lineStart,
+              methodName: 'import',
+              operator: 'import',
+              text: `Failed to import ${run.import}`
+            }
+          ]
+        })
+      }
+    });
   }
-}
+}

package/src/registry/registry-adapter.ts

@@ -1,5 +1,5 @@
 import type { RegistryAdapter } from '@travetto/registry';
-import { RuntimeError, asFull, type Class, describeFunction, Runtime, safeAssign } from '@travetto/runtime';
+import { asFull, type Class, describeFunction, Runtime, RuntimeError, safeAssign } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 import type { SuiteConfig } from '../model/suite.ts';
@@ -8,7 +8,7 @@ import type { TestConfig } from '../model/test.ts';
 function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConfig>[]): SuiteConfig {
   for (const config of subConfig) {
     if (config.tags) {
-      baseConfig.tags = [...new Set([...baseConfig.tags ?? [], ...config.tags])];
+      baseConfig.tags = [...new Set([...(baseConfig.tags ?? []), ...config.tags])];
     }
     baseConfig.skip = config.skip ?? baseConfig.skip;
 
@@ -22,7 +22,7 @@ function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConf
           ...test,
           class: baseConfig.class,
           classId: baseConfig.classId,
-          import: baseConfig.import,
+          import: baseConfig.import
         };
       }
     }
@@ -31,7 +31,7 @@ function combineClasses(baseConfig: SuiteConfig, ...subConfig: Partial<SuiteConf
 }
 
 function combineWithParent(baseConfig: SuiteConfig, parentConfig: SuiteConfig): SuiteConfig {
-  baseConfig.tags = [...parentConfig.tags ?? [], ...baseConfig.tags ?? []];
+  baseConfig.tags = [...(parentConfig.tags ?? []), ...(baseConfig.tags ?? [])];
   baseConfig.skip = baseConfig.skip ?? parentConfig.skip;
   baseConfig.phaseHandlers = [...(parentConfig.phaseHandlers ?? []), ...(baseConfig.phaseHandlers ?? [])];
   for (const [key, test] of Object.entries(parentConfig.tests ?? {})) {
@@ -39,7 +39,7 @@ function combineWithParent(baseConfig: SuiteConfig, parentConfig: SuiteConfig):
       ...test,
       class: baseConfig.class,
       classId: baseConfig.classId,
-      import: baseConfig.import,
+      import: baseConfig.import
     };
   }
   return baseConfig;
@@ -50,10 +50,7 @@ function combineMethods(suite: SuiteConfig, baseConfig: TestConfig, ...subConfig
   baseConfig.import = suite.import;
   for (const config of subConfig) {
     safeAssign(baseConfig, config, {
-      tags: [
-        ...baseConfig.tags ?? [],
-        ...config.tags ?? []
-      ]
+      tags: [...(baseConfig.tags ?? []), ...(config.tags ?? [])]
     });
   }
   return baseConfig;
@@ -80,7 +77,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineEnd: lines?.[1],
         sourceHash: hash,
         tests: {},
-        phaseHandlers: [],
+        phaseHandlers: []
       });
     }
     combineClasses(this.#config, ...data);
@@ -102,7 +99,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
         lineEnd: lines?.[1],
         lineBodyStart: lines?.[2],
         methodName: method,
-        sourceHash: hash,
+        sourceHash: hash
       });
       this.#config.tests[method] = config;
     }
@@ -118,7 +115,7 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     }
 
     for (const test of Object.values(this.#config.tests)) {
-      test.tags = [...new Set([...test.tags ?? [], ...this.#config.tags ?? []])];
+      test.tags = [...new Set([...(test.tags ?? []), ...(this.#config.tags ?? [])])];
       test.description ||= SchemaRegistryIndex.get(this.#cls).getMethod(test.methodName).description;
     }
   }
@@ -134,4 +131,4 @@ export class SuiteRegistryAdapter implements RegistryAdapter<SuiteConfig> {
     }
     return test;
   }
-}
+}