parse.js

import * as fs from 'fs';
import { expect } from 'chai';
import sinon from 'sinon';
import parse from 'eslint-module-utils/parse';

import { getFilename } from '../utils';

describe('parse(content, { settings, ecmaFeatures })', function () {
  const path = getFilename('jsx.js');
  const parseStubParser = require('./parseStubParser');
  const parseStubParserPath = require.resolve('./parseStubParser');
  const eslintParser = require('./eslintParser');
  const eslintParserPath = require.resolve('./eslintParser');
  let content;

  before((done) =>
    fs.readFile(path, { encoding: 'utf8' },
      (err, f) => { if (err) { done(err); } else { content = f; done(); }}));

  it('doesn\'t support JSX by default', function () {
    expect(() => parse(path, content, { parserPath: 'espree' })).to.throw(Error);
  });

  it('infers jsx from ecmaFeatures when using stock parser', function () {
    expect(() => parse(path, content, { settings: {}, parserPath: 'espree', parserOptions: { ecmaVersion: 2015, sourceType: 'module', ecmaFeatures: { jsx: true } } }))
      .not.to.throw(Error);
  });

  it('passes expected parserOptions to custom parser', function () {
    const parseSpy = sinon.spy();
    const parserOptions = { ecmaFeatures: { jsx: true } };
    parseStubParser.parse = parseSpy;
    parse(path, content, { settings: {}, parserPath: parseStubParserPath, parserOptions });
    expect(parseSpy.callCount, 'custom parser to be called once').to.equal(1);
    expect(parseSpy.args[0][0], 'custom parser to get content as its first argument').to.equal(content);
    expect(parseSpy.args[0][1], 'custom parser to get an object as its second argument').to.be.an('object');
    expect(parseSpy.args[0][1], 'custom parser to clone the parserOptions object').to.not.equal(parserOptions);
    expect(parseSpy.args[0][1], 'custom parser to get ecmaFeatures in parserOptions which is a clone of ecmaFeatures passed in')
      .to.have.property('ecmaFeatures')
      .that.is.eql(parserOptions.ecmaFeatures)
      .and.is.not.equal(parserOptions.ecmaFeatures);
    expect(parseSpy.args[0][1], 'custom parser to get parserOptions.attachComment equal to true').to.have.property('attachComment', true);
    expect(parseSpy.args[0][1], 'custom parser to get parserOptions.tokens equal to true').to.have.property('tokens', true);
    expect(parseSpy.args[0][1], 'custom parser to get parserOptions.range equal to true').to.have.property('range', true);
    expect(parseSpy.args[0][1], 'custom parser to get parserOptions.filePath equal to the full path of the source file').to.have.property('filePath', path);
  });

  it('passes with custom `parseForESLint` parser', function () {
    const parseForESLintSpy = sinon.spy(eslintParser, 'parseForESLint');
    const parseSpy = sinon.spy();
    eslintParser.parse = parseSpy;
    parse(path, content, { settings: {}, parserPath: eslintParserPath });
    expect(parseForESLintSpy.callCount, 'custom `parseForESLint` parser to be called once').to.equal(1);
    expect(parseSpy.callCount, '`parseForESLint` takes higher priority than `parse`').to.equal(0);
  });

  it('throws on context == null', function () {
    expect(parse.bind(null, path, content, null)).to.throw(Error);
  });

  it('throws on unable to resolve parserPath', function () {
    expect(parse.bind(null, path, content, { settings: {}, parserPath: null })).to.throw(Error);
  });

  it('takes the alternate parser specified in settings', function () {
    const parseSpy = sinon.spy();
    const parserOptions = { ecmaFeatures: { jsx: true } };
    parseStubParser.parse = parseSpy;
    expect(parse.bind(null, path, content, { settings: { 'import/parsers': { [parseStubParserPath]: [ '.js' ] } }, parserPath: null, parserOptions })).not.to.throw(Error);
    expect(parseSpy.callCount, 'custom parser to be called once').to.equal(1);
  });
});