feat: skip tests in bail mode and allow skipping group tests in bulk

src/group/main.ts

@@ -53,6 +53,10 @@ export class Group<Context extends Record<any, any>> extends Macroable {
   #testsRetries?: number
   #testSetupHooks: TestHooksHandler<Context>[] = []
   #testTeardownHooks: TestHooksHandler<Context>[] = []
+  #testsSkip?: {
+    skip: boolean | (() => Promise<boolean> | boolean)
+    skipReason?: string
+  }
 
   /**
    * Know if one or more tests/hooks within this group
@@ -77,6 +81,7 @@ export class Group<Context extends Record<any, any>> extends Macroable {
     teardown: (handler: TestHooksHandler<Context>) => void
     timeout: (timeout: number) => void
     retry: (retries: number) => void
+    skip: (skip?: boolean | (() => Promise<boolean> | boolean), skipReason?: string) => void
     disableTimeout: () => void
   } = {
     /**
@@ -113,6 +118,13 @@ export class Group<Context extends Record<any, any>> extends Macroable {
     retry: (retries: number) => {
       this.#testsRetries = retries
     },
+
+    /**
+     * Skip all the tests inside the group
+     */
+    skip: (skip, skipReason) => {
+      this.#testsSkip = { skip: skip ?? true, skipReason }
+    },
   }
 
   constructor(
@@ -163,6 +175,9 @@ export class Group<Context extends Record<any, any>> extends Macroable {
     if (this.#testTeardownHooks.length) {
       this.#testTeardownHooks.forEach((handler) => test.teardown(handler))
     }
+    if (this.#testsSkip) {
+      test.skip(this.#testsSkip.skip, this.#testsSkip.skipReason)
+    }
 
     /**
      * Invoke tap callback passing test to each callback

src/group/runner.ts

@@ -182,14 +182,17 @@ export class GroupRunner {
      * Run the test executor
      */
     for (let test of this.#group.tests) {
+      /**
+       * Skip tests in bail mode when there is an error
+       */
+      if (this.#options.bail && this.#hasError) {
+        test.skip(true, 'Skipped due to bail mode')
+      }
+
       await test.exec()
       if (!this.#hasError && test.failed) {
         this.#hasError = true
       }
-
-      if (this.#options.bail && this.#hasError) {
-        break
-      }
     }
 
     /**

src/suite/runner.ts

@@ -14,6 +14,7 @@ import debug from '../debug.js'
 import { Suite } from './main.js'
 import { Emitter } from '../emitter.js'
 import type { SuiteEndNode, SuiteHooks, SuiteHooksData, SuiteStartNode } from '../types.js'
+import { Group } from '../group/main.js'
 
 /**
  * Run all groups or tests inside the suite stack
@@ -178,14 +179,21 @@ export class SuiteRunner {
      * Run the test executor
      */
     for (let groupOrTest of this.#suite.stack) {
+      /**
+       * Skip tests in bail mode when there is an error
+       */
+      if (this.#options.bail && this.#hasError) {
+        if (groupOrTest instanceof Group) {
+          groupOrTest.each.skip(true, 'Skipped due to bail mode')
+        } else {
+          groupOrTest.skip(true, 'Skipped due to bail mode')
+        }
+      }
+
       await groupOrTest.exec()
       if (!this.#hasError && groupOrTest.failed) {
         this.#hasError = true
       }
-
-      if (this.#options.bail && this.#hasError) {
-        break
-      }
     }
 
     /**

tests/group/configure.spec.ts

@@ -72,4 +72,17 @@ test.describe('configure', () => {
 
     assert.equal(testInstance.options.timeout, 0)
   })
+
+  test('skip all tests inside the group', async () => {
+    const emitter = new Emitter()
+    const refiner = new Refiner({})
+
+    const group = new Group<TestContext>('sample group', emitter, refiner)
+    const testInstance = new Test('2 + 2 = 4', new TestContext(), emitter, refiner)
+
+    group.each.skip()
+    group.add(testInstance)
+
+    assert.equal(testInstance.options.isSkipped, true)
+  })
 })

tests/group/execute.spec.ts

@@ -122,12 +122,14 @@ test.describe('execute | test', () => {
     const [groupEndEvent] = await Promise.all([pEvent(emitter, 'group:end'), group.exec()])
 
     assert.isTrue(group.failed)
-    assert.lengthOf(events, 1)
+    assert.lengthOf(events, 2)
     assert.equal(events[0].title.expanded, 'test')
     assert.isTrue(events[0].hasError)
     assert.equal(events[0].errors[0].phase, 'test')
     assert.equal(events[0].errors[0].error.message, 'blow up')
 
+    assert.isTrue(events[1].isSkipped)
+
     assert.equal(groupEndEvent!.title, 'sample group')
     assert.deepEqual(stack, ['test'])
   })

tests/suite/execute.spec.ts

@@ -166,22 +166,34 @@ test.describe('execute | test', () => {
     })
 
     group1.add(testInstance).add(testInstance1)
+
+    const testInstance3 = new Test('test 3', new TestContext(), emitter, refiner)
+    testInstance3.run(() => {
+      stack.push('test 3')
+      throw new Error('blow up')
+    })
+    const testInstance4 = new Test('test 4', new TestContext(), emitter, refiner)
+    testInstance4.run(() => {
+      stack.push('test 1')
+    })
+
     suite.bail()
-    group2.add(testInstance).add(testInstance1)
+    group2.add(testInstance3).add(testInstance4)
 
-    const [suiteEndEvent] = await Promise.all([pEvent(emitter, 'suite:end'), suite.exec()])
+    await Promise.all([pEvent(emitter, 'suite:end'), suite.exec()])
 
     assert.isTrue(suite.failed)
-    assert.lengthOf(events, 2)
+    assert.lengthOf(events, 6)
 
     assert.equal((events[0].title as { expanded: string }).expanded, 'test')
     assert.isTrue(events[0].hasError)
+    assert.isTrue((events[1] as TestEndNode).isSkipped)
 
-    assert.equal(String(events[1].title), 'group')
-    assert.isTrue(events[1].hasError)
+    assert.equal((events[3].title as { expanded: string }).expanded, 'test 3')
+    assert.isTrue(events[3].hasError)
+    assert.isTrue((events[4] as TestEndNode).isSkipped)
 
-    assert.equal(suiteEndEvent!.name, 'sample suite')
-    assert.deepEqual(stack, ['test'])
+    assert.deepEqual(stack, ['test', 'test 3'])
   })
 })