eslint-plugin-jest 27.2.0 → 27.2.2

package/lib/rules/__tests__/require-hook.test.js

@@ -0,0 +1,403 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _requireHook = _interopRequireDefault(require("../require-hook"));
+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('require-hook', _requireHook.default, {
+  valid: ['describe()', 'describe("just a title")', (0, _dedent.default)`
+      describe('a test', () =>
+        test('something', () => {
+          expect(true).toBe(true);
+        }));
+    `, (0, _dedent.default)`
+      test('it', () => {
+        //
+      });
+    `, (0, _dedent.default)`
+      const { myFn } = require('../functions');
+
+      test('myFn', () => {
+        expect(myFn()).toBe(1);
+      });
+    `, {
+    code: (0, _dedent.default)`
+        import { myFn } from '../functions';
+
+        test('myFn', () => {
+          expect(myFn()).toBe(1);
+        });
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    }
+  }, (0, _dedent.default)`
+      class MockLogger {
+        log() {}
+      }
+
+      test('myFn', () => {
+        expect(myFn()).toBe(1);
+      });
+    `, (0, _dedent.default)`
+      const { myFn } = require('../functions');
+
+      describe('myFn', () => {
+        it('returns one', () => {
+          expect(myFn()).toBe(1);
+        });
+      });
+    `, (0, _dedent.default)`
+      describe('some tests', () => {
+        it('is true', () => {
+          expect(true).toBe(true);
+        });
+      });
+    `, (0, _dedent.default)`
+      describe('some tests', () => {
+        it('is true', () => {
+          expect(true).toBe(true);
+        });
+
+        describe('more tests', () => {
+          it('is false', () => {
+            expect(true).toBe(false);
+          });
+        });
+      });
+    `, (0, _dedent.default)`
+      describe('some tests', () => {
+        let consoleLogSpy;
+
+        beforeEach(() => {
+          consoleLogSpy = jest.spyOn(console, 'log'); 
+        });
+
+        it('prints a message', () => {
+          printMessage('hello world');
+
+          expect(consoleLogSpy).toHaveBeenCalledWith('hello world');
+        });
+      });
+    `, (0, _dedent.default)`
+      let consoleErrorSpy = null; 
+
+      beforeEach(() => {
+        consoleErrorSpy = jest.spyOn(console, 'error');
+      });
+    `, (0, _dedent.default)`
+      let consoleErrorSpy = undefined; 
+
+      beforeEach(() => {
+        consoleErrorSpy = jest.spyOn(console, 'error');
+      });
+    `, (0, _dedent.default)`
+      describe('some tests', () => {
+        beforeEach(() => {
+          setup();
+        });
+      });
+    `, (0, _dedent.default)`
+      beforeEach(() => {
+        initializeCityDatabase();
+      });
+
+      afterEach(() => {
+        clearCityDatabase();
+      });
+
+      test('city database has Vienna', () => {
+        expect(isCity('Vienna')).toBeTruthy();
+      });
+
+      test('city database has San Juan', () => {
+        expect(isCity('San Juan')).toBeTruthy();
+      });
+    `, (0, _dedent.default)`
+      describe('cities', () => {
+        beforeEach(() => {
+          initializeCityDatabase();
+        });
+
+        test('city database has Vienna', () => {
+          expect(isCity('Vienna')).toBeTruthy();
+        });
+
+        test('city database has San Juan', () => {
+          expect(isCity('San Juan')).toBeTruthy();
+        });
+
+        afterEach(() => {
+          clearCityDatabase();
+        });
+      });
+    `, {
+    code: (0, _dedent.default)`
+        enableAutoDestroy(afterEach);
+        
+        describe('some tests', () => {
+          it('is false', () => {
+            expect(true).toBe(true);
+          });
+        });
+      `,
+    options: [{
+      allowedFunctionCalls: ['enableAutoDestroy']
+    }]
+  }],
+  invalid: [{
+    code: 'setup();',
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        describe('some tests', () => {
+          setup();
+        });
+      `,
+    errors: [{
+      messageId: 'useHook',
+      line: 2,
+      column: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        let { setup } = require('./test-utils');
+
+        describe('some tests', () => {
+          setup();
+        });
+      `,
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }, {
+      messageId: 'useHook',
+      line: 4,
+      column: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        describe('some tests', () => {
+          setup();
+
+          it('is true', () => {
+            expect(true).toBe(true);
+          });
+
+          describe('more tests', () => {
+            setup();
+
+            it('is false', () => {
+              expect(true).toBe(false);
+            });
+          });
+        });
+      `,
+    errors: [{
+      messageId: 'useHook',
+      line: 2,
+      column: 3
+    }, {
+      messageId: 'useHook',
+      line: 9,
+      column: 5
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        let consoleErrorSpy = jest.spyOn(console, 'error');
+
+        describe('when loading cities from the api', () => {
+          let consoleWarnSpy = jest.spyOn(console, 'warn');
+        });
+      `,
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }, {
+      messageId: 'useHook',
+      line: 4,
+      column: 3
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        let consoleErrorSpy = null;
+
+        describe('when loading cities from the api', () => {
+          let consoleWarnSpy = jest.spyOn(console, 'warn');
+        });
+      `,
+    errors: [{
+      messageId: 'useHook',
+      line: 4,
+      column: 3
+    }]
+  }, {
+    code: 'let value = 1',
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }]
+  }, {
+    code: "let consoleErrorSpy, consoleWarnSpy = jest.spyOn(console, 'error');",
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }]
+  }, {
+    code: "let consoleErrorSpy = jest.spyOn(console, 'error'), consoleWarnSpy;",
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        import { database, isCity } from '../database';
+        import { loadCities } from '../api';
+
+        jest.mock('../api');
+
+        const initializeCityDatabase = () => {
+          database.addCity('Vienna');
+          database.addCity('San Juan');
+          database.addCity('Wellington');
+        };
+
+        const clearCityDatabase = () => {
+          database.clear();
+        };
+
+        initializeCityDatabase();
+
+        test('that persists cities', () => {
+          expect(database.cities.length).toHaveLength(3);
+        });
+
+        test('city database has Vienna', () => {
+          expect(isCity('Vienna')).toBeTruthy();
+        });
+
+        test('city database has San Juan', () => {
+          expect(isCity('San Juan')).toBeTruthy();
+        });
+
+        describe('when loading cities from the api', () => {
+          let consoleWarnSpy = jest.spyOn(console, 'warn');
+
+          loadCities.mockResolvedValue(['Wellington', 'London']);
+
+          it('does not duplicate cities', async () => {
+            await database.loadCities();
+
+            expect(database.cities).toHaveLength(4);
+          });
+
+          it('logs any duplicates', async () => {
+            await database.loadCities();
+
+            expect(consoleWarnSpy).toHaveBeenCalledWith(
+              'Ignored duplicate cities: Wellington',
+            );
+          });
+        });
+
+        clearCityDatabase();
+      `,
+    parserOptions: {
+      sourceType: 'module'
+    },
+    errors: [{
+      messageId: 'useHook',
+      line: 16,
+      column: 1
+    }, {
+      messageId: 'useHook',
+      line: 31,
+      column: 3
+    }, {
+      messageId: 'useHook',
+      line: 33,
+      column: 3
+    }, {
+      messageId: 'useHook',
+      line: 50,
+      column: 1
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        enableAutoDestroy(afterEach);
+        
+        describe('some tests', () => {
+          it('is false', () => {
+            expect(true).toBe(true);
+          });
+        });
+      `,
+    options: [{
+      allowedFunctionCalls: ['someOtherName']
+    }],
+    errors: [{
+      messageId: 'useHook',
+      line: 1,
+      column: 1
+    }]
+  }]
+});
+new _utils.TSESLint.RuleTester({
+  parser: require.resolve('@typescript-eslint/parser')
+}).run('require-hook: typescript edition', _requireHook.default, {
+  valid: [(0, _dedent.default)`
+      import { myFn } from '../functions';
+
+      // todo: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/56545
+      declare module 'eslint' {
+        namespace ESLint {
+          interface LintResult {
+            fatalErrorCount: number;
+          }
+        }
+      }
+
+      test('myFn', () => {
+        expect(myFn()).toBe(1);
+      });
+    `],
+  invalid: [{
+    code: (0, _dedent.default)`
+        import { setup } from '../test-utils';
+
+        // todo: https://github.com/DefinitelyTyped/DefinitelyTyped/pull/56545
+        declare module 'eslint' {
+          namespace ESLint {
+            interface LintResult {
+              fatalErrorCount: number;
+            }
+          }
+        }
+
+        describe('some tests', () => {
+          setup();
+        });
+      `,
+    errors: [{
+      messageId: 'useHook',
+      line: 13,
+      column: 3
+    }]
+  }]
+});

