eslint-plugin-jest 27.2.0 → 27.2.2

package/lib/rules/__tests__/no-conditional-expect.test.js

@@ -0,0 +1,696 @@
+"use strict";
+
+var _utils = require("@typescript-eslint/utils");
+var _dedent = _interopRequireDefault(require("dedent"));
+var _noConditionalExpect = _interopRequireDefault(require("../no-conditional-expect"));
+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: 2019
+  }
+});
+ruleTester.run('common tests', _noConditionalExpect.default, {
+  valid: [`
+      it('foo', () => {
+        expect(1).toBe(2);
+      });
+    `, `
+      it('foo', () => {
+        expect(!true).toBe(false);
+      });
+    `],
+  invalid: []
+});
+ruleTester.run('logical conditions', _noConditionalExpect.default, {
+  valid: [`
+      it('foo', () => {
+        process.env.FAIL && setNum(1);
+
+        expect(num).toBe(2);
+      });
+    `, `
+      function getValue() {
+        let num = 2;
+
+        process.env.FAIL && setNum(1);
+
+        return num;
+      }
+
+      it('foo', () => {
+        expect(getValue()).toBe(2);
+      });
+    `, `
+      it('foo', () => {
+        process.env.FAIL || setNum(1);
+
+        expect(num).toBe(2);
+      });
+    `, `
+      function getValue() {
+        let num = 2;
+
+        process.env.FAIL || setNum(1);
+
+        return num;
+      }
+
+      it('foo', () => {
+        expect(getValue()).toBe(2);
+      });
+    `],
+  invalid: [{
+    code: `
+        it('foo', () => {
+          something && expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          a || b && expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          (a || b) && expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          a || (b && expect(something).toHaveBeenCalled());
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          a && b && expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          a && b || expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          (a && b) || expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          something && expect(something).toHaveBeenCalled(); 
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          something || expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each\`\`('foo', () => {
+          something || expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each()('foo', () => {
+          something || expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          something || expect(something).toHaveBeenCalled(); 
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }]
+});
+ruleTester.run('conditional conditions', _noConditionalExpect.default, {
+  valid: [`
+      it('foo', () => {
+        const num = process.env.FAIL ? 1 : 2;
+
+        expect(num).toBe(2);
+      });
+    `, `
+      function getValue() {
+        return process.env.FAIL ? 1 : 2
+      }
+
+      it('foo', () => {
+        expect(getValue()).toBe(2);
+      });
+    `],
+  invalid: [{
+    code: `
+        it('foo', () => {
+          something ? expect(something).toHaveBeenCalled() : noop();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          something ? expect(something).toHaveBeenCalled() : noop();
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          something ? noop() : expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each\`\`('foo', () => {
+          something ? noop() : expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each()('foo', () => {
+          something ? noop() : expect(something).toHaveBeenCalled();
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          something ? noop() : expect(something).toHaveBeenCalled();
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }]
+});
+ruleTester.run('switch conditions', _noConditionalExpect.default, {
+  valid: [`
+      it('foo', () => {
+        let num;
+
+        switch(process.env.FAIL) {
+          case true:
+            num = 1;
+            break;
+          case false:
+            num = 2;
+            break;
+        }
+
+        expect(num).toBe(2);
+      });
+    `, `
+      function getValue() {
+        switch(process.env.FAIL) {
+          case true:
+            return 1;
+          case false:
+            return 2;
+        }
+      }
+
+      it('foo', () => {
+        expect(getValue()).toBe(2);
+      });
+    `],
+  invalid: [{
+    code: `
+        it('foo', () => {
+          switch(something) {
+            case 'value':
+              break;
+            default:
+              expect(something).toHaveBeenCalled();
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          switch(something) {
+            case 'value':
+              expect(something).toHaveBeenCalled();
+            default:
+              break;
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each\`\`('foo', () => {
+          switch(something) {
+            case 'value':
+              expect(something).toHaveBeenCalled();
+            default:
+              break;
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each()('foo', () => {
+          switch(something) {
+            case 'value':
+              expect(something).toHaveBeenCalled();
+            default:
+              break;
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          switch(something) {
+            case 'value':
+              break;
+            default:
+              expect(something).toHaveBeenCalled();
+          }
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }]
+});
+ruleTester.run('if conditions', _noConditionalExpect.default, {
+  valid: [`
+      it('foo', () => {
+        let num = 2;
+
+        if(process.env.FAIL) {
+          num = 1;
+        }
+
+        expect(num).toBe(2);
+      });
+    `, `
+      function getValue() {
+        if(process.env.FAIL) {
+          return 1;
+        }
+
+        return 2;
+      }
+
+      it('foo', () => {
+        expect(getValue()).toBe(2);
+      });
+    `],
+  invalid: [{
+    code: `
+        it('foo', () => {
+          if(doSomething) {
+            expect(something).toHaveBeenCalled();
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it('foo', () => {
+          if(!doSomething) {
+            // do nothing
+          } else {
+            expect(something).toHaveBeenCalled();
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each\`\`('foo', () => {
+          if(!doSomething) {
+            // do nothing
+          } else {
+            expect(something).toHaveBeenCalled();
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each()('foo', () => {
+          if(!doSomething) {
+            // do nothing
+          } else {
+            expect(something).toHaveBeenCalled();
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          if(doSomething) {
+            expect(something).toHaveBeenCalled();
+          }
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          if(!doSomething) {
+            // do nothing
+          } else {
+            expect(something).toHaveBeenCalled();
+          }
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }]
+});
+ruleTester.run('catch conditions', _noConditionalExpect.default, {
+  valid: [`
+      it('foo', () => {
+        try {
+          // do something
+        } catch {
+          // ignore errors
+        } finally {
+          expect(something).toHaveBeenCalled();
+        }
+      });
+    `, `
+      it('foo', () => {
+        try {
+          // do something
+        } catch {
+          // ignore errors
+        }
+
+        expect(something).toHaveBeenCalled();
+      });
+    `, `
+      function getValue() {
+        try {
+          // do something
+        } catch {
+          // ignore errors
+        } finally {
+          expect(something).toHaveBeenCalled();
+        }
+      }
+
+      it('foo', getValue);
+    `, `
+      function getValue() {
+        try {
+          process.env.FAIL.toString();
+
+          return 1;
+        } catch {
+          return 2;
+        }
+      }
+
+      it('foo', () => {
+        expect(getValue()).toBe(2);
+      });
+    `],
+  invalid: [{
+    code: `
+        it('foo', () => {
+          try {
+  
+          } catch (err) {
+            expect(err).toMatch('Error');
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each\`\`('foo', () => {
+          try {
+  
+          } catch (err) {
+            expect(err).toMatch('Error');
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.each()('foo', () => {
+          try {
+  
+          } catch (err) {
+            expect(err).toMatch('Error');
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.skip.each\`\`('foo', () => {
+          try {
+  
+          } catch (err) {
+            expect(err).toMatch('Error');
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        it.skip.each()('foo', () => {
+          try {
+  
+          } catch (err) {
+            expect(err).toMatch('Error');
+          }
+        })
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: `
+        function getValue() {
+          try {
+            // do something
+          } catch {
+            expect(something).toHaveBeenCalled();
+          }
+        }
+
+        it('foo', getValue);
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }]
+});
+ruleTester.run('promises', _noConditionalExpect.default, {
+  valid: [`
+      it('works', async () => {
+        try {
+          await Promise.resolve().then(() => {
+            throw new Error('oh noes!');
+          });
+        } catch {
+          // ignore errors
+        } finally {
+          expect(something).toHaveBeenCalled();
+        }
+      });
+    `, `
+      it('works', async () => {
+        await doSomething().catch(error => error);
+
+        expect(error).toBeInstanceOf(Error);
+      });
+    `, `
+      it('works', async () => {
+        try {
+          await Promise.resolve().then(() => {
+            throw new Error('oh noes!');
+          });
+        } catch {
+          // ignore errors
+        }
+
+        expect(something).toHaveBeenCalled();
+      });
+    `],
+  invalid: [{
+    code: (0, _dedent.default)`
+        it('works', async () => {
+          await Promise.resolve()
+            .then(() => { throw new Error('oh noes!'); })
+            .catch(error => expect(error).toBeInstanceOf(Error));
+        });
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('works', async () => {
+          await Promise.resolve()
+            .then(() => { throw new Error('oh noes!'); })
+            .catch(error => expect(error).toBeInstanceOf(Error))
+            .then(() => { throw new Error('oh noes!'); })
+            .catch(error => expect(error).toBeInstanceOf(Error))
+            .then(() => { throw new Error('oh noes!'); })
+            .catch(error => expect(error).toBeInstanceOf(Error));
+        });
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('works', async () => {
+          await Promise.resolve()
+            .catch(error => expect(error).toBeInstanceOf(Error))
+            .catch(error => expect(error).toBeInstanceOf(Error))
+            .catch(error => expect(error).toBeInstanceOf(Error));
+        });
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('works', async () => {
+          await Promise.resolve()
+            .catch(error => expect(error).toBeInstanceOf(Error))
+            .then(() => { throw new Error('oh noes!'); })
+            .then(() => { throw new Error('oh noes!'); })
+            .then(() => { throw new Error('oh noes!'); });
+        });
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('works', async () => {
+          await somePromise
+            .then(() => { throw new Error('oh noes!'); })
+            .catch(error => expect(error).toBeInstanceOf(Error));
+        });
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }, {
+    code: (0, _dedent.default)`
+        it('works', async () => {
+          await somePromise.catch(error => expect(error).toBeInstanceOf(Error));
+        });
+      `,
+    errors: [{
+      messageId: 'conditionalExpect'
+    }]
+  }]
+});