nole 2.1.2 → 2.2.1

package/src/run.ts

@@ -1,21 +1,21 @@
 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 * 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) '));
+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
+  log: Function;
+  orderDebug: boolean;
 }
 
 export function ManualRun(options: Options) {
@@ -31,7 +31,7 @@ export function ManualRun(options: Options) {
 
       if (!hashMap.size) {
         log(`${FAILED_TEXT} no specs found`);
-        throw new Error('No specs found');
+        throw new Error("No specs found");
       }
 
       while (hashMap.size) {
@@ -66,7 +66,7 @@ export function ManualRun(options: Options) {
 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;
+    if (!test.dependencies.every((x) => x.dependency.isFinished)) continue;
 
     return test;
   }
@@ -74,13 +74,14 @@ function PickNextTestFromHashMap(hashMap: Map<any, Test>) {
 
 function CreateInstanceIfNotExists(test: Test) {
   if (!test.testInstance) {
-    test.testInstance = new (test.target);
+    test.testInstance = new test.target();
   }
 }
 
 function HandleDependencies(test: Test) {
   for (let dependency of test.dependencies) {
-    test.testInstance[dependency.propertyKey] = dependency.dependency.testInstance;
+    test.testInstance[dependency.propertyKey] =
+      dependency.dependency.testInstance;
   }
 }
 
@@ -88,17 +89,24 @@ 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')));
+    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);
+        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);
@@ -110,19 +118,27 @@ async function HandleBeforeHooks(test: Test, options: Options) {
 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')));
-    
+    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);
+        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;
@@ -133,18 +149,27 @@ async function HandleBeforeEachHooks(test: Test, options: Options) {
 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')));
+
+    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);
+        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);
@@ -157,12 +182,18 @@ 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));
+    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 + '}' : ''}`);
+      let reason = shouldPropertySkip
+        ? test.skip.get(propertyKey)!.reason
+        : test.skipClass!.reason;
+      log(
+        `${SKIP_TEXT} ${" ".repeat(9)} ${testName}() ${
+          reason ? "{" + reason + "}" : ""
+        }`
+      );
       continue;
     }
 
@@ -172,7 +203,10 @@ async function HandleSpecs(test: Test, options: Options) {
 
     try {
       if (!options.orderDebug) {
-        await Executor(test.testInstance[propertyKey].bind(test.testInstance), spec.timeout);
+        await Executor(
+          test.testInstance[propertyKey].bind(test.testInstance),
+          spec.timeout
+        );
       }
 
       let timeText = TimeFactor(start.end(), spec.timeout);
@@ -181,7 +215,11 @@ async function HandleSpecs(test: Test, options: Options) {
     } catch (e) {
       if ((e as any)?._nole_anchor) {
         let reason = (e as any).reason;
-        log(`${DYNAMIC_SKIP_TEXT} ${' '.repeat(8)} ${testName}() ${reason ? '{' + reason + '}' : ''}`);
+        log(
+          `${DYNAMIC_SKIP_TEXT} ${" ".repeat(8)} ${testName}() ${
+            reason ? "{" + reason + "}" : ""
+          }`
+        );
         continue;
       }
 
@@ -200,17 +238,24 @@ 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')));
+    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);
+        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);
@@ -219,10 +264,14 @@ async function HandleAfterHooks(test: Test, options: Options) {
   }
 }
 
-
 async function HandleCleanUp(test: Test, options: Options) {
   if (test.cleanUpCalled) return;
-  if (!test.dependents.every(dependent => dependent.isFinished && dependent.cleanUpCalled)) return;
+  if (
+    !test.dependents.every(
+      (dependent) => dependent.isFinished && dependent.cleanUpCalled
+    )
+  )
+    return;
 
   test.cleanUpCalled = true;
 
@@ -231,12 +280,20 @@ async function HandleCleanUp(test: Test, options: Options) {
   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 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);
+        await Executor(
+          test.testInstance[propertyKey].bind(test.testInstance),
+          hook.timeout
+        );
       }
 
       let timeText = TimeFactor(start.end(), hook.timeout);
@@ -255,13 +312,20 @@ async function HandleCleanUp(test: Test, options: Options) {
 }
 
 function DependencyLock(hashMap: Map<any, Test>) {
-  console.error(FAILED_TEXT + colors.red('Looks like there is confict issue for dependency resolving!'));
+  console.error(
+    FAILED_TEXT +
+      colors.red("Looks like there is confict issue for dependency resolving!")
+  );
 
-  console.error('Possible conflicts;');
+  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(', ')} }`);
+    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!');
-}
+  throw new Error("Dependency lock occurred!");
+}

package/src/test.ts

