fixup!: xfail → expectFailure

Author: JakobJingleheimer

doc/api/test.md

@@ -238,39 +238,39 @@ In the following, `doTheThing()` returns _currently_ `false` (`false` does not e
 `strictEqual` to throw, so the test-case passes).
 
 ```js
-it.xfail('should do the thing', () => {
+it.expectFailure('should do the thing', () => {
   assert.strictEqual(doTheThing(), true);
 });
 
-it('should do the thing', { xfail: true }, () => {
+it('should do the thing', { expectFailure: true }, () => {
   assert.strictEqual(doTheThing(), true);
 });
 ```
 
-`skip` and/or `todo` are mutually exclusive to `xfail`, and `skip` or `todo`
+`skip` and/or `todo` are mutually exclusive to `expectFailure`, and `skip` or `todo`
 will "win" when both are applied (`skip` wins against both, and `todo` wins
-against `xfail`).
+against `expectFailure`).
 
 These tests will be skipped (and not run):
 
 ```js
-it.xfail('should do the thing', { skip: true }, () => {
+it.expectFailure('should do the thing', { skip: true }, () => {
   assert.strictEqual(doTheThing(), true);
 });
 
-it.skip('should do the thing', { xfail: true }, () => {
+it.skip('should do the thing', { expectFailure: true }, () => {
   assert.strictEqual(doTheThing(), true);
 });
 ```
 
 These tests will be marked "todo" (silencing errors):
 
 ```js
-it.xfail('should do the thing', { todo: true }, () => {
+it.expectFailure('should do the thing', { todo: true }, () => {
   assert.strictEqual(doTheThing(), true);
 });
 
-it.todo('should do the thing', { xfail: true }, () => {
+it.todo('should do the thing', { expectFailure: true }, () => {
   assert.strictEqual(doTheThing(), true);
 });
 ```

lib/internal/test_runner/harness.js

@@ -377,7 +377,7 @@ function runInParentContext(Factory) {
 
     return run(name, options, fn, overrides);
   };
