eslint-plugin-jest 27.2.0 → 27.2.2

package/lib/rules/__tests__/no-interpolation-in-snapshots.test.js

@@ -0,0 +1,58 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _noInterpolationInSnapshots = _interopRequireDefault(require("../no-interpolation-in-snapshots"));
+var _testUtils = require("./test-utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ruleTester = new _utils.TSESLint.RuleTester({
+  parser: _testUtils.espreeParser,
+  parserOptions: {
+    ecmaVersion: 2017
+  }
+});
+ruleTester.run('no-interpolation-in-snapshots', _noInterpolationInSnapshots.default, {
+  valid: ['expect("something").toEqual("else");', 'expect(something).toMatchInlineSnapshot();', 'expect(something).toMatchInlineSnapshot(`No interpolation`);', 'expect(something).toMatchInlineSnapshot({}, `No interpolation`);', 'expect(something);', 'expect(something).not;', 'expect.toHaveAssertions();', 'myObjectWants.toMatchInlineSnapshot({}, `${interpolated}`);', 'myObjectWants.toMatchInlineSnapshot({}, `${interpolated1} ${interpolated2}`);', 'toMatchInlineSnapshot({}, `${interpolated}`);', 'toMatchInlineSnapshot({}, `${interpolated1} ${interpolated2}`);', 'expect(something).toThrowErrorMatchingInlineSnapshot();', 'expect(something).toThrowErrorMatchingInlineSnapshot(`No interpolation`);'],
+  invalid: [{
+    code: 'expect(something).toMatchInlineSnapshot(`${interpolated}`);',
+    errors: [{
+      endColumn: 58,
+      column: 41,
+      messageId: 'noInterpolation'
+    }]
+  }, {
+    code: 'expect(something).not.toMatchInlineSnapshot(`${interpolated}`);',
+    errors: [{
+      endColumn: 62,
+      column: 45,
+      messageId: 'noInterpolation'
+    }]
+  }, {
+    code: 'expect(something).toMatchInlineSnapshot({}, `${interpolated}`);',
+    errors: [{
+      endColumn: 62,
+      column: 45,
+      messageId: 'noInterpolation'
+    }]
+  }, {
+    code: 'expect(something).not.toMatchInlineSnapshot({}, `${interpolated}`);',
+    errors: [{
+      endColumn: 66,
+      column: 49,
+      messageId: 'noInterpolation'
+    }]
+  }, {
+    code: 'expect(something).toThrowErrorMatchingInlineSnapshot(`${interpolated}`);',
+    errors: [{
+      endColumn: 71,
+      column: 54,
+      messageId: 'noInterpolation'
+    }]
+  }, {
+    code: 'expect(something).not.toThrowErrorMatchingInlineSnapshot(`${interpolated}`);',
+    errors: [{
+      endColumn: 75,
+      column: 58,
+      messageId: 'noInterpolation'
+    }]
+  }]
+});

package/lib/rules/__tests__/no-jasmine-globals.test.js