@@ -1,19 +1,19 @@
 export interface IDependency {
-  propertyKey: string
-  dependency: Test
+  propertyKey: string;
+  dependency: Test;
 }
 
 export interface ISpec {
-  timeout: number
+  timeout: number;
 }
 
 export interface IHook {
-  type: HookType
-  timeout: number
+  type: HookType;
+  timeout: number;
 }
 
 export interface ISkip {
-  reason: string
+  reason: string;
 }
 
 export class Test {
@@ -39,7 +39,9 @@ export enum HookType {
   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.)
+  CleanUp, // Trigger after all dependents tested (You can safely remove connections etc.)
 }
 
-export interface ClassDefition<T> { new(): T; }
+export interface ClassDefition<T> {
+  new (): T;
+}

package/src/utils/executor.test.ts

@@ -13,15 +13,15 @@ export class ExecutorTest {
   async throws() {
     await assert.rejects(() => {
       return Executor(() => {
-        throw new Error('throws');
+        throw new Error("throws");
       }, 1);
-    })
+    });
   }
 
   @Spec()
   async timeout() {
     await assert.rejects(() => {
       return Executor(() => new Promise(() => {}), 10);
-    })
+    });
   }
 }

package/src/utils/executor.ts

@@ -6,7 +6,7 @@ export function Executor(fn: Function, timeout: number): Promise<void> {
       let expectPromise = fn();
       if (expectPromise && expectPromise.then) {
         _timeout = setTimeout(function () {
-          reject(new Error('Timeout occurred! value: ' + timeout));
+          reject(new Error("Timeout occurred! value: " + timeout));
         }, timeout);
 
         await expectPromise;
@@ -19,4 +19,4 @@ export function Executor(fn: Function, timeout: number): Promise<void> {
 
     resolve();
   });
-}
+}

package/src/utils/time_difference.test.ts

@@ -7,6 +7,6 @@ export class TimeDifferenceTest {
   @Spec()
   async evaluate() {
     const td = TimeDifference.begin();
-    td.end()
+    td.end();
   }
 }

package/src/utils/time_difference.ts

@@ -8,7 +8,6 @@ export class TimeDifference {
     this.startAt = process.hrtime();
   }
 
-
   /**
    * Creates the instance at the begining
    */
@@ -16,7 +15,6 @@ export class TimeDifference {
     return new TimeDifference();
   }
 
-
   /**
    * Finishes the time, returns data in milliseconds
    */
@@ -25,4 +23,4 @@ export class TimeDifference {
 
     return diff[0] * 1000 + diff[1] / 1e6;
   }
-}
+}

package/src/utils/time_factor.test.ts

@@ -13,7 +13,7 @@ export class TimeFactorTest {
       120 * 1000,
       60 * 60 * 1000,
       65 * 60 * 1000,
-      25 * 60 * 60 * 1000
+      25 * 60 * 60 * 1000,
     ]) {
       TimeFactor(n / 1000, n);
       TimeFactor(n / 500, n);

package/src/utils/time_factor.ts

@@ -1,20 +1,35 @@
-import * as clrs from 'colors/safe.js';
+import * as clrs from "colors/safe.js";
 
 const colors = (clrs as any).default;
 
 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, ' '));
+  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';
+  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));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/test/basic.test.ts

@@ -5,7 +5,9 @@ export class BasicTest {
 
   @Spec()
   async checkEqual() {
-    await new Promise(resolve => { setTimeout(resolve, 1010) });
+    await new Promise((resolve) => {
+      setTimeout(resolve, 1010);
+    });
   }
 }
 
