utils.js

'use strict';

const { inspect } = require('util');
const lodash = require('lodash');
const espree = require('espree');
const eslintScope = require('eslint-scope');
const estraverse = require('estraverse');
const assert = require('chai').assert;
const utils = require('../../lib/utils');
const typescriptEslintParser = require('@typescript-eslint/parser');

describe('utils', () => {
  describe('getRuleInfo', () => {
    describe('the file does not have a valid rule (CJS)', () => {
      [
        '',
        'module.exports;',
        'module.exports = foo;',
        'module.boop = function(context) { return {};};',
        'exports = function(context) { return {};};',
        'module.exports = function* (context) { return {}; };',
        'module.exports = async function (context) { return {};};',
        'module.exports = {};',
        'module.exports = { meta: {} }',
        'module.exports = { create: {} }',
        'module.exports = { create: foo }',
        'module.exports = { create: function* foo() {} }',
        'module.exports = { create: async function foo() {} }',

        // Function-style rule but missing object return.
        'module.exports = (context) => { }',
        'module.exports = (context) => { return; }',
        'module.exports = (context) => { return 123; }',
        'module.exports = (context) => { return FOO; }',
        'module.exports = function foo(context) { }',
        'module.exports = (context) => { }',
        'exports.meta = {}; module.exports = (context) => { }',
        'module.exports = (context) => { }; module.exports.meta = {};',

        // Function-style rule but missing context parameter.
        'module.exports = () => { return {}; }',
        'module.exports = (foo, bar) => { return {}; }',

        // Correct TypeScript helper structure but we don't support CJS for TypeScript rules:
        'module.exports = createESLintRule({ create() {}, meta: {} });',
        'module.exports = util.createRule({ create() {}, meta: {} });',
        'module.exports = ESLintUtils.RuleCreator(docsUrl)({ create() {}, meta: {} });',
      ].forEach(noRuleCase => {
        it(`returns null for ${noRuleCase}`, () => {
          const ast = espree.parse(noRuleCase, { ecmaVersion: 8, range: true });
          assert.isNull(utils.getRuleInfo({ ast }), 'Expected no rule to be found');
        });
      });
    });

    describe('the file does not have a valid rule (ESM)', () => {
      [
        '',
        'export const foo = { create() {} }',
        'export default { foo: {} }',
        'const foo = {}; export default foo',

        // Exports function but not default export.
        'export function foo (context) { return {}; }',

        // Exports function but no object return inside function.
        'export default function (context) { }',
        'export default function (context) { return; }',
        'export default function (context) { return 123; }',
        'export default function (context) { return FOO; }',

        // Function-style rule but missing context parameter.
        'export default function () { return {}; }',
        'export default function (foo, bar) { return {}; }',

        // Incorrect TypeScript helper structure:
        'export default foo()({ create() {}, meta: {} });',
        'export default foo().bar({ create() {}, meta: {} });',
        'export default foo.bar.baz({ create() {}, meta: {} });',
        'export default foo(123);',
        'export default foo.bar(123);',
        'export default foo.bar()(123);',

      ].forEach(noRuleCase => {
        it(`returns null for ${noRuleCase}`, () => {
          const ast = espree.parse(noRuleCase, { ecmaVersion: 8, range: true, sourceType: 'module' });
          assert.isNull(utils.getRuleInfo({ ast }), 'Expected no rule to be found');
        });
      });
    });

    describe('the file does not have a valid rule (TypeScript + TypeScript parser + ESM)', () => {
      [
        // Incorrect TypeScript helper structure:
        'export default foo()<Options, MessageIds>({ create() {}, meta: {} });',
        'export default foo().bar<Options, MessageIds>({ create() {}, meta: {} });',
        'export default foo.bar.baz<Options, MessageIds>({ create() {}, meta: {} });',
        'export default foo<Options, MessageIds>(123);',
        'export default foo.bar<Options, MessageIds>(123);',
        'export default foo.bar()<Options, MessageIds>(123);',
      ].forEach(noRuleCase => {
        it(`returns null for ${noRuleCase}`, () => {
          const ast = typescriptEslintParser.parse(noRuleCase, { ecmaVersion: 8, range: true, sourceType: 'module' });
          assert.isNull(utils.getRuleInfo({ ast }), 'Expected no rule to be found');
        });
      });
    });

    describe('the file does not have a valid rule (TypeScript + TypeScript parser + CJS)', () => {
      [
        // Correct TypeScript helper structure but we don't support CJS for TypeScript rules:
        'module.exports = createESLintRule<Options, MessageIds>({ create() {}, meta: {} });',
        'module.exports = util.createRule<Options, MessageIds>({ create() {}, meta: {} });',
        'module.exports = ESLintUtils.RuleCreator(docsUrl)<Options, MessageIds>({ create() {}, meta: {} });',
      ].forEach(noRuleCase => {
        it(`returns null for ${noRuleCase}`, () => {
          const ast = typescriptEslintParser.parse(noRuleCase, { range: true, sourceType: 'script' });
          assert.isNull(utils.getRuleInfo({ ast }), 'Expected no rule to be found');
        });
      });
    });

    describe('the file has a valid rule (TypeScript + TypeScript parser + ESM)', () => {
      const CASES = {
        // Util function only
        'export default createESLintRule<Options, MessageIds>({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'export default createESLintRule<>({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'export default createESLintRule({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },

        // Util function from util object
        'export default util.createRule<Options, MessageIds>({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'export default util.createRule({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },

        // Util function from util object with additional doc URL argument
        'export default ESLintUtils.RuleCreator(docsUrl)<Options, MessageIds>({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'export default ESLintUtils.RuleCreator(docsUrl)({ create() {}, meta: {} });': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
      };

      Object.keys(CASES).forEach(ruleSource => {
        it(ruleSource, () => {
          const ast = typescriptEslintParser.parse(ruleSource, { ecmaVersion: 6, range: true, sourceType: 'module' });
          const ruleInfo = utils.getRuleInfo({ ast });
          assert(
            lodash.isMatch(ruleInfo, CASES[ruleSource]),
            `Expected \n${inspect(ruleInfo)}\nto match\n${inspect(CASES[ruleSource])}`
          );
        });
      });
    });

    describe('the file has a valid rule (CJS)', () => {
      const CASES = {
        'module.exports = { create: function foo() {} };': {
          create: { type: 'FunctionExpression', id: { name: 'foo' } }, // (This property will actually contain the AST node.)
          meta: null,
          isNewStyle: true,
        },
        'module.exports = { create: () => { } };': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: true,
        },
        'module.exports = { create() {}, meta: { } };': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'module.exports.create = function foo(context) {}; module.exports.meta = {}': {
          create: { type: 'FunctionExpression', id: { name: 'foo' } },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'exports.create = function foo() {}; exports.meta = {};': {
          create: { type: 'FunctionExpression', id: { name: 'foo' } },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'module.exports = { create: () => { } }; exports.create = function foo() {}; exports.meta = {};': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: true,
        },
        'exports.meta = {}; module.exports = { create: () => { } };': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: true,
        },
        'module.exports = { create: () => { } }; module.exports.meta = {};': {
          create: { type: 'ArrowFunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'module.exports = { meta: {} }; module.exports.create = () => { };': {
          create: { type: 'ArrowFunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'module.exports = { "meta": {} }; module.exports.create = () => { };': {
          create: { type: 'ArrowFunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },
        'module.exports = { create: (context) => { } }; exports.meta = {};': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: true,
        },
        'module.exports = function foo(context) { return {}; }': {
          create: { type: 'FunctionExpression', id: { name: 'foo' } },
          meta: null,
          isNewStyle: false,
        },
        'module.exports = function foo(slightlyDifferentContextName) { return {}; }': {
          create: { type: 'FunctionExpression', id: { name: 'foo' } },
          meta: null,
          isNewStyle: false,
        },
        'module.exports = function foo({ report }) { return {}; }': {
          create: { type: 'FunctionExpression', id: { name: 'foo' } },
          meta: null,
          isNewStyle: false,
        },
        'module.exports = (context) => { return {}; }': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: false,
        },
        'module.exports = (context) => { if (foo) { return {}; } }': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: false,
        },
        'exports.meta = {}; module.exports = (context) => { return {}; }': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: false,
        },
        'module.exports = (context) => { return {}; }; module.exports.meta = {};': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: false,
        },
      };

      Object.keys(CASES).forEach(ruleSource => {
        it(ruleSource, () => {
          const ast = espree.parse(ruleSource, { ecmaVersion: 6, range: true, sourceType: 'script' });
          const ruleInfo = utils.getRuleInfo({ ast });
          assert(
            lodash.isMatch(ruleInfo, CASES[ruleSource]),
            `Expected \n${inspect(ruleInfo)}\nto match\n${inspect(CASES[ruleSource])}`
          );
        });
      });
    });

    describe('the file has a valid rule (ESM)', () => {
      const CASES = {
        // ESM (object style)
        'export default { create() {} }': {
          create: { type: 'FunctionExpression' },
          meta: null,
          isNewStyle: true,
        },
        'export default { create() {}, meta: {} }': {
          create: { type: 'FunctionExpression' },
          meta: { type: 'ObjectExpression' },
          isNewStyle: true,
        },

        // ESM (function style)
        'export default function (context) { return {}; }': {
          create: { type: 'FunctionDeclaration' },
          meta: null,
          isNewStyle: false,
        },
        'export default function (context) { if (foo) { return {}; } }': {
          create: { type: 'FunctionDeclaration' },
          meta: null,
          isNewStyle: false,
        },
        'export default (context) => { return {}; }': {
          create: { type: 'ArrowFunctionExpression' },
          meta: null,
          isNewStyle: false,
        },
      };

      Object.keys(CASES).forEach(ruleSource => {
        it(ruleSource, () => {
          const ast = espree.parse(ruleSource, { ecmaVersion: 6, range: true, sourceType: 'module' });
          const ruleInfo = utils.getRuleInfo({ ast });
          assert(
            lodash.isMatch(ruleInfo, CASES[ruleSource]),
            `Expected \n${inspect(ruleInfo)}\nto match\n${inspect(CASES[ruleSource])}`
          );
        });
      });
    });

    describe('the file has a valid rule (different scope options)', () => {
      for (const scopeOptions of [
        { ignoreEval: true, ecmaVersion: 6, sourceType: 'script', nodejsScope: true },
        { ignoreEval: true, ecmaVersion: 6, sourceType: 'script' },
        { ignoreEval: true, ecmaVersion: 6, sourceType: 'module' },
      ]) {
        const ast = espree.parse(`
          const create = (context) => {};
          const meta = {};
          module.exports = { create, meta };
        `, { ecmaVersion: 6 });
        const expected = {
          create: { type: 'Identifier' },
          meta: { type: 'Identifier' },
          isNewStyle: true,
        };
        it(`ScopeOptions: ${JSON.stringify(scopeOptions)}`, () => {
          const scopeManager = eslintScope.analyze(ast, scopeOptions);
          const ruleInfo = utils.getRuleInfo({ ast, scopeManager });
          assert(
            lodash.isMatch(ruleInfo, expected),
            `Expected \n${inspect(ruleInfo)}\nto match\n${inspect(expected)}`
          );
        });
      }
    });

    describe('the file has newer syntax', () => {
      const CASES = [
        {
          source: 'module.exports = function(context) { class Foo { @someDecorator() someProp }; return {}; };',
          options: { sourceType: 'script' },
          expected: {
            create: { type: 'FunctionExpression' },
            meta: null,
            isNewStyle: false,
          },
        },
        {
          source: 'export default function(context) { class Foo { @someDecorator() someProp }; return {}; };',
          options: { sourceType: 'module' },
          expected: {
            create: { type: 'FunctionDeclaration' },
            meta: null,
            isNewStyle: false,
          },
        },
      ];
      for (const testCase of CASES) {
        describe(testCase.source, () => {
          it('does not throw with node type PropertyDefinition which is not handled by estraverse (estraverse is used for detecting the object return statement in a function-style rule).', () => {
            const ast = typescriptEslintParser.parse(testCase.source, testCase.options);
            const scopeManager = eslintScope.analyze(ast);
            const ruleInfo = utils.getRuleInfo({ ast, scopeManager });
            assert(
              lodash.isMatch(ruleInfo, testCase.expected),
              `Expected \n${inspect(ruleInfo)}\nto match\n${inspect(testCase.expected)}`
            );
          });
        });
      }
    });
  });

  describe('getContextIdentifiers', () => {
    const CASES = {
      'module.exports = context => { context; context; context; return {}; }' (ast) {
        return [
          ast.body[0].expression.right.body.body[0].expression,
          ast.body[0].expression.right.body.body[1].expression,
          ast.body[0].expression.right.body.body[2].expression,
        ];
      },
      'module.exports = { meta: {}, create(context, foo = context) {} }' (ast) {
        return [ast.body[0].expression.right.properties[1].value.params[1].right];
      },
      'module.exports = { meta: {}, create(notContext) { notContext; notContext; notContext; } }' (ast) {
        return [
          ast.body[0].expression.right.properties[1].value.body.body[0].expression,
          ast.body[0].expression.right.properties[1].value.body.body[1].expression,
          ast.body[0].expression.right.properties[1].value.body.body[2].expression,
        ];
      },
    };

    Object.keys(CASES).forEach(ruleSource => {
      it(ruleSource, () => {
        const ast = espree.parse(ruleSource, { ecmaVersion: 6, range: true });
        const scope = eslintScope.analyze(ast, { ignoreEval: true, ecmaVersion: 6, sourceType: 'script', nodejsScope: true });
        const identifiers = utils.getContextIdentifiers(scope, ast);

        assert(identifiers instanceof Set, 'getContextIdentifiers should return a Set');
        [...identifiers].forEach((identifier, index) => {
          assert.strictEqual(identifier, CASES[ruleSource](ast)[index]);
        });
      });
    });
  });

  describe('getKeyName', () => {
    const CASES = {
      '({ foo: 1 })': 'foo',
      '({ "foo": 1 })': 'foo',
      '({ ["foo"]: 1 })': 'foo',
      '({ [`foo`]: 1 })': 'foo',
      '({ foo() {} })': 'foo',
      '({ "foo"() {} })': 'foo',
      '({ ["foo"]() {} })': 'foo',
      '({ [`foo`]() {} })': 'foo',
      '({ 5: 1 })': '5',
      '({ 0x123: 1 })': '291',
      '({ [foo]: 1 })': null,
      '({ [tag`foo`]: 1 })': null,
      '({ ["foo" + "bar"]: 1 })': null,
    };
    Object.keys(CASES).forEach(objectSource => {
      it(objectSource, () => {
        const ast = espree.parse(objectSource, { ecmaVersion: 6, range: true });

        assert.strictEqual(utils.getKeyName(ast.body[0].expression.properties[0]), CASES[objectSource]);
      });
    });

    const CASES_ES9 = {
      '({ ...foo })': null,
    };
    Object.keys(CASES_ES9).forEach(objectSource => {
      it(objectSource, () => {
        const ast = espree.parse(objectSource, { ecmaVersion: 9, range: true });

        assert.strictEqual(utils.getKeyName(ast.body[0].expression.properties[0]), CASES_ES9[objectSource]);
      });
    });
  });

  describe('getTestInfo', () => {
    describe('the file does not have valid tests', () => {
      [
        '',
        'module.exports = context => { context.report(foo); return {}; };',
        'new (require("eslint").NotRuleTester).run(foo, bar, { valid: [] })',
        'new NotRuleTester().run(foo, bar, { valid: [] })',
        'new RuleTester()',
        'const foo = new RuleTester; bar.run(foo, bar, { valid: [] })',
        'new RuleTester().run()',
        'new RuleTester().run(foo)',
        'new RuleTester().run(foo, bar)',
        'new RuleTester().run(foo, bar, notAnObject)',
      ].forEach(noTestsCase => {
        it(`returns no tests for ${noTestsCase}`, () => {
          const ast = espree.parse(noTestsCase, { ecmaVersion: 8, range: true });
          const scope = eslintScope.analyze(ast, { ignoreEval: true, ecmaVersion: 6, sourceType: 'script', nodejsScope: true });
          assert.deepEqual(utils.getTestInfo(scope, ast), [], 'Expected no tests to be found');
        });
      });
    });

    describe('the file has valid tests', () => {
      const CASES = {
        'new RuleTester().run(bar, baz, { valid: [foo], invalid: [bar, baz] })': { valid: 1, invalid: 2 },
        'var foo = new RuleTester(); foo.run(bar, baz, { valid: [foo], invalid: [bar] })': { valid: 1, invalid: 1 },
        'var foo = new (require("eslint")).RuleTester; foo.run(bar, baz, { valid: [], invalid: [] })': { valid: 0, invalid: 0 },
        'var foo = new bar.RuleTester; foo.run(bar, baz, { valid: [], invalid: [bar, baz] })': { valid: 0, invalid: 2 },
        'var foo = new bar.RuleTester; foo.run(bar, baz, { valid: [,], invalid: [bar, , baz] })': { valid: 0, invalid: 2 },
      };

      Object.keys(CASES).forEach(testSource => {
        it(testSource, () => {
          const ast = espree.parse(testSource, { ecmaVersion: 6, range: true });
          const scope = eslintScope.analyze(ast, { ignoreEval: true, ecmaVersion: 6, sourceType: 'script', nodejsScope: true });
          const testInfo = utils.getTestInfo(scope, ast);

          assert.strictEqual(testInfo.length, 1, 'Expected to find one test run');

          assert.strictEqual(
            testInfo[0].valid.length,
            CASES[testSource].valid,
            `Expected ${CASES[testSource].valid} valid cases but got ${testInfo[0].valid.length}`
          );

          assert.strictEqual(
            testInfo[0].invalid.length,
            CASES[testSource].invalid,
            `Expected ${CASES[testSource].invalid} invalid cases but got ${testInfo[0].invalid.length}`
          );
        });
      });
    });

    describe('the file has multiple test runs', () => {
      const CASES = {
        [`
          new RuleTester().run(foo, bar, { valid: [foo], invalid: [] });
          new RuleTester().run(foo, bar, { valid: [], invalid: [foo, bar] });
        `]: [{ valid: 1, invalid: 0 }, { valid: 0, invalid: 2 }],

        [`
          var foo = new RuleTester;
          var bar = new RuleTester;
          foo.run(foo, bar, { valid: [foo, bar, baz], invalid: [foo] });
          bar.run(foo, bar, { valid: [], invalid: [foo, bar] });
        `]: [{ valid: 3, invalid: 1 }, { valid: 0, invalid: 2 }],

        [`
          var foo = new RuleTester, bar = new RuleTester;
          foo.run(foo, bar, { valid: [foo, bar, baz], invalid: [foo] });
          bar.run(foo, bar, { valid: [], invalid: [foo, bar] });
        `]: [{ valid: 3, invalid: 1 }, { valid: 0, invalid: 2 }],

      };

      Object.keys(CASES).forEach(testSource => {
        it(testSource, () => {
          const ast = espree.parse(testSource, { ecmaVersion: 6, range: true });
          const scope = eslintScope.analyze(ast, { ignoreEval: true, ecmaVersion: 6, sourceType: 'script', nodejsScope: true });
          const testInfo = utils.getTestInfo(scope, ast);

          assert.strictEqual(
            testInfo.length,
            CASES[testSource].length,
            `Expected to find ${CASES[testSource].length} test runs but got ${testInfo.length}`
          );

          CASES[testSource].forEach((testRun, index) => {
            assert.strictEqual(
              testRun.valid,
              testInfo[index].valid.length,
              `On run ${index + 1}, expected ${testRun.valid} valid cases but got ${testInfo[index].valid.length}`
            );
            assert.strictEqual(
              testRun.invalid,
              testInfo[index].invalid.length,
              `On run ${index + 1}, expected ${testRun.invalid} valid cases but got ${testInfo[index].invalid.length}`
            );
          });
        });
      });
    });
  });

  describe('getReportInfo', () => {
    const CASES = new Map([
      [[], () => null],
      [['foo', 'bar'], () => null],
      [['foo', '"bar"', 'baz', 'qux', 'boop'], args => ({ node: args[0], message: args[1], data: args[2], fix: args[3] })],
      [['foo', '`bar`', 'baz', 'qux', 'boop'], args => ({ node: args[0], message: args[1], data: args[2], fix: args[3] })],
      [
        ['foo', '{ bar: 1 }', 'baz', 'qux', 'boop'],
        args => ({ node: args[0], loc: args[1], message: args[2], data: args[3], fix: args[4] }),
      ],
      [['foo', 'bar', 'baz'], () => null],
      [
        ['{ node, message }'],
        () => ({
          node: { type: 'Identifier', name: 'node', start: 17, end: 21 },
          message: { type: 'Identifier', name: 'message', start: 23, end: 30 },
        }),
      ],
    ]);

    for (const args of CASES.keys()) {
      it(args.join(', '), () => {
        const parsedArgs = espree.parse(
          `context.report(${args.join(', ')})`,
          { ecmaVersion: 6, loc: false, range: false }
        ).body[0].expression.arguments;
        const context = { getScope () {} }; // mock object
        const reportInfo = utils.getReportInfo(parsedArgs, context);

        assert.deepEqual(reportInfo, CASES.get(args)(parsedArgs));
      });
    }
  });

  describe('getSourceCodeIdentifiers', () => {
    const CASES = {
      'module.exports = context => { const sourceCode = context.getSourceCode(); sourceCode; foo; return {}; }': 2,
      'module.exports = context => { const x = 1, sc = context.getSourceCode(); sc; sc; sc; sourceCode; return {}; }': 4,
      'module.exports = context => { const sourceCode = context.getNotSourceCode(); return {}; }': 0,
    };

    Object.keys(CASES).forEach(testSource => {
      it(testSource, () => {
        const ast = espree.parse(testSource, { ecmaVersion: 6, range: true });
        const scope = eslintScope.analyze(ast, { ignoreEval: true, ecmaVersion: 6, sourceType: 'script', nodejsScope: true });

        estraverse.traverse(ast, {
          enter (node, parent) {
            node.parent = parent;
          },
        });

        assert.strictEqual(utils.getSourceCodeIdentifiers(scope, ast).size, CASES[testSource]);
      });
    });
  });

  describe('collectReportViolationAndSuggestionData', () => {
    const CASES = [
      {
        // One suggestion.
        code: `
          context.report({
            node: {},
            message: "message1",
            messageId: "messageId1",
            data: { foo: 'hello' },
            fix(fixer) {},
            suggest: [{
              desc: "message2",
              messageId: "messageId2",
              data: { bar: 'world' },
              fix(fixer) {},
            }]
          });
        `,
        shouldMatch: [
          {
            message: { type: 'Literal', value: 'message1' },
            messageId: { type: 'Literal', value: 'messageId1' },
            data: { type: 'ObjectExpression', properties: [{ key: { name: 'foo' } }] },
            fix: { type: 'FunctionExpression' },
          },
          {
            message: { type: 'Literal', value: 'message2' },
            messageId: { type: 'Literal', value: 'messageId2' },
            data: { type: 'ObjectExpression', properties: [{ key: { name: 'bar' } }] },
            fix: { type: 'FunctionExpression' },
          },
        ],
      },
      {
        // Suggestions using an array variable.
        code: `
          context.report({
            node: {},
            message: "message1",
            messageId: "messageId1",
            data: { foo: 'hello' },
            fix(fixer) {},
            suggest: SUGGESTIONS
          });
        `,
        shouldMatch: [
          {
            message: { type: 'Literal', value: 'message1' },
            messageId: { type: 'Literal', value: 'messageId1' },
            data: { type: 'ObjectExpression', properties: [{ key: { name: 'foo' } }] },
            fix: { type: 'FunctionExpression' },
          },
        ],
      },
      {
        // Suggestions using array item variables.
        code: `
          context.report({
            node: {},
            message: "message1",
            messageId: "messageId1",
            data: { foo: 'hello' },
            fix(fixer) {},
            suggest: [ SUGGEST_1, SUGGEST_2 ]
          });
        `,
        shouldMatch: [
          {
            message: { type: 'Literal', value: 'message1' },
            messageId: { type: 'Literal', value: 'messageId1' },
            data: { type: 'ObjectExpression', properties: [{ key: { name: 'foo' } }] },
            fix: { type: 'FunctionExpression' },
          },
        ],
      },
      {
        // No suggestions.
        code: `
          context.report({
            node: {},
            message: "message1",
            messageId: "messageId1",
            data: { foo: 'hello' },
            fix(fixer) {},
          });
        `,
        shouldMatch: [
          {
            message: { type: 'Literal', value: 'message1' },
            messageId: { type: 'Literal', value: 'messageId1' },
            data: { type: 'ObjectExpression', properties: [{ key: { name: 'foo' } }] },
            fix: { type: 'FunctionExpression' },
          },
        ],
      },
    ];

    it('behaves correctly', () => {
      for (const testCase of CASES) {
        const ast = espree.parse(testCase.code, { ecmaVersion: 6, range: true });
        const context = { getScope () {} }; // mock object
        const reportNode = ast.body[0].expression;
        const reportInfo = utils.getReportInfo(reportNode.arguments, context);
        const data = utils.collectReportViolationAndSuggestionData(reportInfo);
        assert(
          lodash.isMatch(data, testCase.shouldMatch),
          `Expected \n${inspect(data)}\nto match\n${inspect(testCase.shouldMatch)}`
        );
      }
    });
  });

  describe('isAutoFixerFunction / isSuggestionFixerFunction', () => {
    const CASES = {
      // isAutoFixerFunction
      'context.report({ fix(fixer) {} });' (ast) {
        return { expected: true, node: ast.body[0].expression.arguments[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isAutoFixerFunction };
      },
      'context.notReport({ fix(fixer) {} });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isAutoFixerFunction };
      },
      'context.report({ notFix(fixer) {} });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isAutoFixerFunction };
      },
      'notContext.report({ notFix(fixer) {} });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value, context: undefined, fn: utils.isAutoFixerFunction };
      },

      // isSuggestionFixerFunction
      'context.report({ suggest: [{ fix(fixer) {} }] });' (ast) {
        return { expected: true, node: ast.body[0].expression.arguments[0].properties[0].value.elements[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isSuggestionFixerFunction };
      },
      'context.notReport({ suggest: [{ fix(fixer) {} }] });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value.elements[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isSuggestionFixerFunction };
      },
      'context.report({ notSuggest: [{ fix(fixer) {} }] });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value.elements[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isSuggestionFixerFunction };
      },
      'context.report({ suggest: [{ notFix(fixer) {} }] });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value.elements[0].properties[0].value, context: ast.body[0].expression.callee.object, fn: utils.isSuggestionFixerFunction };
      },
      'notContext.report({ suggest: [{ fix(fixer) {} }] });' (ast) {
        return { expected: false, node: ast.body[0].expression.arguments[0].properties[0].value, context: undefined, fn: utils.isSuggestionFixerFunction };
      },
    };

    Object.keys(CASES).forEach(ruleSource => {
      it(ruleSource, () => {
        const ast = espree.parse(ruleSource, { ecmaVersion: 6, range: true });

        // Add parent to each node.
        estraverse.traverse(ast, {
          enter (node, parent) {
            node.parent = parent;
          },
        });

        const testCase = CASES[ruleSource](ast);
        const contextIdentifiers = new Set([testCase.context]);
        const result = testCase.fn(testCase.node, contextIdentifiers);
        assert.strictEqual(result, testCase.expected);
      });
    });
  });
});