[Tests] switch from jest to tape

This allows us to:
 - drop all the jest mocks
 - no longer be stuck on an EOL version nor be forced to raise the engines.node threshold
 - run tests 4x faster: jest takes 27.365s, tape takes 7.086s

.github/workflows/node-4+.yml

@@ -128,7 +128,7 @@ jobs:
           skip-ls-check: true
       - run: rm __tests__/src/util/getComputedRole-test.js
         if: ${{ matrix.node-version < 7 }}
-      - run: npm run test:ci
+      - run: npm run tests-only
       - uses: codecov/[email protected]
 
   node:

__tests__/index-test.js

@@ -2,36 +2,39 @@
 
 import fs from 'fs';
 import path from 'path';
-import expect from 'expect';
+import test from 'tape';
+
 import plugin from '../src';
 
 const rules = fs.readdirSync(path.resolve(__dirname, '../src/rules/'))
   .map((f) => path.basename(f, '.js'));
 
-describe('all rule files should be exported by the plugin', () => {
+test('all rule files should be exported by the plugin', (t) => {
   rules.forEach((ruleName) => {
-    it(`should export ${ruleName}`, () => {
-      expect(plugin.rules[ruleName]).toEqual(
-        require(path.join('../src/rules', ruleName)) // eslint-disable-line
-      );
-    });
+    t.equal(
+      plugin.rules[ruleName],
+      require(path.join('../src/rules', ruleName)), // eslint-disable-line import/no-dynamic-require
+      `exports ${ruleName}`,
+    );
   });
+
+  t.end();
 });
 
-describe('configurations', () => {
-  it('should export a \'recommended\' configuration', () => {
-    expect(plugin.configs.recommended).toBeDefined();
-  });
+test('configurations', (t) => {
+  t.notEqual(plugin.configs.recommended, undefined, 'exports a \'recommended\' configuration');
+
+  t.end();
 });
 
-describe('schemas', () => {
+test('schemas', (t) => {
   rules.forEach((ruleName) => {
-    it(`${ruleName} should export a schema with type object`, () => {
-      const rule = require(path.join('../src/rules', ruleName)); // eslint-disable-line
-      const schema = rule.meta && rule.meta.schema && rule.meta.schema[0];
-      const { type } = schema;
+    const rule = require(path.join('../src/rules', ruleName)); // eslint-disable-line import/no-dynamic-require
+    const schema = rule.meta && rule.meta.schema && rule.meta.schema[0];
+    const { type } = schema;
 
-      expect(type).toEqual('object');
-    });
+    t.equal(type, 'object', `${ruleName} exports a schema with type object`);
   });
+
+  t.end();
 });

__tests__/src/rules/anchor-ambiguous-text-test.js

@@ -1,4 +1,3 @@
-/* eslint-env jest */
 /**
  * @fileoverview Enforce `<a>` text to not exactly match "click here", "here", "link", or "a link".
  * @author Matt Wang

__tests__/src/rules/aria-proptypes-test.js

@@ -9,7 +9,8 @@
 
 import { aria } from 'aria-query';
 import { RuleTester } from 'eslint';
-import expect from 'expect';
+import test from 'tape';
+
 import parserOptionsMapper from '../../__util__/parserOptionsMapper';
 import parsers from '../../__util__/helpers/parsers';
 import rule from '../../../src/rules/aria-proptypes';
@@ -51,13 +52,14 @@ tokens from the following: ${permittedValues}.`,
   }
 };
 
-describe('validityCheck', () => {
-  it('should false for an unknown expected type', () => {
-    expect(validityCheck(
-      null,
-      null,
-    )).toBe(false);
-  });
+test('validityCheck', (t) => {
+  t.equal(
+    validityCheck(null, null),
+    false,
+    'is false for an unknown expected type',
+  );
+
+  t.end();
 });
 
 ruleTester.run('aria-proptypes', rule, {

__tests__/src/util/attributesComparator-test.js

@@ -1,115 +1,91 @@
-import expect from 'expect';
+import test from 'tape';
+
 import attributesComparator from '../../../src/util/attributesComparator';
 import JSXAttributeMock from '../../../__mocks__/JSXAttributeMock';
 import JSXElementMock from '../../../__mocks__/JSXElementMock';
 
-describe('attributesComparator', () => {
-  describe('base attributes', () => {
-    let baseAttributes;
-    let attributes;
-    describe('are undefined', () => {
-      describe('and attributes are undefined', () => {
-        it('should return true', () => {
-          expect(attributesComparator()).toBe(true);
-        });
-      });
-    });
-    describe('are empty', () => {
-      beforeEach(() => {
-        baseAttributes = [];
-      });
-      describe('and attributes', () => {
-        describe('are empty', () => {
-          attributes = [];
-          it('should return true', () => {
-            expect(attributesComparator(baseAttributes, attributes))
-              .toBe(true);
-          });
-        });
-        describe('have values', () => {
-          attributes = [
-            JSXAttributeMock('foo', 0),
-            JSXAttributeMock('bar', 'baz'),
-          ];
-          it('should return true', () => {
-            expect(attributesComparator(baseAttributes, attributes))
-              .toBe(true);
-          });
-        });
-      });
-    });
-    describe('have values', () => {
-      beforeEach(() => {
-        baseAttributes = [
-          {
-            name: 'biz',
-            value: 1,
-          }, {
-            name: 'fizz',
-            value: 'pop',
-          }, {
-            name: 'fuzz',
-            value: 'lolz',
-          },
-        ];
-      });
-      describe('and attributes', () => {
-        describe('are empty', () => {
-          attributes = [];
-          it('should return false', () => {
-            expect(attributesComparator(baseAttributes, attributes))
-              .toBe(false);
-          });
-        });
-        describe('have values', () => {
-          describe('and the values are the different', () => {
-            it('should return false', () => {
-              attributes = [
-                JSXElementMock(),
-                JSXAttributeMock('biz', 2),
-                JSXAttributeMock('ziff', 'opo'),
-                JSXAttributeMock('far', 'lolz'),
-              ];
-              expect(attributesComparator(baseAttributes, attributes))
-                .toBe(false);
-            });
-          });
-          describe('and the values are a subset', () => {
-            it('should return true', () => {
-              attributes = [
-                JSXAttributeMock('biz', 1),
-                JSXAttributeMock('fizz', 'pop'),
-                JSXAttributeMock('goo', 'gazz'),
-              ];
-              expect(attributesComparator(baseAttributes, attributes))
-                .toBe(false);
-            });
-          });
-          describe('and the values are the same', () => {
-            it('should return true', () => {
-              attributes = [
-                JSXAttributeMock('biz', 1),
-                JSXAttributeMock('fizz', 'pop'),
-                JSXAttributeMock('fuzz', 'lolz'),
-              ];
-              expect(attributesComparator(baseAttributes, attributes))
-                .toBe(true);
-            });
-          });
-          describe('and the values are a superset', () => {
-            it('should return true', () => {
-              attributes = [
-                JSXAttributeMock('biz', 1),
-                JSXAttributeMock('fizz', 'pop'),
-                JSXAttributeMock('fuzz', 'lolz'),
-                JSXAttributeMock('dar', 'tee'),
-              ];
-              expect(attributesComparator(baseAttributes, attributes))
-                .toBe(true);
-            });
-          });
-        });
-      });
-    });
-  });
+test('attributesComparator', (t) => {
+  t.equal(
+    attributesComparator(),
+    true,
+    'baseAttributes are undefined and attributes are undefined -> true',
+  );
+
+  t.equal(
+    attributesComparator([], []),
+    true,
+    'baseAttributes are empty and attributes are empty -> true',
+  );
+
+  t.equal(
+    attributesComparator([], [
+      JSXAttributeMock('foo', 0),
+      JSXAttributeMock('bar', 'baz'),
+    ]),
+    true,
+    'baseAttributes are empty and attributes have values -> true',
+  );
+
+  const baseAttributes = [
+    {
+      name: 'biz',
+      value: 1,
+    }, {
+      name: 'fizz',
+      value: 'pop',
+    }, {
+      name: 'fuzz',
+      value: 'lolz',
+    },
+  ];
+
+  t.equal(
+    attributesComparator(baseAttributes, []),
+    false,
+    'baseAttributes have values and attributes are empty -> false',
+  );
+
+  t.equal(
+    attributesComparator(baseAttributes, [
+      JSXElementMock(),
+      JSXAttributeMock('biz', 2),
+      JSXAttributeMock('ziff', 'opo'),
+      JSXAttributeMock('far', 'lolz'),
+    ]),
+    false,
+    'baseAttributes have values and attributes have values, and the values are different -> false',
+  );
+
+  t.equal(
+    attributesComparator(baseAttributes, [
+      JSXAttributeMock('biz', 1),
+      JSXAttributeMock('fizz', 'pop'),
+      JSXAttributeMock('goo', 'gazz'),
+    ]),
+    false,
+    'baseAttributes have values and attributes have values, and the values are a subset -> false',
+  );
+
+  t.equal(
+    attributesComparator(baseAttributes, [
+      JSXAttributeMock('biz', 1),
+      JSXAttributeMock('fizz', 'pop'),
+      JSXAttributeMock('fuzz', 'lolz'),
+    ]),
+    true,
+    'baseAttributes have values and attributes have values, and the values are the same -> true',
+  );
+
+  t.equal(
+    attributesComparator(baseAttributes, [
+      JSXAttributeMock('biz', 1),
+      JSXAttributeMock('fizz', 'pop'),
+      JSXAttributeMock('fuzz', 'lolz'),
+      JSXAttributeMock('dar', 'tee'),
+    ]),
+    true,
+    'baseAttributes have values and attributes have values, and the values are a superset -> true',
+  );
+
+  t.end();
 });