nole 2.2.2 → 3.0.0

package/README.md

@@ -1,9 +1,10 @@
 ![](docs/nole.png)
 
-Nole
-==========
+# Nole
 
-Nole is a testing platform just like mocha.. You can create test classes and declare specs with decorators..
+Nole is a testing platform just like mocha..
+
+> Breaking change at nole v3, plain old classes are better at this task.
 
 > Use nole 2.x for ESM and Typescript.
 
@@ -11,23 +12,20 @@ Nole is a testing platform just like mocha.. You can create test classes and dec
 
 ```ts
 // test/queue.test.ts
-import { Spec } from 'nole';
+import { Test } from "nole";
 
-class QueueTest {
+export class QueueTest extends Test() {
   queue!: Queue;
 
-  @Spec()
-  CreateInstance() {
-    this.queue = new Queue();  
+  createInstance() {
+    this.queue = new Queue();
   }
 
-  @Spec()
-  Push() {
+  push() {
     this.queue.push(10);
   }
 
-  @Spec(1000)
-  async Pipe() {
+  async pipe() {
     await this.queue.pipe(somewhere);
   }
 }
@@ -35,96 +33,62 @@ class QueueTest {
 
 ```bash
 $ nole ./test/**/*.test.ts
-  (ok)      0.09 ms QueueTest.CreateInstance()
-  (ok)      0.11 ms QueueTest.Push()
-  (ok)      1.09 ms QueueTest.Pipe()
-```
-
-## Spec
-
-Declaring the spec tag will notify the nole core and assigns the tasks for later use. You can also specify timeout. Default timeout is 5000 ms.
-
-```ts
-// test/queue.test.ts
-import { Spec } from 'nole';
-
-class QueueTest {
-  @Spec(10000)
-  Push() {
-    this.queue.push(10);
-  }
-}
+  (ok)      0.09 ms QueueTest.createInstance()
+  (ok)      0.11 ms QueueTest.push()
+  (ok)      1.09 ms QueueTest.pipe()
 ```
 
-> * All specs will be executed as creation order.
-> * Timing colors are defined by timeout value. If value smaller than (timeout / 5) output will be green. If value bigger than this but smaller than (timeout / 2.5); it will be yellow. In all other cases color will be red.
-
-
 ## Skip
 
-You can skip tests. (hooks will be disabled for this spec)
+You can skip tests. Make sure method name starts with skip
 
 ```ts
 // test/queue.test.ts
-import { Spec, Skip } from 'nole';
+import { Test } from "nole";
 
