refactor(core): 1.0.0-alpha

packages/core/jest.config.js

@@ -1,6 +1,7 @@
+/** @type {import('ts-jest/dist/types').InitialOptionsTsJest} */
 module.exports = {
   preset: 'ts-jest',
+  testEnvironment: 'node',
   roots: ['test/'],
-  testEnvironment: 'jsdom',
   testMatch: ['**/test/**/*.[jt]s?(x)', '**/?(*.)+(spec).[jt]s?(x)'],
 };

packages/core/src/BailError.ts

@@ -0,0 +1,10 @@
+export class BailError extends Error {
+  constructor(message: string) {
+    super(message)
+    this.name = 'BailError'
+  }
+}
+
+function createBailError(message: string): BailError {
+  return new BailError(message)
+}

packages/core/src/TimeoutError.ts

@@ -0,0 +1,10 @@
+export class TimeoutError extends Error {
+  public constructor(message: string) {
+    super(message)
+    this.name = 'TimeoutError'
+  }
+}
+
+function createTimeoutError(message: string): TimeoutError {
+  return new TimeoutError(message)
+}

packages/core/src/index.ts

@@ -14,9 +14,9 @@ export {
   beforeEach,
   afterEach,
 } from './interface'
-export { Status, default as Result } from './result'
-export { default as Runnable, isRunnable, RunnableTypes } from './runnable'
+export { /*Status,*/ default as Result } from './result'
+export { default as Runnable, isRunnable, /*RunnableTypes*/ } from './runnable'
 export { default as Test, isTest } from './test'
-export { default as Suite, isSuite, SuiteStats, rootSymbol, BailError } from './suite'
-export { default as Runner, RunOptions, runnerDefaults } from './runner'
+export { default as Suite, isSuite, /*SuiteStats,*/ rootSymbol/*, BailError*/ } from './suite'
+// export { RunOptions } from './runner'
 export { Hook, HookName, HookFn, Hooks } from './hooks'

packages/core/src/result.ts

