eslint-plugin-jest-formatting 3.0.0 → 4.0.0

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

@@ -1,94 +0,0 @@
-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

@@ -1,115 +0,0 @@
-/**
- * @fileoverview Enforces single line padding before afterAll blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-around-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
-  });
-  afterAll(() => {
-    // other stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  afterAll(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-afterAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  afterAll(() => {
-    // stuff
-  });
-
-  afterAll(() => {
-    // other stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  afterAll(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-after-all-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 5,
-      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: 5,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 8,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 11,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 18,
-          column: 3
-        },
-      ],
-      output: valid,
-    },
-  ]
-});

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

@@ -1,113 +0,0 @@
-/**
- * @fileoverview Enforces single line padding around afterEach blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-around-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
-  });
-  afterEach(() => {
-    // other stuff
-  });
-});
-describe('someText', () => {
-  const something = 'abc';
-  afterEach(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-afterEach(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  afterEach(() => {
-    // stuff
-  });
-
-  afterEach(() => {
-    // other stuff
-  });
-});
-describe('someText', () => {
-  const something = 'abc';
-
-  afterEach(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-after-each-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      errors: 5,
-      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: 5,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 8,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 11,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 17,
-          column: 3
-        },
-      ],
-      output: valid,
-    },
-  ]
-});

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

@@ -1,115 +0,0 @@
-/**
- * @fileoverview Enforces single line padding around beforeAll blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-around-before-all-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-beforeAll(() => {
-});
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  beforeAll(() => {
-    // stuff
-  });
-  beforeAll(() => {
-    // other stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  beforeAll(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-beforeAll(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  beforeAll(() => {
-    // stuff
-  });
-
-  beforeAll(() => {
-    // other stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  beforeAll(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-before-all-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 5,
-      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: 5,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 8,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 11,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 18,
-          column: 3
-        },
-      ],
-      output: valid,
-    },
-  ]
-});

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

@@ -1,115 +0,0 @@
-/**
- * @fileoverview Enforces single line padding around beforeEach blocks
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-around-before-each-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const invalid = `
-const someText = 'abc';
-beforeEach(() => {
-});
-describe('someText', () => {
-  const something = 'abc';
-  // A comment
-  beforeEach(() => {
-    // stuff
-  });
-  beforeEach(() => {
-    // other stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-  beforeEach(() => {
-    // stuff
-  });
-});
-`;
-
-const valid = `
-const someText = 'abc';
-
-beforeEach(() => {
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  // A comment
-  beforeEach(() => {
-    // stuff
-  });
-
-  beforeEach(() => {
-    // other stuff
-  });
-});
-
-describe('someText', () => {
-  const something = 'abc';
-
-  beforeEach(() => {
-    // stuff
-  });
-});
-`;
-
-ruleTester.run('padding-before-before-each-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 5,
-      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: 5,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 8,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 11,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 18,
-          column: 3
-        },
-      ],
-      output: valid,
-    },
-  ]
-});

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

@@ -1,153 +0,0 @@
-/**
- * @fileoverview Enforces padding line around describe blocks
- * @author Dan Green-Leipciger
- */
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const { RuleTester } = require('eslint');
-const rule = require('../../../lib').rules['padding-around-describe-blocks'];
-
-const ruleTester = new RuleTester({
-  parserOptions: {
-    ecmaVersion: 6,
-  },
-});
-
-//------------------------------------------------------------------------------
-// Tests
-//------------------------------------------------------------------------------
-
-const valid = `
-foo();
-bar();
-
-const someText = 'abc';
-const someObject = {
-  one: 1,
-  two: 2,
-};
-
-// A comment before describe
-describe('someText', () => {
-  describe('some condition', () => {
-  });
-
-  describe('some other condition', () => {
-  });
-});
-
-xdescribe('someObject', () => {
-  // Another comment
-  describe('some condition', () => {
-    const anotherThing = 500;
-
-    describe('yet another condition', () => { // A comment over here!
-    });
-  });
-});
-
-fdescribe('weird', () => {});
-
-describe.skip('skip me', () => {});
-
-const BOOP = "boop";
-
-describe
-  .skip('skip me too', () => {
-    // stuff
-  });
-`;
-
-const invalid = `
-foo();
-bar();
-
-const someText = 'abc';
-const someObject = {
-  one: 1,
-  two: 2,
-};
-// A comment before describe
-describe('someText', () => {
-  describe('some condition', () => {
-  });
-  describe('some other condition', () => {
-  });
-});
-xdescribe('someObject', () => {
-  // Another comment
-  describe('some condition', () => {
-    const anotherThing = 500;
-    describe('yet another condition', () => { // A comment over here!
-    });
-  });
-});fdescribe('weird', () => {});
-describe.skip('skip me', () => {});
-const BOOP = "boop";
-describe
-  .skip('skip me too', () => {
-    // stuff
-  });
-`;
-
-ruleTester.run('padding-around-describe-blocks', rule, {
-  valid: [valid],
-  invalid: [
-    {
-      code: invalid,
-      filename: 'src/component.test.jsx',
-      errors: 8,
-      output: valid,
-    },
-    {
-      code: invalid,
-      filename: 'src/component.test.js',
-      errors: [
-        {
-          message: 'Expected blank line before this statement.',
-          line: 11,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 14,
-          column: 3
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 17,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 21,
-          column: 5
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 24,
-          column: 4
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 25,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 26,
-          column: 1
-        },
-        {
-          message: 'Expected blank line before this statement.',
-          line: 27,
-          column: 1
-        },
-      ],
-      output: valid,
-    },
-  ]
-});