nole 3.0.0 → 3.1.0

package/src/handle/cleanup-hooks.ts

@@ -1,55 +0,0 @@
-import { HookType, TestWrap } from "../test-wrap.js";
-import { Executor } from "../utils/executor.js";
-import { TimeDifference } from "../utils/time_difference.js";
-import { TimeFactor } from "../utils/time_factor.js";
-import {
-  colors,
-  DEFAULT_TIMEOUT,
-  HOOK_FAILED_TEXT,
-  OK_TEXT,
-} from "../const.js";
-
-export async function handleCleanUp(test: TestWrap) {
-  const timeout = test.config.timeout ?? DEFAULT_TIMEOUT;
-
-  if (test.cleanUpCalled) return;
-  if (
-    !test.dependents.every(
-      (dependent) => dependent.isFinished && dependent.cleanUpCalled,
-    )
-  )
-    return;
-
-  test.cleanUpCalled = true;
-
-  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 {
-      await Executor(
-        test.testInstance[propertyKey].bind(test.testInstance),
-        timeout,
-      );
-
-      let timeText = TimeFactor(start.end(), timeout);
-
-      console.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);
-  }
-}

package/src/handle/specs.ts

@@ -1,68 +0,0 @@
-import { HookType, TestWrap } from "../test-wrap.js";
-import { Executor } from "../utils/executor.js";
-import { TimeDifference } from "../utils/time_difference.js";
-import { TimeFactor } from "../utils/time_factor.js";
-import { handleAfterEachHooks } from "./after-each-hooks.js";
-import { handleBeforeEachHooks } from "./before-each-hooks.js";
-import {
-  colors,
-  DEFAULT_TIMEOUT,
-  DYNAMIC_SKIP_TEXT,
-  FAILED_TEXT,
-  OK_TEXT,
-  SKIP_TEXT,
-} from "../const.js";
-
-export async function handleSpecs(test: TestWrap) {
-  const timeout = test.config.timeout ?? DEFAULT_TIMEOUT;
-
-  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;
-      console.log(
-        `${SKIP_TEXT} ${" ".repeat(9)} ${testName}() ${
-          reason ? "{" + reason + "}" : ""
-        }`,
-      );
-      continue;
-    }
-
-    await handleBeforeEachHooks(test);
-
-    let start = TimeDifference.begin();
-
-    try {
-      await Executor(
-        test.testInstance[propertyKey].bind(test.testInstance),
-        timeout,
-      );
-
-      let timeText = TimeFactor(start.end(), timeout);
-
-      console.log(`${OK_TEXT} ${timeText} ${testName}()`);
-    } catch (e) {
-      if ((e as any)?._nole_anchor) {
-        let reason = (e as any).reason;
-        console.log(
-          `${DYNAMIC_SKIP_TEXT} ${" ".repeat(8)} ${testName}() ${
-            reason ? "{" + reason + "}" : ""
-          }`,
-        );
-        continue;
-      }
-
-      let timeText = TimeFactor(start.end(), timeout);
-
-      console.error(`${FAILED_TEXT} ${timeText} ${testName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
-
-    await handleAfterEachHooks(test);
-  }
-}

package/src/index.ts

@@ -1,3 +0,0 @@
-export { HookType } from "./test-wrap.js";
-export { Test } from "./core.js";
-export { skipTest, getTest, addTest } from "./dynamic.js";

package/src/run.ts

@@ -1,259 +0,0 @@
-import { HookType, TestWrap } from "./test-wrap.js";
-import { BaseTest, type TestClassInfo } from "./core.js";
-import { TEST_CLASS_KEY } from "./symbol.js";
-import { handleBeforeHooks } from "./handle/before-hooks.js";
-import { handleSpecs } from "./handle/specs.js";
-import { handleAfterHooks } from "./handle/after-hooks.js";
-import { handleCleanUp } from "./handle/cleanup-hooks.js";
-import { colors, FAILED_TEXT } from "./const.js";
-
-let allTests: Map<new () => BaseTest, TestWrap> = new Map();
-let notTestedYet: Map<new () => BaseTest, TestWrap> = new Map();
-
-export async function ManualRun(originalTests: Set<new () => BaseTest>) {
-  for (let test of originalTests) {
-    if (allTests.has(test)) {
-      continue;
-    }
-
-    const wrap = new TestWrap(test);
-
-    allTests.set(test, wrap);
-    notTestedYet.set(test, wrap);
-  }
-
-  extractInformationFromClasses(notTestedYet);
-
-  if (!notTestedYet.size) {
-    throw new Error("No specs found");
-  }
-
-  while (notTestedYet.size) {
-    let entry = pickNext(notTestedYet);
-
-    if (entry) {
-      let test = entry[1];
-      // console.log(colors.bold(colors.cyan(`Running test: ${test.name}`)));
-
-      notTestedYet.delete(test.target);
-      createInstanceIfNotExists(test);
-      handleDependencies(test);
-
-      await handleBeforeHooks(test);
-      await handleSpecs(test);
-      await handleAfterHooks(test);
-
-      test.isFinished = true;
-
-      if (test.dependents.length == 0) {
-        await handleCleanUp(test);
-      }
-    } else {
-      dependencyLock(notTestedYet);
-    }
-  }
-}
-
-function extractInformationFromClasses(
-  tests: Map<new () => BaseTest, TestWrap>,
-) {
-  for (let [target, test] of tests.entries()) {
-    updateInformationForClass(target, test, tests);
-  }
-}
-
-export function updateInformationForClass(
-  target: new () => BaseTest,
-  test: TestWrap,
-  tests: Map<new () => BaseTest, TestWrap>,
-) {
-  const config = target[TEST_CLASS_KEY] as TestClassInfo;
-
-  if (config.skip) {
-    test.skipClass = { reason: config.skip };
-  }
-
-  test.dependencies = config.dependencies
-    ? Array.from(
-        config.dependencies.entries().map(([key, dep]) => {
-          const actual = dep();
-          let testWrap = tests.get(actual);
-
-          if (!testWrap) {
-            testWrap = new TestWrap(actual);
-            tests.set(actual, testWrap);
-            allTests.set(actual, testWrap);
-          }
-
-          testWrap.dependents.push(test);
-
-          return {
-            propertyKey: key,
-            dependency: testWrap,
-          };
-        }),
-      )
-    : [];
-
-  if (config.before) {
-    const beforeTests = config.before();
-
-    for (let i = 0; i < beforeTests.length; i++) {
-      const actual = beforeTests[i];
-
-      let testWrap = tests.get(actual);
-
-      if (!testWrap) {
-        testWrap = new TestWrap(actual);
-        tests.set(actual, testWrap);
-        allTests.set(actual, testWrap);
-      }
-
-      testWrap.dependencies.push({
-        propertyKey: "_before_" + i,
-        dependency: test,
-      });
-
-      test.dependents.push(testWrap);
-    }
-  }
-
-  if (config.after) {
-    const afterTests = config.after();
-
-    for (let i = 0; i < afterTests.length; i++) {
-      const actual = afterTests[i];
-
-      let testWrap = tests.get(actual);
-
-      if (!testWrap) {
-        testWrap = new TestWrap(actual);
-        tests.set(actual, testWrap);
-        allTests.set(actual, testWrap);
-      }
-
-      test.dependencies.push({
-        propertyKey: "_after_" + i,
-        dependency: testWrap,
-      });
-
-      testWrap.dependents.push(test);
-    }
-  }
-}
-
-function pickNext(tests: Map<new () => BaseTest, TestWrap>) {
-  for (let entry of tests.entries()) {
-    let test = entry[1];
-    if (test.isFinished) continue;
-    if (!test.dependencies.every((x) => x.dependency.isFinished)) continue;
-
-    return entry;
-  }
-}
-
-export function createInstanceIfNotExists(test: TestWrap) {
-  if (!test.testInstance) {
-    const instance = new test.target();
-
-    test.testInstance = instance;
-  }
-
-  if (!test.specDetection) {
-    specDetection(test);
-    test.specDetection = true;
-  }
-}
-
-function specDetection(test: TestWrap) {
-  const instance = test.testInstance;
-  for (let key of getAllMethods(instance)) {
-    if (typeof key !== "string") {
-      continue;
-    }
-
-    let lowerKey = key.toLowerCase();
-
-    if (lowerKey.startsWith("skip")) {
-      test.skip.set(key, { reason: "marked as skipped" });
-    }
-
-    if (
-      lowerKey.startsWith("hook") ||
-      lowerKey === "cleanup" ||
-      lowerKey === "before" ||
-      lowerKey === "after" ||
-      lowerKey === "beforeeach" ||
-      lowerKey === "aftereach"
-    ) {
-      let type = HookType.Before;
-
-      if (lowerKey.endsWith("before")) {
-        type = HookType.Before;
-      } else if (lowerKey.endsWith("after")) {
-        type = HookType.After;
-      } else if (lowerKey.endsWith("beforeeach")) {
-        type = HookType.BeforeEach;
-      } else if (lowerKey.endsWith("aftereach")) {
-        type = HookType.AfterEach;
-      } else if (lowerKey.endsWith("cleanup")) {
-        type = HookType.CleanUp;
-      }
-
-      test.hooks.set(key, { type });
-      continue;
-    }
-
-    test.specs.set(key, {});
-  }
-}
-
-function getAllMethods(instance) {
-  let props = new Set();
-  let currentObj = instance;
-
-  while (currentObj && currentObj !== Object.prototype) {
-    Object.getOwnPropertyNames(currentObj).forEach((prop) => {
-      if (typeof currentObj[prop] === "function" && prop !== "constructor") {
-        props.add(prop);
-      }
-    });
-    currentObj = Object.getPrototypeOf(currentObj);
-  }
-
-  return Array.from(props);
-}
-
-function handleDependencies(test: TestWrap) {
-  for (let dependency of test.dependencies) {
-    test.testInstance[dependency.propertyKey] =
-      dependency.dependency.testInstance;
-  }
-}
-
-function dependencyLock(tests: Map<new () => BaseTest, TestWrap>) {
-  console.error(
-    FAILED_TEXT +
-      colors.red("Looks like there is confict issue for dependency resolving!"),
-  );
-
-  console.error("Possible conflicts;");
-  for (let [, test] of tests) {
-    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!");
-}
-
-export function getTestMap() {
-  return allTests;
-}
-
-export function getFutureTestMap() {
-  return notTestedYet;
-}

package/src/symbol.ts

@@ -1 +0,0 @@
-export const TEST_CLASS_KEY = Symbol("TEST_CLASS_KEY");

package/src/test-wrap.ts

@@ -1,48 +0,0 @@
-import { BaseTest, type TestClassInfo } from "./core.js";
-import { TEST_CLASS_KEY } from "./symbol.js";
-
-export interface IDependency {
-  propertyKey: string;
-  dependency: TestWrap;
-}
-
-export interface ISpec {}
-
-export interface IHook {
-  type: HookType;
-}
-
-export interface ISkip {
-  reason: string;
-}
-
-// Old code, but works fine, so I won't change it for now
-export class TestWrap {
-  dependencies: IDependency[] = [];
-  dependents: TestWrap[] = [];
-  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;
-  specDetection: boolean = false;
-  config: TestClassInfo;
-
-  constructor(public target: new () => BaseTest) {
-    this.config = target[TEST_CLASS_KEY];
-  }
-
-  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.)
-}

package/src/utils/executor.test.ts

@@ -1,24 +0,0 @@
-import * as assert from "assert";
-import { Executor } from "./executor.js";
-import { Test } from "../index.js";
-
-export class ExecutorTest extends Test() {
-  async evaluate() {
-    await Executor(() => 1, 1);
-    await Executor(async () => 1, 1);
-  }
-
-  async throws() {
-    await assert.rejects(() => {
-      return Executor(() => {
-        throw new Error("throws");
-      }, 1);
-    });
-  }
-
-  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: NodeJS.Timeout | null = 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,11 +0,0 @@
-import * as assert from "assert";
-import { Test } from "../index.js";
-import { Executor } from "./executor.js";
-import { TimeDifference } from "./time_difference.js";
-
-export class TimeDifferenceTest extends Test() {
-  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;
-  }
-}

package/src/utils/time_factor.test.ts

@@ -1,28 +0,0 @@
-import { Test } from "../index.js";
-import { Delay, TimeFactor } from "./time_factor.js";
-
-export class TimeFactorTest extends Test() {
-  async evaluate() {
-    await Delay(1);
-
-    for (const n of [
-      100,
-      1000,
-      60 * 1000,
-      120 * 1000,
-      60 * 60 * 1000,
-      65 * 60 * 1000,
-      25 * 60 * 60 * 1000,
-    ]) {
-      TimeFactor(n / 1000, n);
-      TimeFactor(n / 500, n);
-      TimeFactor(n / 10, n);
-      TimeFactor(n / 6, n);
-      TimeFactor(n / 4, n);
-      TimeFactor(n / 2, n);
-      TimeFactor(n / 1.5, n);
-      TimeFactor(n, n);
-      TimeFactor(n * 2, n);
-    }
-  }
-}

package/src/utils/time_factor.ts

@@ -1,33 +0,0 @@
-import { colors } from "../const.js";
-
-export function TimeFactor(diff: number, timeout: number) {
-  if (diff < timeout / 5) {
-    return colors.green(TimeResolve(diff).padStart(9, " "));
-  }
-
-  if (diff < timeout / 2) {
-    return colors.yellow(TimeResolve(diff).padStart(9, " "));
-  }
-
-  return colors.red(TimeResolve(diff).padStart(9, " "));
-}
-
-export function TimeResolve(ms: number) {
-  if (ms < 1000) {
-    return ((ms * 100) | 0) / 100 + " ms";
-  }
-
-  if (ms < 60 * 1000) {
-    return ((ms / 10) | 0) / 100 + " s";
-  }
-
-  if (ms < 60 * 60 * 1000) {
-    return ((ms / 600) | 0) / 100 + " m";
-  }
-
-  return ((ms / 36000) | 0) / 100 + " h";
-}
-
-export function Delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/test/basic.test.ts

@@ -1,23 +0,0 @@
-import { Test } from "../dist/index.js";
-
-class BasicTest extends Test({ timeout: 750 }) {
-  variable = 1;
-
-  async checkEqual() {
-    await new Promise((resolve) => {
-      setTimeout(resolve, 500);
-    });
-  }
-}
-
-export class DependencyTest extends Test({
-  dependencies: {
-    basicTest: () => BasicTest,
-  },
-}) {
-  async check() {
-    if (this.basicTest.variable !== 1) {
-      throw new Error("Dependency test failed!");
-    }
-  }
-}

package/test/before.test.ts

@@ -1,41 +0,0 @@
-import { strict as assert } from "assert";
-
-import { Test } from "../dist/core.js";
-import { getTest } from "../dist/index.js";
-
-export class AlwaysExecuteLater extends Test({
-  after: () => [AlwaysExecuteFirst],
-}) {
-  test() {
-    const alwaysExecuteFirst = getTest(() => AlwaysExecuteFirst);
-    assert(alwaysExecuteFirst.value === 1);
-  }
-}
-export class AlwaysExecuteFirst extends Test() {
-  value = 0;
-
-  test() {
-    this.value = 1;
-  }
-}
-
-export class AlwaysExecuteLater2 extends Test({}) {
-  test() {
-    const alwaysExecuteFirst2 = getTest(() => AlwaysExecuteFirst2);
-    assert(alwaysExecuteFirst2.value === 1);
-  }
-
-  cleanUp() {}
-}
-
-export class AlwaysExecuteFirst2 extends Test({
-  before: () => [AlwaysExecuteLater2],
-}) {
-  value = 0;
-
-  test() {
-    this.value = 1;
-  }
-
-  cleanUp() {}
-}

package/test/clean-up.test.ts

@@ -1,48 +0,0 @@
-import { Test } from "../dist/index";
-
-export class CleanUpLayer1Test extends Test() {
-  data: any;
-
-  async start() {
-    this.data = { somethingImportant: 1 };
-  }
-
-  async cleanUp() {
-    this.data = null;
-    console.log("layer 1 clean up completed!");
-  }
-}
-
-export class CleanUpLayer2Test extends Test({
-  dependencies: {
-    previousLayer: () => CleanUpLayer1Test,
-  },
-}) {
-  data: any;
-
-  async start() {
-    this.data = { somethingImportant: 1 };
-  }
-
-  async cleanUp() {
-    this.data = null;
-    console.log("layer 2 clean up completed!");
-  }
-}
-
-export class CleanUpLayer3Test extends Test({
-  dependencies: {
-    previousLayer: () => CleanUpLayer2Test,
-  },
-}) {
-  data: any;
-
-  async start() {
-    this.data = { somethingImportant: 1 };
-  }
-
-  async cleanUp() {
-    this.data = null;
-    console.log("layer 3 clean up completed!");
-  }
-}