@@ -1,61 +1,99 @@
-export enum Status {
-  Pending = 'pending',
-  Running = 'running',
-  Passed = 'passed',
-  Failed = 'failed',
-  Skipped = 'skipped',
-  Todo = 'todo',
+// import { RunnableTypes } from "."\
+
+
+// export enum Status {
+//   Pending = 'pending',
+//   Running = 'running',
+//   Passed = 'passed',
+//   Failed = 'failed',
+//   Skipped = 'skipped',
+//   Todo = 'todo',
+// }
+
+// Types
+import { BailError } from './BailError'
+import { TimeoutError } from './TimeoutError'
+import { RunnableTypes, Status } from './types'
+type ResultOptions<T extends RunnableTypes> = {
+  description: string
+  time: number
+  type: T
 }
 
+type RunnableError = Error | TimeoutError | BailError
+
 /**
  * @todo Delete messages.
  */
-export default class Result {
-  private internalStatus: Status
-  private internalMessages: string[]
+class Result<T extends RunnableTypes> {
+  private _internalErrors: Error[]
+  private _internalStatus: Status
+  private _internalMessages: string[]
 
-  constructor(status?: Status, messages: string | string[] = []) {
-    this.internalStatus = status || Status.Pending
-    if (!Array.isArray(messages)) {
-      messages = [ messages ]
-    }
-    this.internalMessages = messages
+  public time: number
+  public description: string
+  public type: T
+
+  constructor(messages: string | string[] = [], options: ResultOptions<T>, errors: RunnableError[] | RunnableError = [], status?: Status) {
+    this._internalErrors = !Array.isArray(errors) ? [ errors ] : errors
+    this._internalStatus = status || Status.Pending
+    this._internalMessages = !Array.isArray(messages) ? [ messages ] : messages
+
+    this.description = options.description
+    this.time = options.time
+    this.type = options.type
   }
 
   /**
    * @description Checks if the internal status is 'Pending' or 'Running'.
    */
-  public isDone() {
-    return this.internalStatus !== Status.Pending && this.internalStatus !== Status.Running
+  public isDone(): boolean {
+    return this._internalStatus !== Status.Pending && this._internalStatus !== Status.Running
+  }
+
+  public get errors(): Array<Error> {
+    return this._internalErrors
   }
 
   /**
    * @description Gets the internal status on the current `Result` instance.
    */
-  public get status() {
-    return this.internalStatus
+  public get status(): Status {
+    return this._internalStatus
   }
 
   /**
    * @description Sets the internal status on the current `Result` instance.
    */
   public set status(v: Status) {
     if (this.isDone()) { return }
-    this.internalStatus = v
+    this._internalStatus = v
   }
 
   /**
    * @description Gets the internal messages on the current `Result` instance.
    */
-  public get messages() {
-    return this.internalMessages
+  public get messages(): string[] {
+    return this._internalMessages
   }
 
   /**
    * @description Adds messages to the internal messages if the `Runnable` has not completed.
    */
-  public addMessages(...messages: string[]) {
+  public addMessages(...messages: string[]): void {
     if (this.isDone()) { return }
-    this.internalMessages.push(...messages)
+    this._internalMessages = [...this._internalMessages, ...messages]
+  }
+
+  public addErrors(...errors: Error[]): void {
+    if (this.isDone()) { return }
+    this.addMessages(...errors.map((e) => e.message))
+    this._internalErrors = [...this._internalErrors, ...errors]
   }
 }
+
+export function createResult<T extends RunnableTypes>(options: ResultOptions<T>, messages: string | string[] = [], errors: RunnableError[] | RunnableError = [], status?: Status): Result<T> {
+  return new Result(messages, options, errors, status)
+}
+
+export default Result

packages/core/src/runnable.ts

@@ -1,30 +1,57 @@
-import { EventEmitter } from 'events'
 import { performance } from 'perf_hooks'
-import Result, { Status } from './result'
-import Suite from './suite'
+import type { Hooks } from './hooks'
+// import { RunStatus/*, BaseResult*/ } from './newResult'
+// import Result, { Status } from './result'
+import type Suite from './suite'
+import type Result from './result'
+import type Test from './test'
+
+// Types
+import { RunnableOptions, RunnableResult, RunStatus, RunnableTypes, RunOptions } from './types'
 
 export const runnableSymbol = Symbol('isRunnable')
 
 /**
  * @description Checks if passed value is an instance of `Runnable`.
  */
 export const isRunnable = (v: unknown): v is Runnable => {
-  if (typeof v === 'object' && v === null) { return false }
-  return (v as Runnable)[runnableSymbol]
-}
-
-export enum RunnableTypes {
-  Runnable = 'runnable',
-  Suite = 'suite',
-  Test = 'test',
+  if (v && (v as Runnable)[runnableSymbol]) { return true }
+  else { return false }
 }
 
-export interface RunnableOptions {
-  skip: boolean
-  todo: boolean
+// export const isRunnable2 = <R extends Runnable | Test | Suite>(v: unknown): v is R => {
+//   return (v instanceof Runnable) || (v instanceof Test) || (v instanceof Suite)
+// }
+
+// export enum RunnableTypes {
+//   Runnable = 'runnable',
+//   Suite = 'suite',
+//   Test = 'test',
+// }
+
+// export interface RunnableOptions {
+//   skip: boolean
+//   todo: boolean
+// }
+
+// export interface RunnableResult extends BaseResult {
+//   id: string
+//   description: string
+//   time: number
+// }
+
+const DEFAULT_RESULT: RunnableResult = {
+  id: '',
+  description: '',
+  messages: [],
+  failures: [],
+  hooks: {} as Hooks,
+  status: RunStatus.PENDING,
+  time: 0,
+  fullDescription: '', 
 }
 
-export default class Runnable extends EventEmitter {
+export default abstract class Runnable {
 
   /**
    * @description Normalize passed options object with `Runnable` default options.
@@ -37,49 +64,53 @@ export default class Runnable extends EventEmitter {
     }
   }
   public description: string
-  public result: Result
   public options: RunnableOptions
   public parent: Suite | null
+  public result: RunnableResult
+  public status: RunStatus
   public type: RunnableTypes = RunnableTypes.Runnable
   public [runnableSymbol] = true
 
-  public time = 0
-  private start = 0
+  public start = 0
 
   /* istanbul ignore next */
   constructor(description: string, options: Partial<RunnableOptions> = {}, parent: Suite | null) {
-    super()
     this.description = description
-    this.result = new Result()
     this.options = Runnable.normalizeOptions(options)
     this.parent = parent
+    this.result = { ...DEFAULT_RESULT, description, fullDescription: this.getFullDescription() }
+    this.status = RunStatus.PENDING
   }
 
+  /**
+   * @description Run a `Runnable` instance.
+   */
+  public abstract run(options: Partial<RunOptions>): Promise<RunnableResult | Result>
+
+
   /**
    * @description Sets result status to `Running` and emits a `start` event with the `Runnable` instance and timestamp.
    */
-  public doStart(): void {
-    this.result.status = Status.Running
-    this.emit('start', this)
+  public doStart(): RunnableResult {
+    this.result.status = RunStatus.RUNNING
     this.start = performance.now()
+    return this.result
   }
 
   /**
    * @description Emits an `end` event with the completed `Runnable` instance and the time taken to complete.
    */
   public doEnd() {
-    if (this.result.status !== Status.Skipped && this.result.status !== Status.Todo) {
-      this.time = performance.now() - this.start
+    if (this.result.status !== RunStatus.SKIPPED && this.result.status !== RunStatus.TODO) {
+      this.result.time = performance.now() - this.start
     }
-    this.emit('end', this, this.time)
   }
 
   /**
    * @description Emits a `pass` event with the passing `Runnable` instance.
    */
-  public doPass(): Result {
-    this.result.status = Status.Passed
-    this.emit('pass', this)
+  public doPass() {
+    this.result.status = RunStatus.PASSED
     this.doEnd()
 
     return this.result
@@ -88,12 +119,10 @@ export default class Runnable extends EventEmitter {
   /**
    * @description Emits a `fail` event with the failed `Runnable` instance and passed error.
    */
-  public doFail(error?: Error | string): Result {
-    if (error) {
-      this.result.addMessages(String(error))
-    }
-    this.result.status = Status.Failed
-    this.emit('fail', this, error)
+  public doFail(error: Error) {
+    this.result.failures = [...this.result.failures, error]
+    this.result.messages = [...this.result.messages, error.message]
+    this.result.status = RunStatus.FAILED
     this.doEnd()
 
     return this.result
@@ -102,41 +131,37 @@ export default class Runnable extends EventEmitter {
   /**
    * @description Emits `skip` event with the skipped `Runnable` instance.
    */
-  public doSkip(todo = false): Result {
-    this.result.status = todo ? Status.Todo : Status.Skipped
-    this.emit('skip', this, todo)
+  public doSkip(skipOrTodo: RunStatus.SKIPPED | RunStatus.TODO) {
+    this.result.status = skipOrTodo
     this.doEnd()
 
     return this.result
   }
 
   /**
-   * @description Run a `Runnable` instance.
+   * @description Check that `Runnable` has completed.
    */
-  // istanbul ignore next unimplemented
-  public async run(): Promise<Result> {
-    if (this.options.skip || this.options.todo) {
-      return this.doSkip(this.options.todo)
-    }
-
-    this.doStart()
-
-    return this.doSkip() // To be replaced with real run function
+  public isDone() {
+    return this.result.status !== RunStatus.PENDING && this.result.status !== RunStatus.RUNNING
   }
 
   /**
-   * @description Check that `Runnable` has completed.
+   * @description Check if the current status is the same as the status argument passed in.
    */
-  public isDone() {
-    return this.result.isDone()
+  public isStatus(status: RunStatus): boolean {
+    return this.result.status === status
+  }
+
+  public isPending(): boolean {
+    return this.result.status === RunStatus.PENDING || (this.parent !== null && this.parent.isStatus(RunStatus.PENDING))
   }
 
   /**
    * @description Concatenate the Parent's description and the current `Runnable`'s description.
    */
   public getFullDescription(): string {
     if (this.parent && !this.parent.isRoot()) {
-      return `${this.parent.getFullDescription()} -> ${this.description}`
+      return `${this.parent.getFullDescription()} ${this.description}`
     }
     return this.description
   }