nole 2.2.1 → 3.0.0

package/src/run.ts

@@ -1,331 +1,259 @@
-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;
-}
+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;
+    }
 
-export function ManualRun(options: Options) {
-  if (!options.log) {
-    options.log = console.log.bind(console);
+    const wrap = new TestWrap(test);
+
+    allTests.set(test, wrap);
+    notTestedYet.set(test, wrap);
   }
 
-  const log = options.log;
+  extractInformationFromClasses(notTestedYet);
 
-  return new Promise<void>(async (resolve, reject) => {
-    try {
-      let hashMap = new Map(HashMap());
+  if (!notTestedYet.size) {
+    throw new Error("No specs found");
+  }
 
-      if (!hashMap.size) {
-        log(`${FAILED_TEXT} no specs found`);
-        throw new Error("No specs found");
-      }
+  while (notTestedYet.size) {
+    let entry = pickNext(notTestedYet);
 
-      while (hashMap.size) {
-        let test = PickNextTestFromHashMap(hashMap);
+    if (entry) {
+      let test = entry[1];
+      // console.log(colors.bold(colors.cyan(`Running test: ${test.name}`)));
 
-        if (test) {
-          hashMap.delete(test.target);
-          CreateInstanceIfNotExists(test);
-          HandleDependencies(test);
+      notTestedYet.delete(test.target);
+      createInstanceIfNotExists(test);
+      handleDependencies(test);
 
-          await HandleBeforeHooks(test, options);
-          await HandleSpecs(test, options);
-          await HandleAfterHooks(test, options);
+      await handleBeforeHooks(test);
+      await handleSpecs(test);
+      await handleAfterHooks(test);
 
-          test.isFinished = true;
+      test.isFinished = true;
 
-          if (test.dependents.length == 0) {
-            await HandleCleanUp(test, options);
-          }
-        } else {
-          DependencyLock(hashMap);
-        }
+      if (test.dependents.length == 0) {
+        await handleCleanUp(test);
       }
-
-      resolve();
-    } catch (e) {
-      reject(e);
+    } else {
+      dependencyLock(notTestedYet);
     }
-  });
-}
-
-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 extractInformationFromClasses(
+  tests: Map<new () => BaseTest, TestWrap>,
+) {
+  for (let [target, test] of tests.entries()) {
+    updateInformationForClass(target, test, tests);
   }
 }
 
-function HandleDependencies(test: Test) {
-  for (let dependency of test.dependencies) {
-    test.testInstance[dependency.propertyKey] =
-      dependency.dependency.testInstance;
+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 };
   }
-}
 
-async function HandleBeforeHooks(test: Test, options: Options) {
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.Before) continue;
+  test.dependencies = config.dependencies
+    ? Array.from(
+        config.dependencies.entries().map(([key, dep]) => {
+          const actual = dep();
+          let testWrap = tests.get(actual);
 
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "before" ? `.${propertyKey}:before` : ":before")
+          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();
 
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
+    for (let i = 0; i < beforeTests.length; i++) {
+      const actual = beforeTests[i];
 
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
+      let testWrap = tests.get(actual);
+
+      if (!testWrap) {
+        testWrap = new TestWrap(actual);
+        tests.set(actual, testWrap);
+        allTests.set(actual, testWrap);
       }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
+
+      testWrap.dependencies.push({
+        propertyKey: "_before_" + i,
+        dependency: test,
+      });
+
+      test.dependents.push(testWrap);
     }
   }
-}
 
-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")
-      )
-    );
+  if (config.after) {
+    const afterTests = config.after();
+
+    for (let i = 0; i < afterTests.length; i++) {
+      const actual = afterTests[i];
 
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
+      let testWrap = tests.get(actual);
 
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
+      if (!testWrap) {
+        testWrap = new TestWrap(actual);
+        tests.set(actual, testWrap);
+        allTests.set(actual, testWrap);
       }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
+
+      test.dependencies.push({
+        propertyKey: "_after_" + i,
+        dependency: testWrap,
+      });
+
+      testWrap.dependents.push(test);
     }
   }
 }
 
-async function HandleAfterEachHooks(test: Test, options: Options) {
-  for (let [propertyKey, hook] of test.hooks.entries()) {
-    if (hook.type != HookType.AfterEach) continue;
+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;
 
-    let hookName = colors.bold(
-      colors.yellow(
-        test.name +
-          (propertyKey != "afterEach"
-            ? `.${propertyKey}:afterEach`
-            : ":afterEach")
-      )
-    );
+    return entry;
+  }
+}
 
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          hook.timeout
-        );
-      } else {
-        let timeText = TimeFactor(0, hook.timeout);
+export function createInstanceIfNotExists(test: TestWrap) {
+  if (!test.testInstance) {
+    const instance = new test.target();
 
-        options.log(`${OK_TEXT} ${timeText} ${hookName}()`);
-      }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
+    test.testInstance = instance;
+  }
+
+  if (!test.specDetection) {
+    specDetection(test);
+    test.specDetection = true;
   }
 }
 
-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 + "}" : ""
-        }`
-      );
+function specDetection(test: TestWrap) {
+  const instance = test.testInstance;
+  for (let key of getAllMethods(instance)) {
+    if (typeof key !== "string") {
       continue;
     }
 
-    await HandleBeforeEachHooks(test, options);
-
-    let start = TimeDifference.begin();
+    let lowerKey = key.toLowerCase();
 
-    try {
-      if (!options.orderDebug) {
-        await Executor(
-          test.testInstance[propertyKey].bind(test.testInstance),
-          spec.timeout
-        );
-      }
+    if (lowerKey.startsWith("skip")) {
+      test.skip.set(key, { reason: "marked as skipped" });
+    }
 
-      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;
+    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;
       }
 
-      let timeText = TimeFactor(start.end(), spec.timeout);
-
-      console.error(`${FAILED_TEXT} ${timeText} ${testName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
+      test.hooks.set(key, { type });
+      continue;
     }
 
