eslint-plugin-jest-formatting 1.0.0 → 2.0.0

package/tests/lib/ast-utils.spec.ts

@@ -0,0 +1,94 @@
+import { isValidParent, isTokenASemicolon, areTokensOnSameLine } from "../../src/ast-utils";
+import { AST } from "eslint";
+import { Node } from "estree";
+
+describe('isValidParent', () => {
+  test.each`
+    type                 | expected
+    ${'Program'}         | ${true}
+    ${'BlockStatement'}  | ${true}
+    ${'SwitchCase'}      | ${true}
+    ${'SwitchStatement'} | ${true}
+    ${'Statement'}       | ${false}
+  `('returns $expected for parent value of $type', ({ type, expected }) => {
+    expect(isValidParent(type)).toBe(expected);
+  });
+});
+
+describe('isTokenASemicolon', () => {
+  test.each`
+    type            | value  | expected
+    ${'Punctuator'} | ${';'} | ${true}
+    ${'Punctuator'} | ${'.'} | ${false}
+    ${'String'}     | ${';'} | ${false}
+  `('returns $expected for $type and $value', ({ type, value, expected}) => {
+    const token: AST.Token = {
+      type,
+      value,
+      range: [0, 1],
+      loc: {
+        start: {
+          line: 0,
+          column: 0,
+        },
+        end: {
+          line: 0,
+          column: 1,
+        }
+      }
+    };
+
+    expect(isTokenASemicolon(token)).toBe(expected);
+  });
+});
+
+describe('areTokensOnSameLine', () => {
+  const makeNode = (line: number): Node => {
+    return {
+      type: 'Identifier',
+      name: 'describe',
+      loc: {
+        start: {
+          line,
+          column: 10
+        },
+        end: {
+          line,
+          column: 10
+        },
+      },
+    };
+  };
+
+  const makeToken = (line: number): AST.Token => {
+    return {
+      type: 'Punctuator',
+      value: ';',
+      range: [0, 1],
+      loc: {
+        start: {
+          line,
+          column: 10
+        },
+        end: {
+          line,
+          column: 10
+        },
+      },
+    };
+  };
+
+  test.each`
+    left            | right           | expected
+    ${makeNode(1)}  | ${makeNode(1)}  | ${true}
+    ${makeNode(1)}  | ${makeToken(1)} | ${true}
+    ${makeToken(1)} | ${makeNode(1)}  | ${true}
+    ${makeToken(1)} | ${makeToken(1)} | ${true} 
+    ${makeNode(1)}  | ${makeNode(2)}  | ${false}
+    ${makeNode(1)}  | ${makeToken(2)} | ${false}
+    ${makeToken(1)} | ${makeNode(2)}  | ${false}
+    ${makeToken(1)} | ${makeToken(2)} | ${false} 
+  `('returns $expected for left node/token ending on $left.loc.end.line and right node/token starting on $right.loc.start.line', ({ left, right, expected }) => {
+    expect(areTokensOnSameLine(left, right)).toBe(expected);
+  });
+});

package/tests/lib/rules/padding-around-after-all-blocks.spec.js