@@ -0,0 +1,206 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _noJasmineGlobals = _interopRequireDefault(require("../no-jasmine-globals"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ruleTester = new _utils.TSESLint.RuleTester();
+ruleTester.run('no-jasmine-globals', _noJasmineGlobals.default, {
+  valid: ['jest.spyOn()', 'jest.fn()', 'expect.extend()', 'expect.any()', 'it("foo", function () {})', 'test("foo", function () {})', 'foo()', `require('foo')('bar')`, '(function(){})()', 'function callback(fail) { fail() }', 'var spyOn = require("actions"); spyOn("foo")', 'function callback(pending) { pending() }'],
+  invalid: [{
+    code: 'spyOn(some, "object")',
+    output: null,
+    errors: [{
+      messageId: 'illegalGlobal',
+      data: {
+        global: 'spyOn',
+        replacement: 'jest.spyOn'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'spyOnProperty(some, "object")',
+    output: null,
+    errors: [{
+      messageId: 'illegalGlobal',
+      data: {
+        global: 'spyOnProperty',
+        replacement: 'jest.spyOn'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'fail()',
+    output: null,
+    errors: [{
+      messageId: 'illegalFail',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'pending()',
+    output: null,
+    errors: [{
+      messageId: 'illegalPending',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;',
+    output: 'jest.setTimeout(5000);',
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.DEFAULT_TIMEOUT_INTERVAL = function() {}',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.addMatchers(matchers)',
+    output: null,
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.addMatchers',
+        replacement: 'expect.extend'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.createSpy()',
+    output: null,
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.createSpy',
+        replacement: 'jest.fn'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.any()',
+    output: 'expect.any()',
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.any',
+        replacement: 'expect.any'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.anything()',
+    output: 'expect.anything()',
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.anything',
+        replacement: 'expect.anything'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.arrayContaining()',
+    output: 'expect.arrayContaining()',
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.arrayContaining',
+        replacement: 'expect.arrayContaining'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.objectContaining()',
+    output: 'expect.objectContaining()',
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.objectContaining',
+        replacement: 'expect.objectContaining'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.stringMatching()',
+    output: 'expect.stringMatching()',
+    errors: [{
+      messageId: 'illegalMethod',
+      data: {
+        method: 'jasmine.stringMatching',
+        replacement: 'expect.stringMatching'
+      },
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.getEnv()',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.empty()',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.falsy()',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.truthy()',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.arrayWithExactContents()',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.clock()',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }, {
+    code: 'jasmine.MAX_PRETTY_PRINT_ARRAY_LENGTH = 42',
+    output: null,
+    errors: [{
+      messageId: 'illegalJasmine',
+      column: 1,
+      line: 1
+    }]
+  }]
+});

package/lib/rules/__tests__/no-large-snapshots.test.js

@@ -0,0 +1,237 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _noLargeSnapshots = _interopRequireDefault(require("../no-large-snapshots"));
+var _testUtils = require("./test-utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ruleTester = new _utils.TSESLint.RuleTester({
+  parser: _testUtils.espreeParser,
+  parserOptions: {
+    ecmaVersion: 2015
+  }
+});
+const generateSnapshotLines = lines => `\`\n${'line\n'.repeat(lines)}\``;
+const generateExportsSnapshotString = (lines, title = 'a big component 1') => `exports[\`${title}\`] = ${generateSnapshotLines(lines - 1)};`;
+const generateExpectInlineSnapsCode = (lines, matcher) => `expect(something).${matcher}(${generateSnapshotLines(lines)});`;
+ruleTester.run('no-large-snapshots', _noLargeSnapshots.default, {
+  valid: ['expect(something)', 'expect(something).toBe(1)', 'expect(something).toMatchInlineSnapshot', 'expect(something).toMatchInlineSnapshot()', {
+    filename: 'mock.js',
+    code: generateExpectInlineSnapsCode(2, 'toMatchInlineSnapshot')
+  }, {
+    filename: 'mock.js',
+    code: generateExpectInlineSnapsCode(2, 'toThrowErrorMatchingInlineSnapshot')
+  }, {
+    filename: 'mock.jsx',
+    code: generateExpectInlineSnapsCode(20, 'toMatchInlineSnapshot'),
+    options: [{
+      maxSize: 19,
+      inlineMaxSize: 21
+    }]
+  }, {
+    filename: 'mock.jsx',
+    code: generateExpectInlineSnapsCode(60, 'toMatchInlineSnapshot'),
+    options: [{
+      maxSize: 61
+    }]
+  }, {
+    filename: 'mock.jsx',
+    code: (0, _dedent.default)`
+        expect(
+          functionUnderTest(
+            arg1,
+            arg2,
+            arg3
+          )
+        ).toMatchInlineSnapshot(${generateSnapshotLines(60)});
+      `,
+    options: [{
+      maxSize: 61
+    }]
+  }, {
+    // "should not report if node has fewer lines of code than limit"
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(20)
+  }, {
+    // "it should not report snapshots that are allowed to be large"
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(58),
+    options: [{
+      allowedSnapshots: {
+        '/mock-component.jsx.snap': ['a big component 1']
+      }
+    }]
+  }, {
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(20),
+    options: [{
+      maxSize: 21,
+      inlineMaxSize: 19
+    }]
+  }],
+  invalid: [{
+    filename: 'mock.js',
+    code: generateExpectInlineSnapsCode(50, 'toMatchInlineSnapshot'),
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 51
+      }
+    }]
+  }, {
+    filename: 'mock.js',
+    code: generateExpectInlineSnapsCode(50, 'toThrowErrorMatchingInlineSnapshot'),
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 51
+      }
+    }]
+  }, {
+    filename: 'mock.js',
+    code: generateExpectInlineSnapsCode(50, 'toThrowErrorMatchingInlineSnapshot'),
+    options: [{
+      maxSize: 51,
+      inlineMaxSize: 50
+    }],
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 51
+      }
+    }]
+  }, {
+    // "it should return an empty object for non snapshot files"
+    filename: 'mock.jsx',
+    code: generateExpectInlineSnapsCode(50, 'toMatchInlineSnapshot'),
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 51
+      }
+    }]
+  }, {
+    // "should report if node has more than 50 lines of code, and no sizeThreshold option is passed"
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(52),
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 52
+      }
+    }]
+  }, {
+    // "should report if node has more lines of code than number given in sizeThreshold option"
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(100),
+    options: [{
+      maxSize: 70
+    }],
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 70,
+        lineCount: 100
+      }
+    }]
+  }, {
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(100),
+    options: [{
+      maxSize: 70,
+      inlineMaxSize: 101
+    }],
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 70,
+        lineCount: 100
+      }
+    }]
+  }, {
+    // "should report if maxSize is zero"
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(1),
+    options: [{
+      maxSize: 0
+    }],
+    errors: [{
+      messageId: 'noSnapshot',
+      data: {
+        lineLimit: 0,
+        lineCount: 1
+      }
+    }]
+  }, {
+    // "it should report if file is not allowed"
+    filename: '/mock-component.jsx.snap',
+    code: generateExportsSnapshotString(58),
+    options: [{
+      allowedSnapshots: {
+        '/another-mock-component.jsx.snap': [/a big component \d+/u]
+      }
+    }],
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 58
+      }
+    }]
+  }, {
+    // "should not report allowed large snapshots based on regexp"
+    filename: '/mock-component.jsx.snap',
+    code: [generateExportsSnapshotString(58, 'a big component w/ text'), generateExportsSnapshotString(58, 'a big component 2')].join('\n\n'),
+    options: [{
+      allowedSnapshots: {
+        '/mock-component.jsx.snap': [/a big component \d+/u]
+      }
+    }],
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 58
+      }
+    }]
+  }, {
+    filename: '/mock-component.jsx.snap',
+    code: [generateExportsSnapshotString(58, 'a big component w/ text'), generateExportsSnapshotString(58, 'a big component 2')].join('\n\n'),
+    options: [{
+      allowedSnapshots: {
+        '/mock-component.jsx.snap': ['a big component 2']
+      }
+    }],
+    errors: [{
+      messageId: 'tooLongSnapshots',
+      data: {
+        lineLimit: 50,
+        lineCount: 58
+      }
+    }]
+  }]
+});
+describe('no-large-snapshots', () => {
+  describe('when "allowedSnapshots" option contains relative paths', () => {
+    it('should throw an exception', () => {
+      expect(() => {
+        const linter = new _utils.TSESLint.Linter();
+        linter.defineRule('no-large-snapshots', _noLargeSnapshots.default);
+        linter.verify('console.log()', {
+          rules: {
+            'no-large-snapshots': ['error', {
+              allowedSnapshots: {
+                'mock-component.jsx.snap': [/a big component \d+/u]
+              }
+            }]
+          }
+        }, 'mock-component.jsx.snap');
+      }).toThrow('All paths for allowedSnapshots must be absolute. You can use JS config and `path.resolve`');
+    });
+  });
+});