-    await HandleAfterEachHooks(test, options);
+    test.specs.set(key, {});
   }
 }
 
-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")
-      )
-    );
+function getAllMethods(instance) {
+  let props = new Set();
+  let currentObj = instance;
 
-    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}()`);
+  while (currentObj && currentObj !== Object.prototype) {
+    Object.getOwnPropertyNames(currentObj).forEach((prop) => {
+      if (typeof currentObj[prop] === "function" && prop !== "constructor") {
+        props.add(prop);
       }
-    } catch (e) {
-      console.error(`${HOOK_FAILED_TEXT} ${hookName}()`);
-      console.error((e as any)?.stack ?? e);
-      throw e;
-    }
+    });
+    currentObj = Object.getPrototypeOf(currentObj);
   }
-}
-
-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;
-    }
-  }
+  return Array.from(props);
+}
 
-  for (let tree of test.dependencies) {
-    await HandleCleanUp(tree.dependency, options);
+function handleDependencies(test: TestWrap) {
+  for (let dependency of test.dependencies) {
+    test.testInstance[dependency.propertyKey] =
+      dependency.dependency.testInstance;
   }
 }
 
-function DependencyLock(hashMap: Map<any, Test>) {
+function dependencyLock(tests: Map<new () => BaseTest, TestWrap>) {
   console.error(
     FAILED_TEXT +
-      colors.red("Looks like there is confict issue for dependency resolving!")
+      colors.red("Looks like there is confict issue for dependency resolving!"),
   );
 
   console.error("Possible conflicts;");
-  for (let test of hashMap.values()) {
+  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(", ")} }`
+        .join(", ")} }`,
     );
   }
 
   throw new Error("Dependency lock occurred!");
 }
+
+export function getTestMap() {
+  return allTests;
+}
+
+export function getFutureTestMap() {
+  return notTestedYet;
+}

package/src/symbol.ts

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

package/src/{test.ts → test-wrap.ts}

@@ -1,24 +1,25 @@
+import { BaseTest, type TestClassInfo } from "./core.js";
+import { TEST_CLASS_KEY } from "./symbol.js";
+
 export interface IDependency {
   propertyKey: string;
-  dependency: Test;
+  dependency: TestWrap;
 }
 
-export interface ISpec {
-  timeout: number;
-}
+export interface ISpec {}
 
 export interface IHook {
   type: HookType;
-  timeout: number;
 }
 
 export interface ISkip {
   reason: string;
 }
 
-export class Test {
+// Old code, but works fine, so I won't change it for now
+export class TestWrap {
   dependencies: IDependency[] = [];
-  dependents: Test[] = [];
+  dependents: TestWrap[] = [];
   skip = new Map<string, ISkip>();
   skipClass: ISkip | null = null;
   specs = new Map<string, ISpec>();
@@ -26,8 +27,12 @@ export class Test {
   isFinished: boolean = false; // cleanup ignored
   cleanUpCalled: boolean = false;
   testInstance: any;
+  specDetection: boolean = false;
+  config: TestClassInfo;
 
-  constructor(public target: any) {}
+  constructor(public target: new () => BaseTest) {
+    this.config = target[TEST_CLASS_KEY];
+  }
 
   get name() {
     return this.target.name;
@@ -41,7 +46,3 @@ export enum HookType {
   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,15 +1,13 @@
 import * as assert from "assert";
-import { Spec } from "../index.js";
 import { Executor } from "./executor.js";
+import { Test } from "../index.js";
 
-export class ExecutorTest {
-  @Spec()
+export class ExecutorTest extends Test() {
   async evaluate() {
     await Executor(() => 1, 1);
     await Executor(async () => 1, 1);
   }
 
-  @Spec()
   async throws() {
     await assert.rejects(() => {
       return Executor(() => {
@@ -18,7 +16,6 @@ export class ExecutorTest {
     });
   }
 
-  @Spec()
   async timeout() {
     await assert.rejects(() => {
       return Executor(() => new Promise(() => {}), 10);

package/src/utils/executor.ts

@@ -1,6 +1,6 @@
 export function Executor(fn: Function, timeout: number): Promise<void> {
   return new Promise(async (resolve, reject) => {
-    let _timeout = null;
+    let _timeout: NodeJS.Timeout | null = null;
 
     try {
       let expectPromise = fn();

package/src/utils/time_difference.test.ts

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

package/src/utils/time_factor.test.ts

@@ -1,8 +1,7 @@
-import { Spec } from "../index.js";
+import { Test } from "../index.js";
 import { Delay, TimeFactor } from "./time_factor.js";
 
-export class TimeFactorTest {
-  @Spec()
+export class TimeFactorTest extends Test() {
   async evaluate() {
     await Delay(1);
 

package/src/utils/time_factor.ts

@@ -1,6 +1,4 @@
-import * as clrs from "colors/safe.js";
-
-const colors = (clrs as any).default;
+import { colors } from "../const.js";
 
 export function TimeFactor(diff: number, timeout: number) {
   if (diff < timeout / 5) {

package/test/basic.test.ts

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