-class QueueTest {
-  @Skip('deprecated unit')
-  @Spec()
-  Push() {
+export class QueueTest extends Test() {
+  skip_Push() {
     this.queue.push(10);
   }
 }
 ```
 
-> * Skipping the task make it yellow colored.
-
 ```bash
 $ nole ./**/test/*.test.ts
-  (skip)              QueueTest.Push() {deprecated unit}
+  (skip)              QueueTest.skip_Push() {marked as skipped}
 ```
 
-## SkipClass
-
-You can skip whole test classes. It's equivalent of spec skipping, but you don't have to select one by one. 
-**Kindly reminder**: Dependents might require this test class and props. 
-
 ```ts
-// test/queue-skip-class.test.ts
-import { Spec, Skip, SkipClass } from 'nole';
-
-@SkipClass('No need anymore')
-class QueueTest {
-  @Spec()
-  Push() { }
+// test/queue.test.ts
+import { Test } from "nole";
 
-  @Skip('deprecated unit')
-  @Spec()
-  PushButSomehowDifferent() { }
+export class QueueTest extends Test({
+  skip: "no need",
+}) {
+  push() {
+    this.queue.push(10);
+  }
 }
 ```
 
 ```bash
 $ nole ./**/test/*.test.ts
-  (skip)              QueueTest.Push() {No need anymore}
-  (skip)              QueueTest.PushButSomehowDifferent() {deprecated unit}
+  (skip)              QueueTest.skip_Push() {no need}
 ```
 
-
 ## Dependencies
 
 You can include other tests and wait them to complete.
 
 ```ts
 // test/database.test.ts
-import { Spec } from 'nole';
+import { Test } from "nole";
 
-export class Database {
+export class Database extends Test() {
   connection!: any;
 
-  @Spec() 
-  async Connect() {
-    connection = new Connection('...');
+  async connect() {
+    connection = new Connection("...");
 
     await connection.connect();
   }
@@ -133,92 +97,35 @@ export class Database {
 
 ```ts
 // test/other.test.ts
-import { Spec, Dependency } from 'nole';
-import { Database } from './database.test';
-
-class Other {
-  @Dependency(Database)
-  database!: Database;
-
-  @Spec() 
-  async DoThings() {
-    await database.connection.doStuff();
-  }
-}
-```
-
-> * All dependencies will be waited until done
-> * If dependencies cannot resolve, it will occurr an error after the available tests done.
-
-
-## Multi Dependencies
-
-Easier way to declare dependencies by decorating class with an array.
-
-```ts
-// test/redis.test.ts
-import { Spec, Dependencies } from 'nole';
-import { Database } from './database.test';
-import { Other } from './other.test';
-
-@Dependencies([
-  Database,
-  Other
-])
-class Redis {
-  database: Database; // camel-case syntax
-  // even though other does not exist in this test, but nole will make sure it is completed when this test runs
-
-  @Spec() 
+import { Test } from "nole";
+import { Database } from "./database.test";
+
+export class Other extends Test({
+  dependencies: {
+    database: () => Database,
+  },
+}) {
   async DoThings() {
-    await database.connection.doStuff();
+    await this.database.connection.doStuff();
   }
 }
 ```
 
-## Lazy multi Dependencies / after
-
-Can solve order of execution issues
-
-```ts
-// test/redis.test.ts
-import { Spec, Dependencies, After } from 'nole';
-
-@Dependencies(() => [ B ])
-// or
-// @After(() => [ B ])
-class A {
-  b: B;
-
-  @Spec() 
-  async DoThings() { }
-}
-
-class B {
-  @Spec() 
-  async DoThings() { }
-}
-```
-
-## Reverse dependency / dependent / before
-
+> - All dependencies will be waited until done
+> - If dependencies cannot resolve, it will occurr an error after the available tests done.
 
+## Wait other tests
 
 ```ts
 // test/redis.test.ts
-import { Spec, Dependents, Before } from 'nole';
-
-class A {
-  b: B;
+import { Test } from "nole";
 
-  @Spec() 
-  async DoThings() { }
+export class A extends Test() {
+  async doThings() {}
 }
 
-@Before(() => [ A ])
-class B {
-  @Spec() 
-  async DoThings() { }
+export class B extends Test({ before: () => [A] }) {
+  async doThings() {}
 }
 ```
 
@@ -228,161 +135,160 @@ Hooks will help you to develop helper methods.
 
 ```ts
 // test/hook.test.ts
-import { Spec, Hook, HookType } from 'nole';
+import { Test } from "nole";
 
-class HookTest {
+export class HookTest {
   value!: number;
 
-  @Hook(HookType.BeforeEach)
   async beforeEach() {
     this.value = Math.random();
   }
 
-  @Spec()
-  ValidateNumber() {
+  validateNumber() {
     if (this.value > 0.5) {
-      throw new Error('Should not be higher than 0.5');
+      throw new Error("Should not be higher than 0.5");
     }
   }
 }
 ```
 
-> * Hooks can be async tasks.
-> * Hooks do have timeout, you can change it by second parameter.
-> * If you name hook same as hook type then; When it occurr an error, It will print "class:hookType" otherwise "class.name:hoopType"
-> * Hooks cannot be spec
-> * Hooks cannot skipped
-
 ## Dynamic Tests
 
-Dynamic tests are not featured in but you can create another method and call it dynamicly.
+```ts
+// test/dynamic.test.ts
+import { Test, addTest } from "nole";
 
+// not exported, nole cannot auto-bind this class
+class DynamicTest extends Test() {
+  test() {}
+}
+
+// adds it anyway
+addTest(() => DynamicTest);
+```
 
 ```ts
-// test/dynamic.test.ts
-import { Spec } from 'nole';
+// test/dynamic2.test.ts
+import { Test, addTest } from "nole";
+
+if (something) {
+  addTest(
+    () =>
+      class Special extends Test() {
+        check() {}
+      },
+  );
+}
+```
 
-class DynamicTest {
-  @Spec()
-  Some() {
-    for (let i = 0; i < 10; i++) {
-      this.single(i);
-    }
-  }
+```ts
+// test/dynamic3.test.ts
+import { Test, addTest } from "nole";
 
-  single(i) {
-    // ...    
+export class DeepTest extends Test() {
+  check() {
+    if (something) {
+      addTest(() => class Wololo extends Test() {});
+    }
   }
 }
 ```
 
-## Dependency hook
+## Test cleanup
 
-After end of the test tree, special hook will be called. Nole will follow execution order to run; first executed spec's "CleanUp" hook will be called last.
+There is a special hook that can be used to capture test finishing stage.
 
+> **Lifecycle:**
+>
+> - (class) Before
+> - - (method) BeforeEach
+> - - (method) Spec
+> - - (method) AfterEach
+> - (class) After
+> - (class) CleanUp \*called after dependency execution
 
 ```ts
 // test/database-with-cleanup.test.ts
-import { Spec, HookType, Hook } from 'nole';
+import { Test } from "nole";
 
-export class DatabaseWithCleanup {
+export class DatabaseWithCleanup extends Test() {
   connection!: any;
 
-  @Spec() 
-  async Connect() {
-    connection = new Connection('...');
+  async connect() {
+    this.connection = new Connection("...");
 
     await connection.connect();
   }
 
-  @Hook(HookType.CleanUp)
   async cleanUp() {
     this.connection.close();
-    console.log('Connection closed!');
+    console.log("Connection closed!");
   }
 }
 ```
 
 ```ts
 // test/other.test.ts
-import { Spec, Dependency } from 'nole';
-import { Database } from './database.test';
-
-class Other {
-  @Dependency(DatabaseWithCleanup)
-  database!: DatabaseWithCleanup;
-
-  @Spec() 
-  async DoThings() {
-    await database.connection.doStuff();
+import { Test } from "nole";
+import { Database } from "./database.test";
+
+export class Other extends Test({
+  dependencies: {
+    database: () => DatabaseWithCleanup,
+  },
+}) {
+  async doThings() {
+    await this.database.connection.doStuff();
   }
 }
 ```
 
 ```bash
 $ nole ./test/**/*.test.ts
-  (ok)      0.09 ms DatabaseWithCleanup.Connect()
-  (ok)      0.11 ms Other.DoThings()
+  (ok)      0.09 ms DatabaseWithCleanup.connect()
+  (ok)      0.11 ms Other.doThings()
 Connection closed!
 ```
 
+## Test extending
 
+If they are classes we should be able to extend them right
 
-## Assert
-
-We do not provide assert library. You can use chai or should.js.
-
-## Debugging
-
-Having cleanup features with missing dependencies could lead to issues and time loses. To make sure execution of tests correct, use `-O` parameter to print out every spec and hook without calling the function. It will also print before/after hook orders.
+```ts
+// test/extending.test.ts
+import { Test } from "nole";
 
-```bash
-$ nole -O ./test/**/*.test.ts
-  (skip)             SkipAllTest.wontRun() {skip all class}
-  (skip)             SkipAllTest.wontRunToo() {wont run too}
-  (skip)             SkipAllWithoutReason.wontRun()
-   (ok)         0 ms BasicTest.checkEqual()
-   (ok)         0 ms DependencyTest.check()
-   (ok)         0 ms CleanUpLayer1Test.start()
-   (ok)         0 ms CleanUpLayer2Test.start()
-   (ok)         0 ms CleanUpLayer3Test.start()
-   (ok)         0 ms DynamicSkipTest.thisShouldBeSkipped()
-   (ok)         0 ms HookTest.pushFourIntoArray:beforeEach()
-   (ok)         0 ms HookTest.hasToBe4()
-  (skip)             HookTest.hasToBe4Again() {no need}
-   (ok)         0 ms HookTest.pushFourIntoArray:beforeEach()
-   (ok)      0.03 ms HookTest.hasToBe4AgainButNotSkipped()
-   (ok)         0 ms MultiDependency.test()
-   (ok)         0 ms CleanUpLayer3Test:cleanUp()
-   (ok)         0 ms CleanUpLayer2Test:cleanUp()
-   (ok)         0 ms CleanUpLayer1Test:cleanUp()
-   (ok)         0 ms DynamicTest.thisTestsShouldNotFail()
-   (ok)         0 ms TimeFactorTest.evaluate()
-   (ok)         0 ms TimeDifferenceTest.evaluate()
-   (ok)         0 ms ExecutorTest.evaluate()
-   (ok)         0 ms ExecutorTest.throws()
-   (ok)         0 ms ExecutorTest.timeout()
-```
+// Simple is not exported, so nole wont handle it
+class Simple extends Test() {
+  value = 1;
 
-## Compiled files
+  check() {
+    if (this.value !== 1) {
+      // yeah it should be 1 anyway
+    }
+  }
+}
 
-> Deprecated (v2.x+), It will always use ts-node/esm module
+export class Complex extends Simple {
+  check() {
+    if (this.value > 0) {
+      // maybe it is more than just 1?
+    }
 
-You can run the compiled test files with `-T` option.
+    super.check(); // or
+  }
+}
 
-```bash
-$ nole -T ./build/test/**/*.test.js
-  (ok)      0.09 ms QueueTest.CreateInstance()
-  (ok)      0.11 ms QueueTest.Push()
-  (ok)      1.09 ms QueueTest.Pipe()
+export class MoreComplex extends Simple {
+  moreSpecs() {
+    // mooree
+  }
+}
 ```
 
-> This will prevent to load ts-node register. It will be quite faster.
-
-## Environment values to configure stuff
-
+```bash
+$ nole ./test/**/*.test.ts
+  (ok)      0.09 ms Complex.check()
+  (ok)      0.11 ms MoreComplex.check()
+  (ok)      0.11 ms MoreComplex.moreSpecs()
 ```
-NOLE_PRESERVE_CONSECUTIVE_UPPERCASE=true
-NOLE_PASCALCASE=false
-NOLE_WAIT_PERIOD=500
-```

package/bin/nole.js

@@ -1,59 +1,37 @@
 #!/usr/bin/env node
 
 import program from "commander";
-import glob from "glob";
+import { glob } from "glob";
 import path from "path";
 import fs from "fs";
 import colors from "colors/safe.js";
-import { ManualRun } from "../dist/run.js";
+import { register } from "tsx/esm/api";
+const unregister = register();
+
 import { TimeDifference } from "../dist/utils/time_difference.js";
 import { Delay, TimeResolve } from "../dist/utils/time_factor.js";
-import { register } from "node:module";
-import { pathToFileURL } from "node:url";
-register("ts-node/esm", pathToFileURL("./"));
+import { TEST_CLASS_KEY } from "../dist/symbol.js";
+import { ManualRun } from "../dist/run.js";
 
 const pkg = JSON.parse(
-  fs.readFileSync(new URL("../package.json", import.meta.url)).toString()
+  fs.readFileSync(new URL("../package.json", import.meta.url)).toString(),
 );
 
-program
-  .usage("<glob> ...")
-  .option("-L, --no-log", "disable console.log")
-  .option("-O, --order-debug", "shows execution order")
-  .version(pkg.version)
-  .parse(process.argv);
+program.usage("<glob> ...").version(pkg.version).parse(process.argv);
 
 if (!program.args.length) {
   program.help();
 } else {
   let time = TimeDifference.begin();
 
-  let log = console.log.bind(console);
-
-  if (!program.log) {
-    console.log = function () {};
-  }
-
-  Promise.all(
-    program.args.map(
-      (arg) =>
-        new Promise((resolve, reject) => {
-          glob(arg, (err, matches) => {
-            if (err) {
-              return reject(err);
-            }
-
-            resolve(matches);
-          });
-        })
-    )
-  )
+  Promise.all(program.args.map((arg) => glob(arg)))
     .then(async (list) => {
       const fileList = [];
 
       for (const item of list) {
-        while (item.length)
+        while (item.length) {
           fileList.push(path.resolve(process.cwd(), item.pop()));
+        }
       }
 
       if (!fileList.length) {
@@ -63,8 +41,24 @@ if (!program.args.length) {
 
       const file = time.end();
 
+      const tests = new Set();
+
       for (const file of fileList) {
-        await import(`file://${file}`);
+        const module = await import(`file://${file}`);
+
+        for (const key in module) {
+          const value = module[key];
+
+          if (!value) {
+            continue;
+          }
+
+          if (!value[TEST_CLASS_KEY]) {
+            continue;
+          }
+
+          tests.add(value);
+        }
       }
 
       const prop = time.end();
@@ -78,20 +72,25 @@ if (!program.args.length) {
         dependencyResolveWaitPeriod = 500;
       }
 
-      log("Nole tests v" + pkg.version);
+      console.log("Nole tests v" + pkg.version);
+
       try {
         await Delay(dependencyResolveWaitPeriod);
 
-        await ManualRun({
-          log,
-          orderDebug: program.orderDebug,
-        });
-
-        log(" discover: %s", TimeResolve(file));
-        log("  resolve: %s", TimeResolve(prop - file));
-        log(
+        try {
+          await ManualRun(tests);
+        } catch (e) {
+          if (e.message === "No specs found") {
+            log(`${FAILED_TEXT} no specs found`);
+          }
+          throw e;
+        }
+
+        console.log(" discover: %s", TimeResolve(file));
+        console.log("  resolve: %s", TimeResolve(prop - file));
+        console.log(
           "    tests: %s",
-          TimeResolve(time.end() - prop - dependencyResolveWaitPeriod)
+          TimeResolve(time.end() - prop - dependencyResolveWaitPeriod),
         );
         process.exit(0);
       } catch (e) {

package/dist/const.d.ts

@@ -0,0 +1,8 @@
+export declare const colors: any;
+export declare const OK_TEXT: any;
+export declare const SKIP_TEXT: any;
+export declare const DYNAMIC_SKIP_TEXT: any;
+export declare const FAILED_TEXT: any;
+export declare const HOOK_FAILED_TEXT: any;
+export declare const DEFAULT_TIMEOUT = 5000;
+//# sourceMappingURL=const.d.ts.map

package/dist/const.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.d.ts","sourceRoot":"","sources":["../src/const.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,MAAM,KAAwB,CAAC;AAE5C,eAAO,MAAM,OAAO,KAA0C,CAAC;AAC/D,eAAO,MAAM,SAAS,KAA2C,CAAC;AAClE,eAAO,MAAM,iBAAiB,KAA0C,CAAC;AACzE,eAAO,MAAM,WAAW,KAAwC,CAAC;AACjE,eAAO,MAAM,gBAAgB,KAA6C,CAAC;AAE3E,eAAO,MAAM,eAAe,OAAO,CAAC"}

package/dist/const.js

@@ -0,0 +1,9 @@
+import * as clrs from "colors/safe.js";
+export const colors = clrs.default;
+export const OK_TEXT = colors.bold(colors.green("   (ok)   "));
+export const SKIP_TEXT = colors.bold(colors.yellow("  (skip)  "));
+export const DYNAMIC_SKIP_TEXT = colors.bold(colors.blue(" (dskip)   "));
+export const FAILED_TEXT = colors.bold(colors.red(" (failed) "));
+export const HOOK_FAILED_TEXT = colors.bold(colors.red(" (hook failed) "));
+export const DEFAULT_TIMEOUT = 5000;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvY29uc3QudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLElBQUksTUFBTSxnQkFBZ0IsQ0FBQztBQUV2QyxNQUFNLENBQUMsTUFBTSxNQUFNLEdBQUksSUFBWSxDQUFDLE9BQU8sQ0FBQztBQUU1QyxNQUFNLENBQUMsTUFBTSxPQUFPLEdBQUcsTUFBTSxDQUFDLElBQUksQ0FBQyxNQUFNLENBQUMsS0FBSyxDQUFDLFlBQVksQ0FBQyxDQUFDLENBQUM7QUFDL0QsTUFBTSxDQUFDLE1BQU0sU0FBUyxHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLE1BQU0sQ0FBQyxZQUFZLENBQUMsQ0FBQyxDQUFDO0FBQ2xFLE1BQU0sQ0FBQyxNQUFNLGlCQUFpQixHQUFHLE1BQU0sQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDLElBQUksQ0FBQyxhQUFhLENBQUMsQ0FBQyxDQUFDO0FBQ3pFLE1BQU0sQ0FBQyxNQUFNLFdBQVcsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUMsQ0FBQztBQUNqRSxNQUFNLENBQUMsTUFBTSxnQkFBZ0IsR0FBRyxNQUFNLENBQUMsSUFBSSxDQUFDLE1BQU0sQ0FBQyxHQUFHLENBQUMsaUJBQWlCLENBQUMsQ0FBQyxDQUFDO0FBRTNFLE1BQU0sQ0FBQyxNQUFNLGVBQWUsR0FBRyxJQUFJLENBQUMifQ==