package/lib/rules/__tests__/no-mocks-import.test.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _noMocksImport = _interopRequireDefault(require("../no-mocks-import"));
+var _testUtils = require("./test-utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ruleTester = new _utils.TSESLint.RuleTester({
+  parser: _testUtils.espreeParser,
+  parserOptions: {
+    ecmaVersion: 2015
+  }
+});
+ruleTester.run('no-mocks-import', _noMocksImport.default, {
+  valid: [{
+    code: 'import something from "something"',
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, 'require("somethingElse")', 'require("./__mocks__.js")', 'require("./__mocks__x")', 'require("./__mocks__x/x")', 'require("./x__mocks__")', 'require("./x__mocks__/x")', 'require()', 'var path = "./__mocks__.js"; require(path)', 'entirelyDifferent(fn)'],
+  invalid: [{
+    code: 'require("./__mocks__")',
+    errors: [{
+      endColumn: 22,
+      column: 9,
+      messageId: 'noManualImport'
+    }]
+  }, {
+    code: 'require("./__mocks__/")',
+    errors: [{
+      endColumn: 23,
+      column: 9,
+      messageId: 'noManualImport'
+    }]
+  }, {
+    code: 'require("./__mocks__/index")',
+    errors: [{
+      endColumn: 28,
+      column: 9,
+      messageId: 'noManualImport'
+    }]
+  }, {
+    code: 'require("__mocks__")',
+    errors: [{
+      endColumn: 20,
+      column: 9,
+      messageId: 'noManualImport'
+    }]
+  }, {
+    code: 'require("__mocks__/")',
+    errors: [{
+      endColumn: 21,
+      column: 9,
+      messageId: 'noManualImport'
+    }]
+  }, {
+    code: 'require("__mocks__/index")',
+    errors: [{
+      endColumn: 26,
+      column: 9,
+      messageId: 'noManualImport'
+    }]
+  }, {
+    code: 'import thing from "./__mocks__/index"',
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      endColumn: 38,
+      column: 1,
+      messageId: 'noManualImport'
+    }]
+  }]
+});

