mark test as exclusive run

lib/core/test.js

@@ -12,12 +12,14 @@ export class Test {
   #body;
   #callbacks;
   #result;
+  #isMarkedAsExclusiveForRun;
 
   constructor(name, body, callbacks) {
     this.#initializeName(name);
     this.#initializeBody(body);
     this.#callbacks = callbacks;
     this.#result = undefined;
+    this.#isMarkedAsExclusiveForRun = false;
   }
 
   // Execution
@@ -62,6 +64,14 @@ export class Test {
     this.setResult(explicitlySkippedResult);
   }
 
+  only() {
+    this.#isMarkedAsExclusiveForRun = true;
+  }
+
+  isMarkedAsExclusiveForRun() {
+    return this.#isMarkedAsExclusiveForRun;
+  }
+
   setResult(result) {
     if (this.hasNoResult() || this.isSuccess()) {
       this.#result = result;

lib/core/test_suite.js

@@ -208,6 +208,26 @@ export class TestSuite {
 
   #evaluateSuiteDefinition() {
     this.#body.call();
+    this.#evaluateExclusiveRunsMarks();
+  }
+
+  #evaluateExclusiveRunsMarks() {
+    const testsMarkedAsOnlyCount = this.#getTestsMarkedAsExclusive();
+    if(testsMarkedAsOnlyCount > 0) {
+      this.#skipTestsNotMarkedAsExclusive();
+    }
+  }
+
+  #getTestsMarkedAsExclusive() {
+    return this.tests().filter(test => test.isMarkedAsExclusiveForRun()).length;
+  }
+
+  #skipTestsNotMarkedAsExclusive() {
+    this.tests().forEach(test => {
+      if(!test.isMarkedAsExclusiveForRun()) {
+        test.skip();
+      }
+    })
   }
 
   async #runTests(context) {

tests/core/test_suite_test.js

@@ -242,4 +242,58 @@ suite('test suite behavior', () => {
 
     assert.that(count).isEqualTo(0);
   });
+
+  test('a suite that has tests marked as only runs exclusively those tests and skips the rest', async () => {
+    mySuite.addTest(passingTest);
+    mySuite.addTest(failingTest);
+    mySuite.addTest(erroredTest);
+
+    passingTest.only();
+    failingTest.only();
+
+    await runner.run();
+
+    assert.that(erroredTest.isExplicitlySkipped()).isTrue();
+
+    assert.that(mySuite.totalCount()).isEqualTo(3);
+    assert.that(mySuite.pendingCount()).isEqualTo(0);
+    assert.that(mySuite.successCount()).isEqualTo(1);
+    assert.that(mySuite.failuresCount()).isEqualTo(1);
+    assert.that(mySuite.errorsCount()).isEqualTo(0);
+    assert.that(mySuite.skippedCount()).isEqualTo(1);
+  })
+
+  test('a suite that has tests marked as only runs before hooks exclusively for those tests', async () => {
+    let count = 0;
+
+    mySuite.before(() => {
+      count += 1;
+    });
+
+    mySuite.addTest(passingTest);
+    mySuite.addTest(failingTest);
+
+    passingTest.only();
+
+    await runner.run();
+
+    assert.that(count).isEqualTo(1);
+  });
+
+  test('a suite that has tests marked as only runs after hooks exclusively for those tests', async () => {
+    let count = 0;
+
+    mySuite.after(() => {
+      count += 1;
+    });
+
+    mySuite.addTest(passingTest);
+    mySuite.addTest(failingTest);
+
+    passingTest.only();
+
+    await runner.run();
+
+    assert.that(count).isEqualTo(1);
+  });
 });

tests/core/test_test.js

@@ -146,4 +146,40 @@ suite('tests behavior', () => {
       assert.that(calls).isEqualTo(1);
     });
   });
+
+  test('a successful test marked as only runs normally', async () => {
+    await withRunner(async(runner, asserter) => {
+      let calls = 0;
+
+      const testToBeMarkedAsOnly = aPassingTest(
+        asserter, { whenSuccess: () => {
+          calls += 1;
+        } });
+
+      testToBeMarkedAsOnly.only();
+
+      const result = await resultOfASuiteWith(runner, testToBeMarkedAsOnly);
+
+      assert.isTrue(result.isSuccess());
+      assert.that(calls).isEqualTo(1);
+    });
+  })
+
+  test('a failed test marked as only runs normally', async () => {
+    await withRunner(async(runner, asserter) => {
+      let calls = 0;
+
+      const testToBeMarkedAsOnly = aFailingTest(
+        asserter, { whenFailed: () => {
+          calls += 1;
+        } });
+
+      testToBeMarkedAsOnly.only();
+
+      const result = await resultOfASuiteWith(runner, testToBeMarkedAsOnly);
+
+      assert.isTrue(result.isFailure());
+      assert.that(calls).isEqualTo(1);
+    });
+  })
 });