@@ -13,8 +15,10 @@ export class DependencyTest {
   @Dependency(BasicTest)
   basicTest!: BasicTest;
 
-  @Spec() async check() {
-    if (this.basicTest.variable !== 1) throw new Error('Dependency test failed!');
+  @Spec()
+  async check() {
+    if (this.basicTest.variable !== 1) {
+      throw new Error("Dependency test failed!");
+    }
   }
 }
-

package/test/before.test.ts

@@ -0,0 +1,54 @@
+import { strict as assert } from "assert";
+import { Before, Spec, After, Hook, HookType, Dependents } from "../src/index.js";
+
+// @After(() => [AlwaysExecuteFirst])
+export class AlwaysExecuteLater {
+  alwaysExecuteFirst: AlwaysExecuteFirst;
+
+  @Spec()
+  test() {
+    assert(this.alwaysExecuteFirst.value === 1);
+  }
+
+  @Hook(HookType.CleanUp)
+  cleanUp() {}
+}
+
+@Dependents(() => [AlwaysExecuteLater])
+export class AlwaysExecuteFirst {
+  value = 0;
+
+  @Spec()
+  test() {
+    this.value = 1;
+  }
+
+  @Hook(HookType.CleanUp)
+  cleanUp() {}
+}
+
+@After(() => [AlwaysExecuteFirst2])
+export class AlwaysExecuteLater2 {
+  alwaysExecuteFirst2: AlwaysExecuteFirst2;
+
+  @Spec()
+  test() {
+    assert(this.alwaysExecuteFirst2.value === 1);
+  }
+
+  @Hook(HookType.CleanUp)
+  cleanUp() {}
+}
+
+// @Before(() => [AlwaysExecuteLater2])
+export class AlwaysExecuteFirst2 {
+  value = 0;
+
+  @Spec()
+  test() {
+    this.value = 1;
+  }
+
+  @Hook(HookType.CleanUp)
+  cleanUp() {}
+}

package/test/clean-up.test.ts

@@ -11,11 +11,10 @@ export class CleanUpLayer1Test {
   @Hook(HookType.CleanUp)
   async cleanUp() {
     this.data = null;
-    console.log('layer 1 clean up completed!');
+    console.log("layer 1 clean up completed!");
   }
 }
 
-
 export class CleanUpLayer2Test {
   data: any;
 
@@ -30,11 +29,10 @@ export class CleanUpLayer2Test {
   @Hook(HookType.CleanUp)
   async cleanUp() {
     this.data = null;
-    console.log('layer 2 clean up completed!');
+    console.log("layer 2 clean up completed!");
   }
 }
 
-
 export class CleanUpLayer3Test {
   data: any;
 
@@ -49,6 +47,6 @@ export class CleanUpLayer3Test {
   @Hook(HookType.CleanUp)
   async cleanUp() {
     this.data = null;
-    console.log('layer 3 clean up completed!');
+    console.log("layer 3 clean up completed!");
   }
 }

package/test/dynamic-skip.test.ts

@@ -3,6 +3,6 @@ import { skipTest, Spec } from "../src/index.js";
 export class DynamicSkipTest {
   @Spec()
   async thisShouldBeSkipped() {
-    skipTest('I don\'t like this test anymore!');
+    skipTest("I don't like this test anymore!");
   }
 }

package/test/dynamic.test.ts

@@ -1,4 +1,4 @@
-import * as assert from 'assert';
+import * as assert from "assert";
 import { Spec } from "../src/index.js";
 
 export class DynamicTest {

package/test/hook.test.ts

@@ -1,4 +1,4 @@
-import * as assert from 'assert';
+import * as assert from "assert";
 import { Spec, Hook, Skip, HookType } from "../src/index.js";
 
 export class HookTest {
@@ -14,7 +14,7 @@ export class HookTest {
     assert.equal(this.array.pop(), 4);
   }
 
-  @Skip('no need')
+  @Skip("no need")
   @Spec()
   async hasToBe4Again() {
     assert.equal(this.array.pop(), 4);
@@ -24,4 +24,4 @@ export class HookTest {
   async hasToBe4AgainButNotSkipped() {
     assert.equal(this.array.pop(), 4);
   }
-}
+}

package/test/multi-dependency.test.ts

@@ -1,9 +1,31 @@
-import * as assert from 'assert';
+import * as assert from "assert";
 import { Dependencies, Spec } from "../src/index.js";
-import { BasicTest } from './basic.test.js';
-import { CleanUpLayer1Test, CleanUpLayer2Test, CleanUpLayer3Test } from './clean-up.test.js';
-import { DynamicSkipTest } from './dynamic-skip.test.js';
-import { HookTest } from './hook.test.js';
+import { BasicTest } from "./basic.test.js";
+import {
+  CleanUpLayer1Test,
+  CleanUpLayer2Test,
+  CleanUpLayer3Test,
+} from "./clean-up.test.js";
+import { DynamicSkipTest } from "./dynamic-skip.test.js";
+import { HookTest } from "./hook.test.js";
+
+@Dependencies(() => [
+  BasicTest,
+  CleanUpLayer1Test,
+  CleanUpLayer2Test,
+  CleanUpLayer3Test,
+  DynamicSkipTest,
+  HookTest,
+  MultiDependency,
+])
+export class MultiLazyDependency {
+  basicTest: BasicTest;
+
+  @Spec()
+  test() {
+    assert.strictEqual(this.basicTest.variable, 1);
+  }
+}
 
 @Dependencies([
   BasicTest,
@@ -11,13 +33,13 @@ import { HookTest } from './hook.test.js';
   CleanUpLayer2Test,
   CleanUpLayer3Test,
   DynamicSkipTest,
-  HookTest
+  HookTest,
 ])
 export class MultiDependency {
   basicTest: BasicTest;
 
-  @Spec() 
+  @Spec()
   test() {
-    assert.strictEqual(this.basicTest.variable, 1);  
+    assert.strictEqual(this.basicTest.variable, 1);
   }
-}
+}