@@ -71,13 +71,7 @@ describe('someText', () => {
 `;
 
 ruleTester.run('padding-before-after-all-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
@@ -114,7 +108,8 @@ ruleTester.run('padding-before-after-all-blocks', rule, {
           line: 18,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-after-each-blocks.spec.js

@@ -69,13 +69,7 @@ describe('someText', () => {
 `;
 
 ruleTester.run('padding-before-after-each-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
@@ -112,7 +106,8 @@ ruleTester.run('padding-before-after-each-blocks', rule, {
           line: 17,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-before-all-blocks.spec.js

@@ -71,13 +71,7 @@ describe('someText', () => {
 `;
 
 ruleTester.run('padding-before-before-all-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
@@ -114,7 +108,8 @@ ruleTester.run('padding-before-before-all-blocks', rule, {
           line: 18,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-before-each-blocks.spec.js

@@ -71,13 +71,7 @@ describe('someText', () => {
 `;
 
 ruleTester.run('padding-before-before-each-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
@@ -114,7 +108,8 @@ ruleTester.run('padding-before-before-each-blocks', rule, {
           line: 18,
           column: 3
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-describe-blocks.spec.js

@@ -39,7 +39,7 @@ describe('someText', () => {
   });
 });
 
-describe('someObject', () => {
+xdescribe('someObject', () => {
   // Another comment
   describe('some condition', () => {
     const anotherThing = 500;
@@ -49,7 +49,7 @@ describe('someObject', () => {
   });
 });
 
-describe('weird', () => {});
+fdescribe('weird', () => {});
 
 describe.skip('skip me', () => {});
 
@@ -77,14 +77,14 @@ describe('someText', () => {
   describe('some other condition', () => {
   });
 });
-describe('someObject', () => {
+xdescribe('someObject', () => {
   // Another comment
   describe('some condition', () => {
     const anotherThing = 500;
     describe('yet another condition', () => { // A comment over here!
     });
   });
-});describe('weird', () => {});
+});fdescribe('weird', () => {});
 describe.skip('skip me', () => {});
 const BOOP = "boop";
 describe
@@ -94,13 +94,7 @@ describe
 `;
 
 ruleTester.run('padding-around-describe-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx',
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
@@ -152,7 +146,8 @@ ruleTester.run('padding-around-describe-blocks', rule, {
           line: 27,
           column: 1
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-expect-groups.spec.js

@@ -106,13 +106,7 @@ describe('someText', () => {
 `;
 
 ruleTester.run('padding-around-expect-groups', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx',
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
@@ -154,7 +148,8 @@ ruleTester.run('padding-around-expect-groups', rule, {
           line: 32,
           column: 7
         },
-      ]
+      ],
+      output: valid,
     },
   ]
 });

package/tests/lib/rules/padding-around-test-blocks.spec.js

@@ -27,7 +27,7 @@ it('foo', () => {
   // stuff
 });
 
-it('bar', () => {
+fit('bar', () => {
   // stuff
 });
 
@@ -51,10 +51,12 @@ describe('other bar', () => {
   it.skip('skipping too', () => {});
 });
 
-test('weird', () => {});
+xtest('weird', () => {});
 
 test
   .skip('skippy skip', () => {});
+
+xit('bar foo', () => {});
 `;
 
 const invalid = `
@@ -63,7 +65,7 @@ const bar = 'baz';
 it('foo', () => {
   // stuff
 });
-it('bar', () => {
+fit('bar', () => {
   // stuff
 });
 test('foo foo', () => {});
@@ -79,24 +81,19 @@ describe('other bar', () => {
   });
   test.skip('skipping', () => {}); // Another comment
   it.skip('skipping too', () => {});
-});test('weird', () => {});
+});xtest('weird', () => {});
 test
   .skip('skippy skip', () => {});
+xit('bar foo', () => {});
 `;
 
 ruleTester.run('padding-around-test-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
+  valid: [valid],
   invalid: [
     {
       code: invalid,
       filename: 'src/component.test.jsx',
-      errors: 10,
+      errors: 11,
       output: valid,
     },
     {
@@ -153,7 +150,13 @@ ruleTester.run('padding-around-test-blocks', rule, {
           line: 24,
           column: 1
         },
+        {
+          message: 'Expected blank line before this statement.',
+          line: 26,
+          column: 1
+        },
       ],
+      output: valid,
     },
   ],
 });

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "module": "commonjs",
-    "noImplicitAny": false,
+    "noImplicitAny": true,
     "removeComments": true,
     "preserveConstEnums": true,
     "target": "es2015",

package/lib/utils.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const padding_1 = require("./rules/padding");
-exports.makeRule = (options) => {
-    return {
-        meta: {
-            fixable: 'whitespace',
-        },
-        create(context) {
-            const ctx = Object.create(context, { options: { value: options } });
-            Object.freeze(ctx);
-            return padding_1.default.create(ctx);
-        },
-    };
-};

package/src/utils.ts

@@ -1,40 +0,0 @@
-import { Rule } from 'eslint';
-import padding from './rules/padding';
-
-type TokenIdentifier =
-  | '*'
-  | 'afterAll'
-  | 'afterEach'
-  | 'beforeAll'
-  | 'beforeEach'
-  | 'describe'
-  | 'expect'
-  | 'it'
-  | 'test';
-
-interface RuleOption {
-  blankLine: 'always' | 'any' | 'never';
-  prev: TokenIdentifier | TokenIdentifier[];
-  next: TokenIdentifier | TokenIdentifier[];
-}
-
-// Returns a rule that wraps a call to padding.create and adds the given options
-// to the RuleContext so users don't have to.
-export const makeRule = (options: RuleOption[]): Rule.RuleModule => {
-  return {
-    meta: {
-      fixable: 'whitespace',
-    },
-    create(context: Rule.RuleContext) {
-      // Copy the RuleContext and overwrite options; it's frozen and
-      // we can't set them directly.
-      const ctx = Object.create(context, { options: { value: options } });
-
-      // Freeze it again
-      Object.freeze(ctx);
-
-      // Call the original create method with new context
-      return padding.create(ctx);
-    },
-  };
-};

package/tests/lib/rules/padding-before-after-all-blocks.spec.js

@@ -1,104 +0,0 @@
-/**
- * @fileoverview Enforces single line padding before afterAll blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-before-after-all-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-afterAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  afterAll(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  afterAll(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-afterAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  afterAll(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  afterAll(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-after-all-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 3,
-      output: valid,
-    },
-    {
-      code: invalid,
-      filename: 'src/component.test.js',
-      errors: [
-        {
-          message: 'Expected blank line before this statement.',
-          line: 3,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 9,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 16,
-          column: 3
-        },
-      ]
-    },
-  ]
-});

package/tests/lib/rules/padding-before-after-each-blocks.spec.js

@@ -1,104 +0,0 @@
-/**
- * @fileoverview Enforces single line padding before afterEach blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-before-after-each-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-afterEach(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  afterEach(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  afterEach(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-afterEach(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  afterEach(() => {
-    // stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  afterEach(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-after-each-blocks', rule, {
-  valid: [
-    valid,
-    {
-      code: invalid,
-      filename: 'src/component.jsx'
-    }
-  ],
-  invalid: [
-    {
-      code: invalid,
-      errors: 3,
-      filename: 'src/component.test.jsx',
-      output: valid,
-    },
-    {
-      code: invalid,
-      filename: 'src/component.test.js',
-      errors: [
-        {
-          message: 'Expected blank line before this statement.',
-          line: 3,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 9,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 16,
-          column: 3
-        },
-      ]
-    },
-  ]
-});