Upgrade to Babel 7 (jest-community#327)

wh1t3cAt1k · Jul 9, 2021 · 671bbdd · 671bbdd
1 parent 0013709
commit 671bbdd
Show file tree

Hide file tree

Showing 25 changed files with 1,350 additions and 956 deletions.
diff --git a/.eslintrc b/.eslintrc
@@ -1,5 +1,9 @@
 {
-  "parser": "babel-eslint",
+  "parser": "@babel/eslint-parser",
+  "parserOptions": {
+      "ecmaVersion": 6,
+      "sourceType": "module"
+  },
   "env": {
     "node": true,
     "es6": true,

diff --git a/package.json b/package.json
@@ -35,16 +35,14 @@
   "license": "MIT",
   "repository": "jest-community/jest-extended",
   "devDependencies": {
+    "@babel/cli": "^7.0.0",
+    "@babel/core": "^7.0.0",
+    "@babel/eslint-parser": "^7.14.7",
+    "@babel/preset-env": "^7.14.7",
     "@types/jest": "^24.0.0",
-    "babel-cli": "^6.26.0",
-    "babel-core": "^6.26.0",
-    "babel-eslint": "^8.0.1",
     "babel-jest": "^24.0.0",
     "babel-jest-assertions": "^0.1.0",
     "babel-plugin-gwt": "^1.0.0",
-    "babel-plugin-transform-async-to-generator": "^6.24.1",
-    "babel-plugin-transform-es2015-modules-commonjs": "^6.26.0",
-    "babel-plugin-transform-object-rest-spread": "^6.26.0",
     "codecov": "^3.0.0",
     "eslint": "^4.9.0",
     "eslint-plugin-import": "^2.8.0",
@@ -95,11 +93,18 @@
     ]
   },
   "babel": {
+    "presets": [
+      [
+        "@babel/preset-env",
+        {
+          "targets": {
+            "node": "12"
+          }
+        }
+      ]
+    ],
     "plugins": [
-      "babel-plugin-transform-es2015-modules-commonjs",
-      "transform-object-rest-spread",
-      "transform-async-to-generator",
-      "./node_modules/babel-jest-assertions",
+      "module:babel-jest-assertions",
       "gwt",
       "macros"
     ]

diff --git a/src/matchers/toBeArrayOfSize/index.test.js b/src/matchers/toBeArrayOfSize/index.test.js
@@ -22,18 +22,12 @@ describe('.toBeArrayOfSize', () => {
     expect(() => expect(false).toBeArrayOfSize(1)).toThrowErrorMatchingSnapshot();
   });
 
-  each([
-    [false],
-    [true],
-    [0],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('fails when given type of %s which is not an array', given => {
-    expect(() => expect(given).toBeArrayOfSize(1)).toThrowErrorMatchingSnapshot();
-  });
+  each([[false], [true], [0], [{}], [() => {}], [undefined], [null], [NaN]]).test(
+    'fails when given type of %s which is not an array',
+    given => {
+      expect(() => expect(given).toBeArrayOfSize(1)).toThrowErrorMatchingSnapshot();
+    }
+  );
 
   test('fails when not given an array', () => {
     expect(() => expect().toBeArrayOfSize(5)).toThrowErrorMatchingSnapshot();

diff --git a/src/matchers/toBeBoolean/index.test.js b/src/matchers/toBeBoolean/index.test.js
@@ -27,18 +27,12 @@ describe('.toBeBoolean', () => {
 });
 
 describe('.not.toBeBoolean', () => {
-  each([
-    ['true'],
-    [0],
-    [{}],
-    [[]],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('passes when item is not of type boolean: %s', given => {
-    expect(given).not.toBeBoolean();
-  });
+  each([['true'], [0], [{}], [[]], [() => {}], [undefined], [null], [NaN]]).test(
+    'passes when item is not of type boolean: %s',
+    given => {
+      expect(given).not.toBeBoolean();
+    }
+  );
 
   test('fails when given a boolean', () => {
     expect(() => expect(true).not.toBeBoolean()).toThrowErrorMatchingSnapshot();

diff --git a/src/matchers/toBeDate/index.test.js b/src/matchers/toBeDate/index.test.js
@@ -15,19 +15,12 @@ describe('.toBeDate', () => {
 });
 
 describe('.not.toBeDate', () => {
-  each([
-    [false],
-    [true],
-    [0],
-    [''],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('passes when not given a date: %s', given => {
-    expect(given).not.toBeDate();
-  });
+  each([[false], [true], [0], [''], [{}], [() => {}], [undefined], [null], [NaN]]).test(
+    'passes when not given a date: %s',
+    given => {
+      expect(given).not.toBeDate();
+    }
+  );
 
   test('fails when given a date', () => {
     expect(() => expect(new Date('2018-01-01T13:00:00.000Z')).not.toBeDate()).toThrowErrorMatchingSnapshot();

diff --git a/src/matchers/toBeEven/index.test.js b/src/matchers/toBeEven/index.test.js
@@ -9,38 +9,23 @@ describe('.toBeEven', () => {
     expect(2).toBeEven();
   });
 
-  each([
-    [false],
-    [true],
-    [''],
-    [1],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('fails when not given an even number', given => {
-    expect(() => expect(given).toBeEven()).toThrowErrorMatchingSnapshot();
-  });
+  each([[false], [true], [''], [1], [{}], [() => {}], [undefined], [null], [NaN]]).test(
+    'fails when not given an even number',
+    given => {
+      expect(() => expect(given).toBeEven()).toThrowErrorMatchingSnapshot();
+    }
+  );
 });
 
 describe('.not.toBeEven', () => {
   test('fails when given an even number', () => {
     expect(() => expect(2).not.toBeEven()).toThrowErrorMatchingSnapshot();
   });
 
-  each([
-    [false],
-    [true],
-    [''],
-    [1],
-    [[]],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('passes when not given an even number: %s', given => {
-    expect(given).not.toBeEven();
-  });
+  each([[false], [true], [''], [1], [[]], [{}], [() => {}], [undefined], [null], [NaN]]).test(
+    'passes when not given an even number: %s',
+    given => {
+      expect(given).not.toBeEven();
+    }
+  );
 });
diff --git a/src/matchers/toBeExtensible/index.test.js b/src/matchers/toBeExtensible/index.test.js
@@ -9,33 +9,21 @@ describe('.toBeExtensible', () => {
     expect(given).toBeExtensible();
   });
 
-  each([
-    [false],
-    [''],
-    [0],
-    [undefined],
-    [null],
-    [NaN],
-    [Object.seal({})],
-    [Object.freeze({})]
-  ]).test('fails when not given an extensible object: %s', given => {
-    expect(() => expect(given).toBeExtensible()).toThrowErrorMatchingSnapshot();
-  });
+  each([[false], [''], [0], [undefined], [null], [NaN], [Object.seal({})], [Object.freeze({})]]).test(
+    'fails when not given an extensible object: %s',
+    given => {
+      expect(() => expect(given).toBeExtensible()).toThrowErrorMatchingSnapshot();
+    }
+  );
 });
 
 describe('.not.toBeExtensible', () => {
-  each([
-    [false],
-    [''],
-    [0],
-    [undefined],
-    [null],
-    [NaN],
-    [Object.seal({})],
-    [Object.freeze({})]
-  ]).test('passes when not given extensible object: %s', given => {
-    expect(given).not.toBeExtensible();
-  });
+  each([[false], [''], [0], [undefined], [null], [NaN], [Object.seal({})], [Object.freeze({})]]).test(
+    'passes when not given extensible object: %s',
+    given => {
+      expect(given).not.toBeExtensible();
+    }
+  );
 
   each([[{}], [[]], [() => {}]]).test('fails when given an extensible object: %s', given => {
     expect(() => expect(given).not.toBeExtensible()).toThrowErrorMatchingSnapshot();

diff --git a/src/matchers/toBeExtensible/predicate.test.js b/src/matchers/toBeExtensible/predicate.test.js
@@ -6,16 +6,10 @@ describe('toBeExpected Predicate', () => {
     expect(predicate(given)).toBe(true);
   });
 
-  each([
-    [false],
-    [''],
-    [0],
-    [undefined],
-    [null],
-    [NaN],
-    [Object.seal({})],
-    [Object.freeze({})]
-  ]).test('returns false when given non-extensible object: %s', given => {
-    expect(predicate(given)).toBe(false);
-  });
+  each([[false], [''], [0], [undefined], [null], [NaN], [Object.seal({})], [Object.freeze({})]]).test(
+    'returns false when given non-extensible object: %s',
+    given => {
+      expect(predicate(given)).toBe(false);
+    }
+  );
 });
diff --git a/src/matchers/toBeNumber/index.test.js b/src/matchers/toBeNumber/index.test.js
@@ -21,18 +21,12 @@ describe('.toBeNumber', () => {
 });
 
 describe('.not.toBeNumber', () => {
-  each([
-    [false],
-    [true],
-    [[]],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    ['10']
-  ]).test('passes when not given a number: %s', given => {
-    expect(given).not.toBeNumber();
-  });
+  each([[false], [true], [[]], [{}], [() => {}], [undefined], [null], ['10']]).test(
+    'passes when not given a number: %s',
+    given => {
+      expect(given).not.toBeNumber();
+    }
+  );
 
   test('fails when given a number', () => {
     expect(() => expect(1).not.toBeNumber()).toThrowErrorMatchingSnapshot();

diff --git a/src/matchers/toBeOdd/index.test.js b/src/matchers/toBeOdd/index.test.js
@@ -9,36 +9,21 @@ describe('.toBeOdd', () => {
     expect(1).toBeOdd();
   });
 
-  each([
-    [false],
-    [true],
-    [''],
-    [2],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('fails when given not given an odd number', given => {
-    expect(() => expect(given).toBeOdd()).toThrowErrorMatchingSnapshot();
-  });
+  each([[false], [true], [''], [2], [{}], [() => {}], [undefined], [null], [NaN]]).test(
+    'fails when given not given an odd number',
+    given => {
+      expect(() => expect(given).toBeOdd()).toThrowErrorMatchingSnapshot();
+    }
+  );
 });
 
 describe('.not.toBeOdd', () => {
-  each([
-    [false],
-    [true],
-    [''],
-    [2],
-    [[]],
-    [{}],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN]
-  ]).test('passes when not given an odd number: %s', given => {
-    expect(given).not.toBeOdd();
-  });
+  each([[false], [true], [''], [2], [[]], [{}], [() => {}], [undefined], [null], [NaN]]).test(
+    'passes when not given an odd number: %s',
+    given => {
+      expect(given).not.toBeOdd();
+    }
+  );
 
   test('fails when given an odd number', () => {
     expect(() => expect(1).not.toBeOdd()).toThrowErrorMatchingSnapshot();

diff --git a/src/matchers/toBeOneOf/predicate.test.js b/src/matchers/toBeOneOf/predicate.test.js
@@ -13,15 +13,10 @@ describe('.toBeOneOf', () => {
     expect(predicate(value, [1, 2, { hello: 'world' }, ['foo']])).toBe(true);
   });
 
-  each([
-    [0],
-    [null],
-    [undefined],
-    [false],
-    [''],
-    [{ hello: 'world' }],
-    [['foo']]
-  ]).test('returns false when value: %s is not in given array', value => {
-    expect(predicate(value, [1, 2, 3])).toBe(false);
-  });
+  each([[0], [null], [undefined], [false], [''], [{ hello: 'world' }], [['foo']]]).test(
+    'returns false when value: %s is not in given array',
+    value => {
+      expect(predicate(value, [1, 2, 3])).toBe(false);
+    }
+  );
 });
diff --git a/src/matchers/toBePositive/index.test.js b/src/matchers/toBePositive/index.test.js
@@ -15,21 +15,12 @@ describe('.toBePositive', () => {
 });
 
 describe('.not.toBePositive', () => {
-  each([
-    [false],
-    [''],
-    [-1],
-    [0],
-    [{}],
-    [[]],
-    [() => {}],
-    [undefined],
-    [null],
-    [NaN],
-    [Infinity]
-  ]).test('passes when not given a positive number: %s', given => {
-    expect(given).not.toBePositive();
-  });
+  each([[false], [''], [-1], [0], [{}], [[]], [() => {}], [undefined], [null], [NaN], [Infinity]]).test(
+    'passes when not given a positive number: %s',
+    given => {
+      expect(given).not.toBePositive();
+    }
+  );
 
   test('fails when given a positive number', () => {
     expect(() => expect(5).not.toBePositive()).toThrowErrorMatchingSnapshot();