package/lib/rules/__tests__/no-restricted-jest-methods.test.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _noRestrictedJestMethods = _interopRequireDefault(require("../no-restricted-jest-methods"));
+var _testUtils = require("./test-utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const ruleTester = new _utils.TSESLint.RuleTester({
+  parser: _testUtils.espreeParser,
+  parserOptions: {
+    ecmaVersion: 2017
+  }
+});
+ruleTester.run('no-restricted-jest-methods', _noRestrictedJestMethods.default, {
+  valid: ['jest', 'jest()', 'jest.mock()', 'expect(a).rejects;', 'expect(a);', {
+    code: (0, _dedent.default)`
+        import { jest } from '@jest/globals';
+
+        jest;
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }],
+  invalid: [{
+    code: 'jest.fn()',
+    options: [{
+      fn: null
+    }],
+    errors: [{
+      messageId: 'restrictedJestMethod',
+      data: {
+        message: null,
+        restriction: 'fn'
+      },
+      column: 6,
+      line: 1
+    }]
+  }, {
+    code: 'jest["fn"]()',
+    options: [{
+      fn: null
+    }],
+    errors: [{
+      messageId: 'restrictedJestMethod',
+      data: {
+        message: null,
+        restriction: 'fn'
+      },
+      column: 6,
+      line: 1
+    }]
+  }, {
+    code: 'jest.mock()',
+    options: [{
+      mock: 'Do not use mocks'
+    }],
+    errors: [{
+      messageId: 'restrictedJestMethodWithMessage',
+      data: {
+        message: 'Do not use mocks',
+        restriction: 'mock'
+      },
+      column: 6,
+      line: 1
+    }]
+  }, {
+    code: 'jest["mock"]()',
+    options: [{
+      mock: 'Do not use mocks'
+    }],
+    errors: [{
+      messageId: 'restrictedJestMethodWithMessage',
+      data: {
+        message: 'Do not use mocks',
+        restriction: 'mock'
+      },
+      column: 6,
+      line: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { jest } from '@jest/globals';
+
+        jest.advanceTimersByTime();
+      `,
+    options: [{
+      advanceTimersByTime: null
+    }],
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'restrictedJestMethod',
+      data: {
+        message: null,
+        restriction: 'advanceTimersByTime'
+      },
+      column: 6,
+      line: 3
+    }]
+  }]
+});