nole 2.2.2 → 3.1.0

package/src/decorators.ts

@@ -1,208 +0,0 @@
-import { HashMap } from "./data.js";
-import { Test, HookType, ClassDefition } from "./test.js";
-import camelcase from "camelcase";
-
-/**
- * Assignes method as test case
- * @param timeout Timeout of case in milliseconds
- */
-export function Spec(timeout: number = 5000): MethodDecorator {
-  return function (target, propertyKey) {
-    DeclareSpecForTestClass(target, <string>propertyKey, timeout);
-  };
-}
-
-/**
- * Assignes dependency for test class
- * @param dependency a Test class that needed
- */
-export function Dependency<T>(dependency: ClassDefition<T>): PropertyDecorator {
-  return function (target, propertyKey) {
-    DeclareDependencyForTestClass(target, <string>propertyKey, dependency);
-  };
-}
-
-/**
- * Assignes dependencies for test class
- * @param dependencies a Test class array that needed
- */
-export function Dependencies(
-  dependencies: (() => ClassDefition<any>[]) | ClassDefition<any>[]
-): ClassDecorator {
-  return function (target) {
-    setImmediate(() => {
-      const value = isFunction(dependencies) ? dependencies() : dependencies;
-
-      for (const dependency of value) {
-        const propertyKey = validPropertyName(dependency.name);
-
-        DeclareDependencyForTestClass(
-          { constructor: target },
-          propertyKey,
-          dependency
-        );
-      }
-    });
-  };
-}
-
-/**
- * Reverse dependencies for assuring execution order
- * @param dependents a function that returns a Test class array
- */
-export function Dependents(
-  dependents: (() => ClassDefition<any>[]) | ClassDefition<any>[]
-): ClassDecorator {
-  return function (target) {
-    setImmediate(() => {
-      const value = isFunction(dependents) ? dependents() : dependents;
-
-      for (const dependent of value) {
-        const propertyKey = validPropertyName(target.name);
-
-        DeclareDependencyForTestClass(
-          { constructor: dependent },
-          propertyKey,
-          target
-        );
-      }
-    });
-  };
-}
-
-/**
- * Creates hook for test case
- * @param type Hook type
- * @param timeout Timeout of case in milliseconds
- */
-export function Hook(type: HookType, timeout: number = 5000): MethodDecorator {
-  return function (target, propertyKey) {
-    DeclareHookForTestClass(target, <string>propertyKey, type, timeout);
-  };
-}
-
-/**
- * Assigns test spec as skipped
- * @param reason Why skipped
- */
-export function Skip(reason?: string): MethodDecorator {
-  return function (target, propertyKey) {
-    DeclareAsSkipped(target, <string>propertyKey, reason ? reason : "");
-  };
-}
-
-/**
- * Assigns test spec as skipped
- * @param reason Why skipped
- */
-export function SkipClass(reason?: string): ClassDecorator {
-  return function (target) {
-    DeclareAsSkippedClass(target, reason ? reason : "");
-  };
-}
-
-function GetTestInstanceOfTarget(target: any) {
-  let instance = HashMap().get(target);
-  if (!instance) {
-    HashMap().set(target, (instance = new Test(target)));
-  }
-  return instance;
-}
-
-function DeclareDependencyForTestClass(
-  protoOfTarget: any,
-  propertyKey: string,
-  dependency: any
-) {
-  const target = protoOfTarget.constructor;
-
-  const test = GetTestInstanceOfTarget(target);
-  const depTest = GetTestInstanceOfTarget(dependency);
-
-  test.dependencies.push({ propertyKey, dependency: depTest });
-  depTest.dependents.push(test);
-}
-
-function DeclareSpecForTestClass(
-  protoOfTarget: any,
-  propertyKey: string,
-  timeout: number
-) {
-  const target = protoOfTarget.constructor;
-  const test = GetTestInstanceOfTarget(target);
-
-  if (test.hooks.has(propertyKey)) {
-    throw new Error("@Hook cannot be used with @Spec! Test: ");
-  }
-
-  if (test.specs.has(propertyKey)) {
-    throw new Error("Multiple @Spec for a single method is prohibited");
-  }
-
-  test.specs.set(propertyKey, { timeout });
-}
-
-function DeclareHookForTestClass(
-  protoOfTarget: any,
-  propertyKey: string,
-  hookType: HookType,
-  timeout: number
-) {
-  const target = protoOfTarget.constructor;
-  const test = GetTestInstanceOfTarget(target);
-
-  if (test.specs.has(propertyKey)) {
-    throw new Error("@Hook cannot be used with @Spec");
-  }
-
-  if (test.hooks.has(propertyKey)) {
-    throw new Error("Multiple @Hook for a single method is prohibited");
-  }
-
-  test.hooks.set(propertyKey, { type: hookType, timeout });
-}
-
-function DeclareAsSkipped(
-  protoOfTarget: any,
-  propertyKey: string,
-  reason: string
-) {
-  const target = protoOfTarget.constructor;
-  const test = GetTestInstanceOfTarget(target);
-
-  if (test.skip.has(propertyKey)) {
-    const obj = test.skip.get(propertyKey)!;
-
-    if (reason) {
-      obj.reason = (obj.reason ? obj.reason + ", " : "") + reason;
-    }
-  } else {
-    test.skip.set(propertyKey, { reason });
-  }
-}
-
-function DeclareAsSkippedClass(target: any, reason: string) {
-  const test = GetTestInstanceOfTarget(target);
-
-  test.skipClass = { reason };
-}
-
-function validPropertyName(name: string) {
-  return camelcase(name, {
-    preserveConsecutiveUppercase:
-      process.env.NOLE_PRESERVE_CONSECUTIVE_UPPERCASE == undefined
-        ? true
-        : process.env.NOLE_PRESERVE_CONSECUTIVE_UPPERCASE === "true",
-
-    pascalCase:
-      process.env.NOLE_PASCALCASE == undefined
-        ? false
-        : process.env.NOLE_PASCALCASE === "true",
-
-    locale: "en-US",
-  });
-}
-
-function isFunction(thing: any): thing is (...args: any[]) => void {
-  return typeof thing !== "object" && typeof thing === "function";
-}

