nole 3.0.0 → 3.2.0

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!");
-  }
-}

package/test/dynamic-skip.test.ts

@@ -1,6 +0,0 @@
-import { Test, skipTest } from "../dist/index.js";
-export class DynamicSkipTest extends Test() {
-  async thisShouldBeSkipped() {
-    skipTest("I don't like this test anymore!");
-  }
-}

package/test/dynamic.test.ts

@@ -1,28 +0,0 @@
-import * as assert from "assert";
-import { addTest } from "../dist/dynamic";
-import { Test } from "../dist/index";
-
-class DynamicTest extends Test() {
-  variable = 1;
-
-  async test() {
-    const v = (this.variable = Math.random());
-
-    addTest(
-      () =>
-        class UltraDynamic extends Test({
-          dependencies: { dynamicTest: () => DynamicTest },
-        }) {
-          async test() {
-            assert.equal(
-              this.dynamicTest.variable,
-              v,
-              "The dynamic test variable should be the same as the one in the parent test",
-            );
-          }
-        },
-    );
-  }
-}
-
-addTest(() => DynamicTest);

package/test/extend.test.ts

@@ -1,43 +0,0 @@
-import * as assert from "assert";
-import { Test } from "../dist/index.js";
-
-class Simple extends Test() {
-  variable = 1;
-
-  async before() {
-    console.log("before", this.variable);
-    assert.equal(this.variable, 1);
-  }
-
-  async after() {
-    console.log("after", this.variable);
-    assert.equal(this.variable, 2);
-  }
-
-  async change() {
-    this.variable = 2;
-  }
-}
-
-class ExtendedSimple extends Simple {
-  async change() {
-    this.variable = 3;
-  }
-
-  async after() {
-    console.log("after", this.variable);
-    assert.equal(this.variable, 3);
-  }
-}
-
-export class ExtendedTest extends Test({
-  dependencies: {
-    simple: () => Simple,
-    extendedSimple: () => ExtendedSimple,
-  },
-}) {
-  async check() {
-    assert.equal(this.simple.variable, 2);
-    assert.equal(this.extendedSimple.variable, 3);
-  }
-}

package/test/hook.test.ts

@@ -1,26 +0,0 @@
-import * as assert from "assert";
-import { Test } from "../dist/index.js";
-
-export class HookTest extends Test() {
-  array: number[] = [1, 2, 3];
-
-  async beforeEach() {
-    this.array.push(4);
-  }
-
-  async afterEach() {
-    assert.equal(this.array.length, 3);
-  }
-
-  async hasToBe4() {
-    assert.equal(this.array.pop(), 4);
-  }
-
-  async skip_hasToBe4Again() {
-    assert.equal(this.array.pop(), 4);
-  }
-
-  async hasToBe4AgainButNotSkipped() {
-    assert.equal(this.array.pop(), 4);
-  }
-}

package/test/multi-dependency.test.ts

@@ -1,43 +0,0 @@
-import * as assert from "assert";
-import {
-  CleanUpLayer1Test,
-  CleanUpLayer2Test,
-  CleanUpLayer3Test,
-} from "./clean-up.test.js";
-import { DynamicSkipTest } from "./dynamic-skip.test.js";
-import { HookTest } from "./hook.test.js";
-import { Test } from "../dist/index.js";
-import { DependencyTest } from "./basic.test.js";
-
-export class MultiLazyDependency extends Test({
-  dependencies: {
-    dependencyTest: () => DependencyTest,
-
-    c1: () => CleanUpLayer1Test,
-    c2: () => CleanUpLayer2Test,
-    c3: () => CleanUpLayer3Test,
-    c4: () => DynamicSkipTest,
-    c5: () => HookTest,
-    c6: () => MultiDependency,
-  },
-}) {
-  test() {
-    assert.strictEqual(this.dependencyTest.basicTest.variable, 1);
-  }
-}
-
-export class MultiDependency extends Test({
-  dependencies: {
-    dependencyTest: () => DependencyTest,
-
-    c1: () => CleanUpLayer1Test,
-    c2: () => CleanUpLayer2Test,
-    c3: () => CleanUpLayer3Test,
-    c4: () => DynamicSkipTest,
-    c5: () => HookTest,
-  },
-}) {
-  test() {
-    assert.strictEqual(this.dependencyTest.basicTest.variable, 1);
-  }
-}

package/test/multiple-uppercased-chars.test.ts

@@ -1,20 +0,0 @@
-import { strict as assert } from "assert";
-import { Test } from "../dist/index";
-
-export class IOTPOTest extends Test() {
-  async test() {}
-}
-
-export class MultipleUppercasedCharsTest extends Test({
-  dependencies: {
-    IOTPOTest: () => IOTPOTest,
-  },
-}) {
-  async check() {
-    assert.notEqual(
-      this["IOTPOTest"],
-      undefined,
-      "turkish character test is failed",
-    );
-  }
-}

package/test/skip-all.test.ts

@@ -1,10 +0,0 @@
-import * as assert from "assert";
-import { Test } from "../dist/index";
-
-export class SkipAllTest extends Test({
-  skip: "skip all class",
-}) {
-  async wontRun() {}
-
-  async wontRunToo() {}
-}

package/test/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "ES2020",
-    "lib": [
-      "es2020",
-      "esnext"
-    ],
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "outDir": "dist",
-    "removeComments": true,
-    "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
-  },
-  "include": [
-    "./**/*.ts",
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ],
-}

package/test/turkish-chars.test.ts

@@ -1,20 +0,0 @@
-import { strict as assert } from "assert";
-import { Test } from "../dist/index";
-
-export class ICharacterTest extends Test() {
-  async test() {}
-}
-
-export class TurkishCharacterTest extends Test({
-  dependencies: {
-    iCharacterTest: () => ICharacterTest,
-  },
-}) {
-  async check() {
-    assert.notEqual(
-      this["iCharacterTest"],
-      undefined,
-      "turkish character test is failed",
-    );
-  }
-}

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "es2020",
-    "module": "node16",
-    "moduleResolution": "node16",
-    "lib": ["es2020", "esnext"],
-    "declaration": true,
-    "declarationMap": true,
-    "outDir": "dist",
-    "strictNullChecks": true,
-    "inlineSourceMap": true,
-    "verbatimModuleSyntax": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["node_modules", "dist"]
-}