package/lib/rules/__tests__/require-to-throw-message.test.js

@@ -0,0 +1,108 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _requireToThrowMessage = _interopRequireDefault(require("../require-to-throw-message"));
+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('require-to-throw-message', _requireToThrowMessage.default, {
+  valid: [
+  // String
+  "expect(() => { throw new Error('a'); }).toThrow('a');", "expect(() => { throw new Error('a'); }).toThrowError('a');", (0, _dedent.default)`
+      test('string', async () => {
+        const throwErrorAsync = async () => { throw new Error('a') };
+        await expect(throwErrorAsync()).rejects.toThrow('a');
+        await expect(throwErrorAsync()).rejects.toThrowError('a');
+      })
+    `,
+  // Template literal
+  "const a = 'a'; expect(() => { throw new Error('a'); }).toThrow(`${a}`);", "const a = 'a'; expect(() => { throw new Error('a'); }).toThrowError(`${a}`);", (0, _dedent.default)`
+      test('Template literal', async () => {
+        const a = 'a';
+        const throwErrorAsync = async () => { throw new Error('a') };
+        await expect(throwErrorAsync()).rejects.toThrow(\`\${a}\`);
+        await expect(throwErrorAsync()).rejects.toThrowError(\`\${a}\`);
+      })
+    `,
+  // Regex
+  "expect(() => { throw new Error('a'); }).toThrow(/^a$/);", "expect(() => { throw new Error('a'); }).toThrowError(/^a$/);", (0, _dedent.default)`
+      test('Regex', async () => {
+        const throwErrorAsync = async () => { throw new Error('a') };
+        await expect(throwErrorAsync()).rejects.toThrow(/^a$/);
+        await expect(throwErrorAsync()).rejects.toThrowError(/^a$/);
+      })
+    `,
+  // Function
+  "expect(() => { throw new Error('a'); }).toThrow((() => { return 'a'; })());", "expect(() => { throw new Error('a'); }).toThrowError((() => { return 'a'; })());", (0, _dedent.default)`
+      test('Function', async () => {
+        const throwErrorAsync = async () => { throw new Error('a') };
+        const fn = () => { return 'a'; };
+        await expect(throwErrorAsync()).rejects.toThrow(fn());
+        await expect(throwErrorAsync()).rejects.toThrowError(fn());
+      })
+    `,
+  // Allow no message for `not`.
+  "expect(() => { throw new Error('a'); }).not.toThrow();", "expect(() => { throw new Error('a'); }).not.toThrowError();", (0, _dedent.default)`
+      test('Allow no message for "not"', async () => {
+        const throwErrorAsync = async () => { throw new Error('a') };
+        await expect(throwErrorAsync()).resolves.not.toThrow();
+        await expect(throwErrorAsync()).resolves.not.toThrowError();
+      })
+    `, 'expect(a);'],
+  invalid: [
+  // Empty toThrow
+  {
+    code: "expect(() => { throw new Error('a'); }).toThrow();",
+    errors: [{
+      messageId: 'addErrorMessage',
+      data: {
+        matcherName: 'toThrow'
+      },
+      column: 41,
+      line: 1
+    }]
+  },
+  // Empty toThrowError
+  {
+    code: "expect(() => { throw new Error('a'); }).toThrowError();",
+    errors: [{
+      messageId: 'addErrorMessage',
+      data: {
+        matcherName: 'toThrowError'
+      },
+      column: 41,
+      line: 1
+    }]
+  },
+  // Empty rejects.toThrow / rejects.toThrowError
+  {
+    code: (0, _dedent.default)`
+        test('empty rejects.toThrow', async () => {
+          const throwErrorAsync = async () => { throw new Error('a') };
+          await expect(throwErrorAsync()).rejects.toThrow();
+          await expect(throwErrorAsync()).rejects.toThrowError();
+        })
+      `,
+    errors: [{
+      messageId: 'addErrorMessage',
+      data: {
+        matcherName: 'toThrow'
+      },
+      column: 43,
+      line: 3
+    }, {
+      messageId: 'addErrorMessage',
+      data: {
+        matcherName: 'toThrowError'
+      },
+      column: 43,
+      line: 4
+    }]
+  }]
+});