package/src/dynamic.ts

@@ -1,11 +0,0 @@
-export function skipTest(reason?: string) {
-  throw new NoleManualSkip(reason);
-}
-
-class NoleManualSkip extends Error {
-  _nole_anchor = 1;
-
-  constructor(public reason?: string) {
-    super(`Dynamicly skipped! ${reason}`);
-  }
-}

package/src/index.ts

@@ -1,13 +0,0 @@
-export {
-  Dependency,
-  Spec,
-  Hook,
-  Skip,
-  SkipClass,
-  Dependencies,
-  Dependencies as After,
-  Dependents as Before,
-  Dependents,
-} from "./decorators.js";
-export { HookType } from "./test.js";
-export { skipTest } from "./dynamic.js";

package/src/run.ts

@@ -1,331 +0,0 @@
-import { HashMap } from "./data.js";
-import { TimeDifference } from "./utils/time_difference.js";
-import { TimeFactor } from "./utils/time_factor.js";
-import * as clrs from "colors/safe.js";
-import { Executor } from "./utils/executor.js";
-import { HookType, Test } from "./test.js";
-
-const colors = (clrs as any).default;
-
-const OK_TEXT = colors.bold(colors.green("   (ok)   "));
-const SKIP_TEXT = colors.bold(colors.yellow("  (skip)  "));
-const DYNAMIC_SKIP_TEXT = colors.bold(colors.blue(" (dskip)   "));
-const FAILED_TEXT = colors.bold(colors.red(" (failed) "));
-const HOOK_FAILED_TEXT = colors.bold(colors.red(" (hook failed) "));
-
-interface Options {
-  log: Function;
-  orderDebug: boolean;
-}
-
-export function ManualRun(options: Options) {
-  if (!options.log) {
-    options.log = console.log.bind(console);
-  }
-
-  const log = options.log;
-
-  return new Promise<void>(async (resolve, reject) => {
-    try {
-      let hashMap = new Map(HashMap());
-
-      if (!hashMap.size) {
-        log(`${FAILED_TEXT} no specs found`);
-        throw new Error("No specs found");
-      }
-
-      while (hashMap.size) {
-        let test = PickNextTestFromHashMap(hashMap);
-
-        if (test) {
-          hashMap.delete(test.target);
-          CreateInstanceIfNotExists(test);
-          HandleDependencies(test);
-
-          await HandleBeforeHooks(test, options);
-          await HandleSpecs(test, options);
-          await HandleAfterHooks(test, options);
-
-          test.isFinished = true;
-
-          if (test.dependents.length == 0) {
-            await HandleCleanUp(test, options);
-          }
-        } else {
-          DependencyLock(hashMap);
-        }
-      }
-
-      resolve();
-    } catch (e) {
-      reject(e);
-    }
-  });
-}
-
-function PickNextTestFromHashMap(hashMap: Map<any, Test>) {
-  for (let test of hashMap.values()) {
-    if (test.isFinished) continue;
-    if (!test.dependencies.every((x) => x.dependency.isFinished)) continue;
-
-    return test;
-  }
-}
-
-function CreateInstanceIfNotExists(test: Test) {
-  if (!test.testInstance) {
-    test.testInstance = new test.target();
-  }
-}
-
-function HandleDependencies(test: Test) {
-  for (let dependency of test.dependencies) {
-    test.testInstance[dependency.propertyKey] =
-      dependency.dependency.testInstance;
-  }
-}
-
-async function HandleBeforeHooks(test: Test, options: Options) {
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.Before) continue;
-
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "before" ? `.${propertyKey}:before` : ":before")
-      )
-    );
-
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
-
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
-      }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-  }
-}
-
-async function HandleBeforeEachHooks(test: Test, options: Options) {
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.BeforeEach) continue;
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "beforeEach"
-            ? `.${propertyKey}:beforeEach`
-            : ":beforeEach")
-      )
-    );
-
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
-
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
-      }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-  }
-}
-
-async function HandleAfterEachHooks(test: Test, options: Options) {
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.AfterEach) continue;
-
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "afterEach"
-            ? `.${propertyKey}:afterEach`
-            : ":afterEach")
-      )
-    );
-
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
-
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
-      }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-  }
-}
-
-async function HandleSpecs(test: Test, options: Options) {
-  const log = options.log;
-
-  for (let [propertyKey, spec] of test.specs.entries()) {
-    let testName = colors.bold(colors.yellow(test.name + "." + propertyKey));
-
-    const shouldPropertySkip = test.skip.has(propertyKey);
-    if (shouldPropertySkip || test.skipClass) {
-      let reason = shouldPropertySkip
-        ? test.skip.get(propertyKey)!.reason
-        : test.skipClass!.reason;
-      log(
-        `${SKIP_TEXT} ${" ".repeat(9)} ${testName}() ${
-          reason ? "{" + reason + "}" : ""
-        }`
-      );
-      continue;
-    }
-
-    await HandleBeforeEachHooks(test, options);
-
-    let start = TimeDifference.begin();
-
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          spec.timeout
-        );
-      }
-
-      let timeText = TimeFactor(start.end(), spec.timeout);
-
-      log(`${OK_TEXT} ${timeText} ${testName}()`);
-    } catch (e) {
-      if ((e as any)?._nole_anchor) {
-        let reason = (e as any).reason;
-        log(
-          `${DYNAMIC_SKIP_TEXT} ${" ".repeat(8)} ${testName}() ${
-            reason ? "{" + reason + "}" : ""
-          }`
-        );
-        continue;
-      }
-
-      let timeText = TimeFactor(start.end(), spec.timeout);
-
-      console.error(`${FAILED_TEXT} ${timeText} ${testName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-
-    await HandleAfterEachHooks(test, options);
-  }
-}
-
-async function HandleAfterHooks(test: Test, options: Options) {
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.After) continue;
-
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "after" ? `.${propertyKey}:after` : ":after")
-      )
-    );
-
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
-
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
-      }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-  }
-}
-
-async function HandleCleanUp(test: Test, options: Options) {
-  if (test.cleanUpCalled) return;
-  if (
-    !test.dependents.every(
-      (dependent) => dependent.isFinished && dependent.cleanUpCalled
-    )
-  )
-    return;
-
-  test.cleanUpCalled = true;
-
-  const log = options.log;
-
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.CleanUp) continue;
-
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "cleanUp" ? `.${propertyKey}:cleanUp` : ":cleanUp")
-      )
-    );
-    let start = TimeDifference.begin();
-
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      }
-
-      let timeText = TimeFactor(start.end(), hook.timeout);
-
-      log(`${OK_TEXT} ${timeText} ${hookName}()`);
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-  }
-
-  for (let tree of test.dependencies) {
-    await HandleCleanUp(tree.dependency, options);
-  }
-}
-
-function DependencyLock(hashMap: Map<any, Test>) {
-  console.error(
-    FAILED_TEXT +
-      colors.red("Looks like there is confict issue for dependency resolving!")
-  );
-
-  console.error("Possible conflicts;");
-  for (let test of hashMap.values()) {
-    console.error(
-      `- class ${test.name} { ${test.dependencies
-        .filter((x) => !x.dependency.isFinished)
-        .map((x) => `@Dependency(${x.dependency.name}) ${x.propertyKey}`)
-        .join(", ")} }`
-    );
-  }
-
-  throw new Error("Dependency lock occurred!");
-}

package/src/test.ts

@@ -1,47 +0,0 @@
-export interface IDependency {
-  propertyKey: string;
-  dependency: Test;
-}
-
-export interface ISpec {
-  timeout: number;
-}
-
-export interface IHook {
-  type: HookType;
-  timeout: number;
-}
-
-export interface ISkip {
-  reason: string;
-}
-
-export class Test {
-  dependencies: IDependency[] = [];
-  dependents: Test[] = [];
-  skip = new Map<string, ISkip>();
-  skipClass: ISkip | null = null;
-  specs = new Map<string, ISpec>();
-  hooks = new Map<string, IHook>();
-  isFinished: boolean = false; // cleanup ignored
-  cleanUpCalled: boolean = false;
-  testInstance: any;
-
-  constructor(public target: any) {}
-
-  get name() {
-    return this.target.name;
-  }
-}
-
-export enum HookType {
-  Before, // Trigger when test case is ready to handle
-  After, // Trigger when test case did all the specs
-  BeforeEach, // Trigger before each spec
-  AfterEach, // Trigger after each spec
-  CleanUp, // Trigger after all dependents tested (You can safely remove connections etc.)
-}
-
-export interface ClassDefition<T> {
-  new (): T;
-}

package/src/utils/executor.test.ts

@@ -1,27 +0,0 @@
-import * as assert from "assert";
-import { Spec } from "../index.js";
-import { Executor } from "./executor.js";
-
-export class ExecutorTest {
-  @Spec()
-  async evaluate() {
-    await Executor(() => 1, 1);
-    await Executor(async () => 1, 1);
-  }
-
-  @Spec()
-  async throws() {
-    await assert.rejects(() => {
-      return Executor(() => {
-        throw new Error("throws");
-      }, 1);
-    });
-  }
-
-  @Spec()
-  async timeout() {
-    await assert.rejects(() => {
-      return Executor(() => new Promise(() => {}), 10);
-    });
-  }
-}

package/src/utils/executor.ts

@@ -1,22 +0,0 @@
-export function Executor(fn: Function, timeout: number): Promise<void> {
-  return new Promise(async (resolve, reject) => {
-    let _timeout = null;
-
-    try {
-      let expectPromise = fn();
-      if (expectPromise && expectPromise.then) {
-        _timeout = setTimeout(function () {
-          reject(new Error("Timeout occurred! value: " + timeout));
-        }, timeout);
-
-        await expectPromise;
-      }
-    } catch (e) {
-      reject(e);
-    }
-
-    clearTimeout(_timeout!);
-
-    resolve();
-  });
-}

package/src/utils/time_difference.test.ts

@@ -1,12 +0,0 @@
-import * as assert from "assert";
-import { Spec } from "../index.js";
-import { Executor } from "./executor.js";
-import { TimeDifference } from "./time_difference.js";
-
-export class TimeDifferenceTest {
-  @Spec()
-  async evaluate() {
-    const td = TimeDifference.begin();
-    td.end();
-  }
-}

package/src/utils/time_difference.ts

@@ -1,26 +0,0 @@
-/**
- * Calculates the time difference in nanoseconds
- */
-export class TimeDifference {
-  private startAt: [number, number];
-
-  private constructor() {
-    this.startAt = process.hrtime();
-  }
-
-  /**
-   * Creates the instance at the begining
-   */
-  public static begin() {
-    return new TimeDifference();
-  }
-
-  /**
-   * Finishes the time, returns data in milliseconds
-   */
-  end(): number {
-    let diff = process.hrtime(this.startAt);
-
-    return diff[0] * 1000 + diff[1] / 1e6;
-  }
-}