-  ArrayPrototypeForEach(['xfail', 'skip', 'todo', 'only'], (keyword) => {
+  ArrayPrototypeForEach(['expectFailure', 'skip', 'todo', 'only'], (keyword) => {
     test[keyword] = (name, options, fn) => {
       const overrides = {
         __proto__: null,

lib/internal/test_runner/reporter/tap.js

@@ -33,12 +33,12 @@ async function * tapReporter(source) {
   for await (const { type, data } of source) {
     switch (type) {
       case 'test:fail': {
-        yield reportTest(data.nesting, data.testNumber, 'not ok', data.name, data.skip, data.todo, data.xfail);
+        yield reportTest(data.nesting, data.testNumber, 'not ok', data.name, data.skip, data.todo, data.expectFailure);
         const location = data.file ? `${data.file}:${data.line}:${data.column}` : null;
         yield reportDetails(data.nesting, data.details, location);
         break;
       } case 'test:pass':
-        yield reportTest(data.nesting, data.testNumber, 'ok', data.name, data.skip, data.todo, data.xfail);
+        yield reportTest(data.nesting, data.testNumber, 'ok', data.name, data.skip, data.todo, data.expectFailure);
         yield reportDetails(data.nesting, data.details, null);
         break;
       case 'test:plan':
@@ -65,7 +65,7 @@ async function * tapReporter(source) {
   }
 }
 
-function reportTest(nesting, testNumber, status, name, skip, todo, xfail) {
+function reportTest(nesting, testNumber, status, name, skip, todo, expectFailure) {
   let line = `${indent(nesting)}${status} ${testNumber}`;
 
   if (name) {
@@ -76,7 +76,7 @@ function reportTest(nesting, testNumber, status, name, skip, todo, xfail) {
     line += ` # SKIP${typeof skip === 'string' && skip.length ? ` ${tapEscape(skip)}` : ''}`;
   } else if (todo !== undefined) {
     line += ` # TODO${typeof todo === 'string' && todo.length ? ` ${tapEscape(todo)}` : ''}`;
-  } else if (xfail !== undefined) {
+  } else if (expectFailure !== undefined) {
     line += ' # EXPECTED FAILURE';
   }
 

lib/internal/test_runner/reporter/utils.js

@@ -71,15 +71,15 @@ function formatError(error, indent) {
 function formatTestReport(type, data, prefix = '', indent = '', hasChildren = false, showErrorDetails = true) {
   let color = reporterColorMap[type] ?? colors.white;
   let symbol = reporterUnicodeSymbolMap[type] ?? ' ';
-  const { skip, todo, xfail } = data;
+  const { skip, todo, expectFailure } = data;
   const duration_ms = data.details?.duration_ms ? ` ${colors.gray}(${data.details.duration_ms}ms)${colors.white}` : '';
   let title = `${data.name}${duration_ms}`;
 
   if (skip !== undefined) {
     title += ` # ${typeof skip === 'string' && skip.length ? skip : 'SKIP'}`;
   } else if (todo !== undefined) {
     title += ` # ${typeof todo === 'string' && todo.length ? todo : 'TODO'}`;
-  } else if (xfail !== undefined) {
+  } else if (expectFailure !== undefined) {
     title += ` # EXPECTED FAILURE`;
   }
 

lib/internal/test_runner/test.js

@@ -496,7 +496,7 @@ class Test extends AsyncResource {
     super('Test');
 
     let { fn, name, parent } = options;
-    const { concurrency, entryFile, xfail, loc, only, timeout, todo, skip, signal, plan } = options;
+    const { concurrency, entryFile, expectFailure, loc, only, timeout, todo, skip, signal, plan } = options;
 
     if (typeof fn !== 'function') {
       fn = noop;
@@ -635,7 +635,7 @@ class Test extends AsyncResource {
     this.plan = null;
     this.expectedAssertions = plan;
     this.cancelled = false;
-    this.xfail = xfail !== undefined && xfail !== false;
+    this.expectFailure = expectFailure !== undefined && expectFailure !== false;
     this.skipped = skip !== undefined && skip !== false;
     this.isTodo = (todo !== undefined && todo !== false) || this.parent?.isTodo;
     this.startTime = null;
@@ -939,7 +939,7 @@ class Test extends AsyncResource {
       return;
     }
 
-    if (this.xfail === true) {
+    if (this.expectFailure === true) {
       this.passed = true;
     } else {
       this.passed = false;
@@ -1341,8 +1341,8 @@ class Test extends AsyncResource {
       directive = this.reporter.getSkip(this.message);
     } else if (this.isTodo) {
       directive = this.reporter.getTodo(this.message);
-    } else if (this.xfail) {
-      directive = this.reporter.getXFail(this.xfail); // TODO(@JakobJingleheimer): support specifying failure
+    } else if (this.expectFailure) {
+      directive = this.reporter.getXFail(this.expectFailure); // TODO(@JakobJingleheimer): support specifying failure
     }
 
     if (this.reportedType) {

lib/internal/test_runner/tests_stream.js

@@ -88,7 +88,7 @@ class TestsStream extends Readable {
   }
 
   getXFail(expectation = undefined) {
-    return { __proto__: null, xfail: expectation ?? true };
+    return { __proto__: null, expectFailure: expectation ?? true };
   }
 
   enqueue(nesting, loc, name, type) {

test/fixtures/test-runner/output/describe_it.js

@@ -5,19 +5,19 @@ const { describe, it, test } = require('node:test');
 const util = require('util');
 
 
-it.xfail('sync expect fail (method)', () => {
+it.expectFailure('sync expect fail (method)', () => {
   throw new Error('should pass');
 });
 
-it('sync expect fail (options)', { xfail: true }, () => {
+it('sync expect fail (options)', { expectFailure: true }, () => {
   throw new Error('should pass');
 });
 
-it.xfail('async expect fail (method)', async () => {
+it.expectFailure('async expect fail (method)', async () => {
   throw new Error('should pass');
 });
 
-it('async expect fail (options)', { xfail: true }, async () => {
+it('async expect fail (options)', { expectFailure: true }, async () => {
   throw new Error('should pass');
 });
 
@@ -31,7 +31,7 @@ it.todo('sync todo', () => {
   throw new Error('should not count as a failure');
 });
 
-it.todo('sync todo with expect fail', { xfail: true }, () => {
+it.todo('sync todo with expect fail', { expectFailure: true }, () => {
   throw new Error('should not count as an expected failure');
 });
 
@@ -42,7 +42,7 @@ it('sync todo with message', { todo: 'this is a failing todo' }, () => {
 it.skip('sync skip pass', () => {
 });
 
-it.skip('sync skip expect fail', { xfail: true }, () => {
+it.skip('sync skip expect fail', { expectFailure: true }, () => {
   throw new Error('should not fail');
 });
 

test/fixtures/test-runner/output/output.js

@@ -5,27 +5,27 @@ const assert = require('node:assert');
 const test = require('node:test');
 const util = require('util');
 
-test.xfail('sync expect fail (method)', () => {
+test.expectFailure('sync expect fail (method)', () => {
   throw new Error('should pass');
 });
 
-test('sync expect fail (options)', { xfail: true }, () => {
+test('sync expect fail (options)', { expectFailure: true }, () => {
   throw new Error('should pass');
 });
 
-test.xfail('async expect fail (method)', async () => {
+test.expectFailure('async expect fail (method)', async () => {
   throw new Error('should pass');
 });
 
-test('async expect fail (options)', { xfail: true }, async () => {
+test('async expect fail (options)', { expectFailure: true }, async () => {
   throw new Error('should pass');
 });
 
-test.todo('sync todo with expect fail', { xfail: true }, () => {
+test.todo('sync todo with expect fail', { expectFailure: true }, () => {
   throw new Error('should not count as an expected failure');
 });
 
-test.skip('sync skip expect fail', { xfail: true }, () => {
+test.skip('sync skip expect fail', { expectFailure: true }, () => {
   throw new Error('should not fail');
 });