feat: added option to skip a single unit test in code

Author: ncpa0cpl

src/base/test-runner.ts

@@ -49,43 +49,35 @@ const currentMicrosecond = () => {
   return now.to_unix() * 1000000 + now.get_microsecond();
 };
 
-class SuiteRunner {
-  constructor(
-    private readonly options: SuiteRunnerOptions,
-    private readonly tracker: ProgressTracker,
-    private readonly suiteID: symbol
-  ) {}
+class UnitRunner {
+  readonly unitName: string[];
+  readonly isSkipped: boolean = false;
 
-  private async measureRun(
-    action: () => void | Promise<void>
-  ): Promise<number> {
-    const start = currentMicrosecond();
-    await action();
-    const end = currentMicrosecond();
+  constructor(
+    public readonly unit: It,
+    parentName: string[],
+    public readonly suite: SuiteRunner
+  ) {
+    this.unitName = [...parentName, unit.name];
 
-    const duration = end - start;
-    return duration;
+    if (!this.testNameMatches(this.unitName) || unit.skip) {
+      this.isSkipped = true;
+      this.suite.tracker.unitProgress({
+        suite: this.suite.suiteID,
+        skipped: true,
+        unitName: this.unitName,
+        unit,
+      });
+    }
   }
 
   private testNameMatches(unitName: string[]) {
-    const testableName = unitName.join(" > ");
-    const { testNamePattern } = this.options;
+    const { testNamePattern } = this.suite.options;
     if (!testNamePattern) return true;
+    const testableName = unitName.join(" > ");
     return testableName.match(testNamePattern) !== null;
   }
 
-  private markAsSkipped(units: It[], parentName: string[]) {
-    for (const unit of units) {
-      const unitName = [...parentName, unit.name];
-      this.tracker.unitProgress({
-        suite: this.suiteID,
-        unitName,
-        skipped: true,
-        unit,
-      });
-    }
-  }
-
   private async runWithTimeout(
     action: () => void | Promise<void>,
     time: number
@@ -112,60 +104,42 @@ class SuiteRunner {
     return r;
   }
 
-  private async runHook(hook: TestHook, unitName: string[]) {
-    try {
-      await hook.callback();
-    } catch (e) {
-      this.tracker.suiteProgress({
-        suite: this.suiteID,
-        parentUnitName: unitName,
-        error: {
-          origin: "lifecycleHook",
-          thrown: e,
-          hook,
-        },
-      });
+  private async measureRun(
+    action: () => void | Promise<void>
+  ): Promise<number> {
+    const start = currentMicrosecond();
+    await action();
+    const end = currentMicrosecond();
 
-      throw new NoLogError(e, "Hook error");
-    }
+    const duration = end - start;
+    return duration;
   }
 
-  private async runUnit(unit: It, parentName: string[]) {
-    const unitName = [...parentName, unit.name];
+  async run() {
+    if (this.isSkipped) return false;
 
     try {
-      if (!this.testNameMatches(unitName)) {
-        this.tracker.unitProgress({
-          suite: this.suiteID,
-          skipped: true,
-          unitName,
-          unit,
-        });
-
-        return true;
-      }
-
       const duration = await this.measureRun(() =>
-        this.runWithTimeout(unit.callback, this.options.timeout)
+        this.runWithTimeout(this.unit.callback, this.suite.options.timeout)
       );
 
-      this.tracker.unitProgress({
-        suite: this.suiteID,
-        unitName,
+      this.suite.tracker.unitProgress({
+        suite: this.suite.suiteID,
+        unitName: this.unitName,
         duration,
-        unit,
+        unit: this.unit,
       });
 
       return true;
     } catch (e) {
-      this.tracker.unitProgress({
-        suite: this.suiteID,
-        unitName,
+      this.suite.tracker.unitProgress({
+        suite: this.suite.suiteID,
+        unitName: this.unitName,
         error: {
           origin: "test",
           thrown: e,
         },
-        unit,
+        unit: this.unit,
       });
 
       if (_isExpectError(e)) {
@@ -175,6 +149,44 @@ class SuiteRunner {
       return false;
     }
   }
+}
+
+class SuiteRunner {
+  constructor(
+    public readonly options: SuiteRunnerOptions,
+    public readonly tracker: ProgressTracker,
+    public readonly suiteID: symbol
+  ) {}
+
+  private markAsSkipped(units: It[], parentName: string[]) {
+    for (const unit of units) {
+      const unitName = [...parentName, unit.name];
+      this.tracker.unitProgress({
+        suite: this.suiteID,
+        unitName,
+        skipped: true,
+        unit,
+      });
+    }
+  }
+
+  private async runHook(hook: TestHook, unitName: string[]) {
+    try {
+      await hook.callback();
+    } catch (e) {
+      this.tracker.suiteProgress({
+        suite: this.suiteID,
+        parentUnitName: unitName,
+        error: {
+          origin: "lifecycleHook",
+          thrown: e,
+          hook,
+        },
+      });
+
+      throw new NoLogError(e, "Hook error");
+    }
+  }
 
   async runSuite(test: Test, parentName: string[] = []): Promise<boolean> {
     let passed = true;
@@ -192,19 +204,25 @@ class SuiteRunner {
         }
       }
 
-      $: for (const [index, unitTest] of test.its.entries()) {
+      $: for (const unitTest of test.its) {
+        const unitRunner = new UnitRunner(unitTest, unitName, this);
+
+        if (unitRunner.isSkipped) {
+          continue;
+        }
+
         for (const hook of test.beforeEach) {
           try {
             await this.runHook(hook, unitName);
           } catch (e) {
             // All tests that cannot be ran because of a beforeAll hook
             // error should be marked as skipped
-            this.markAsSkipped(test.its.slice(index, index + 1), unitName);
+            this.markAsSkipped([unitTest], unitName);
             continue $;
           }
         }
 
-        const result = await this.runUnit(unitTest, unitName);
+        const result = await unitRunner.run();
 
         passed &&= result;
 

src/user-land/index.ts

@@ -23,6 +23,16 @@ export const it = (name: string, fn: () => any) => {
   });
 };
 
+export const skip = (name: string, fn: () => any) => {
+  TestCollector.addIt({
+    name,
+    line: 0,
+    column: 0,
+    skip: true,
+    callback: () => {},
+  });
+};
+
 export const beforeAll = (fn: () => void) => {
   // Get line where this function was called
   const [line, column] = _getLineFromError(new Error());

src/user-land/test-collector.ts

@@ -2,6 +2,7 @@ export type It = {
   name: string;
   line: number;
   column: number;
+  skip?: boolean;
   callback: () => any;
 };