ember-introjs/.node_modules.ember-try/eslint-plugin-ember/tests/lib/utils/utils-test.js

An Ember Component for intro.js

'use strict';

const babelEslint = require('babel-eslint');
const utils = require('../../../lib/utils/utils');

function parse(code) {
  return babelEslint.parse(code).body[0].expression;
}

function parseVariableDeclarator(code) {
  return babelEslint.parse(code).body[0].declarations[0];
}

describe('findNodes', () => {
  const node = parse(`test = [
    {test: "a"}, b, "c", [d, e], "f", "g", h, {test: "i"}, function() {}, [], new Date()
  ]`).right.elements;

  it('should find nodes based on their name', () => {
    const literals = utils.findNodes(node, 'Literal');
    const identifiers = utils.findNodes(node, 'Identifier');
    const objects = utils.findNodes(node, 'ObjectExpression');
    const functions = utils.findNodes(node, 'FunctionExpression');
    const news = utils.findNodes(node, 'NewExpression');
    const arrays = utils.findNodes(node, 'ArrayExpression');

    expect(literals).toHaveLength(3);
    expect(identifiers).toHaveLength(2);
    expect(objects).toHaveLength(2);
    expect(functions).toHaveLength(1);
    expect(news).toHaveLength(1);
    expect(arrays).toHaveLength(2);
  });
});

describe('isIdentifier', () => {
  const node = parse('test');

  it('should check if node is identifier', () => {
    expect(utils.isIdentifier(node)).toBeTruthy();
  });
});

describe('isLiteral', () => {
  const node = parse('"test"');

  it('should check if node is identifier', () => {
    expect(utils.isLiteral(node)).toBeTruthy();
  });
});

describe('isUnaryExpression', () => {
  const node = parse('-1');

  it('should check if node is identifier', () => {
    expect(utils.isUnaryExpression(node)).toBeTruthy();
  });
});

describe('isMemberExpression', () => {
  const node = parse('test.value');

  it('should check if node is member expression', () => {
    expect(utils.isMemberExpression(node)).toBeTruthy();
  });
});

describe('isCallExpression', () => {
  const node = parse('test()');

  it('should check if node is call expression', () => {
    expect(utils.isCallExpression(node)).toBeTruthy();
  });
});

describe('isObjectExpression', () => {
  const node = parse('test = {}').right;

  it('should check if node is identifier', () => {
    expect(utils.isObjectExpression(node)).toBeTruthy();
  });
});

describe('isArrayExpression', () => {
  const node = parse('test = []').right;

  it('should check if node is array expression', () => {
    expect(utils.isArrayExpression(node)).toBeTruthy();
  });
});

describe('isFunctionExpression', () => {
  const node = parse('test = function () {}').right;

  it('should check if node is function expression', () => {
    expect(utils.isFunctionExpression(node)).toBeTruthy();
  });
});

describe('isArrowFunctionExpression', () => {
  const node = parse('test = () => {}').right;

  it('should check if node is arrow function expression', () => {
    expect(utils.isArrowFunctionExpression(node)).toBeTruthy();
  });
});

describe('isConciseArrowFunctionExpressionWithCall', () => {
  const node = parse('test = () => foo()').right;
  const blockNode = parse('test = () => { foo() }').right;

  it('should check if node is concise arrow function expression with call expression body', () => {
    expect(utils.isConciseArrowFunctionWithCallExpression(node)).toBeTruthy();
  });

  it('should check if node does not have block body', () => {
    expect(!utils.isConciseArrowFunctionWithCallExpression(blockNode)).toBeTruthy();
  });
});

describe('isNewExpression', () => {
  const node = parse('new Date()');

  it('should check if node is new expression', () => {
    expect(utils.isNewExpression(node)).toBeTruthy();
  });
});

describe('isCallWithFunctionExpression', () => {
  const node = parse('mysteriousFnc(function(){})');

  it('should check if node is call with function expression', () => {
    expect(utils.isCallWithFunctionExpression(node)).toBeTruthy();
  });
});

describe('isThisExpression', () => {
  const node = parse('this');

  it('should check if node is "this" expression', () => {
    expect(utils.isThisExpression(node)).toBeTruthy();
  });
});

describe('isConditionalExpression', () => {
  const node = parse('test = true ? \'asd\' : \'qwe\'').right;

  it('should check if node is a conditional expression', () => {
    expect(utils.isConditionalExpression(node)).toBeTruthy();
  });
});

describe('isTaggedTemplateExpression', () => {
  const node = parse('test = hbs`lorem ipsum`;').right;

  it('should check if node is a tagged template expression', () => {
    expect(utils.isTaggedTemplateExpression(node)).toBeTruthy();
  });
});

describe('getSize', () => {
  const node = parse('some = {\nfew: "line",\nheight: "statement",\nthat: "should",\nhave: "6 lines",\n};');

  it('should check size of given expression', () => {
    expect(utils.getSize(node)).toEqual(6);
  });
});

describe('parseCallee', () => {
  it('should parse calleeExpression', () => {
    const node = parse('Ember.computed.or("asd", "qwe")');
    const parsedCallee = utils.parseCallee(node);
    expect(parsedCallee).toHaveLength(3, 'it has 3 elements in array');
    expect(parsedCallee).toEqual(['Ember', 'computed', 'or']);
  });

  it('should parse newExpression', () => {
    const node = parse('new Ember.A()');
    const parsedCallee = utils.parseCallee(node);
    expect(parsedCallee).toHaveLength(2, 'it has 2 elements in array');
    expect(parsedCallee).toEqual(['Ember', 'A']);
  });
});

describe('parseArgs', () => {
  it('should parse arguments', () => {
    const node = parse('Ember.computed("asd", "qwe", "zxc", function() {})');
    const parsedArgs = utils.parseArgs(node);
    expect(parsedArgs).toHaveLength(3);
    expect(parsedArgs).toEqual(['asd', 'qwe', 'zxc']);
  });
});

describe('getPropertyValue', () => {
  const simpleObject = {
    foo: true,
    bar: {
      baz: 1,
      fizz: {
        buzz: 'buzz'
      }
    }
  };

  const node = babelEslint.parse(`
    export default Ember.Component({
      init() {
        this._super(...arguments);
        this._valueCache = this.value;
        this.updated = false;
      },
      didReceiveAttrs() {
        if (this._valueCache !== this.value) {
          this._valueCache = this.value;
          this.set('updated', true);
        } else {
          this.set('updated', false);
        }
      }
    });
  `).body[0].declaration;

  it('should return null when property value not found for simpleObject', () => {
    const value = utils.getPropertyValue(simpleObject, 'blah');
    expect(value).toEqual(undefined);
  });

  it('should return value when using a simple property path for simpleObject', () => {
    const value = utils.getPropertyValue(simpleObject, 'foo');
    expect(value).toEqual(true);
  });

  it('should return value when using a full property path for simpleObject', () => {
    const buzz = utils.getPropertyValue(simpleObject, 'bar.fizz.buzz');
    expect(buzz).toEqual('buzz');
  });

  it('should return null when property value not found for node', () => {
    const value = utils.getPropertyValue(node, 'blah');
    expect(value).toEqual(undefined);
  });

  it('should return value when using a simple property path for node', () => {
    const type = utils.getPropertyValue(node, 'type');
    expect(type).toEqual('CallExpression');
  });

  it('should return value when using a full property path for node', () => {
    const name = utils.getPropertyValue(node, 'callee.object.name');
    expect(name).toEqual('Ember');
  });
});

describe('collectObjectPatternBindings', () => {
  it('collects bindings correctly', () => {
    const node = parseVariableDeclarator('const { $ } = Ember');
    const collectedBindings = utils.collectObjectPatternBindings(node, {
      Ember: ['$'],
    });

    expect(collectedBindings).toEqual(['$']);
  });

  it('collects aliased bindings correctly', () => {
    const node = parseVariableDeclarator('const { $:foo } = Ember');
    const collectedBindings = utils.collectObjectPatternBindings(node, {
      Ember: ['$'],
    });

    expect(collectedBindings).toEqual(['foo']);
  });

  it('collects only relevant bindings correctly for multiple destructurings', () => {
    const node = parseVariableDeclarator('const { $, computed } = Ember');
    const collectedBindings = utils.collectObjectPatternBindings(node, {
      Ember: ['$'],
    });

    expect(collectedBindings).toEqual(['$']);
  });

  it('collects only relevant bindings correctly for multiple destructurings and aliases', () => {
    const node = parseVariableDeclarator('const { $: foo, computed } = Ember');
    const collectedBindings = utils.collectObjectPatternBindings(node, {
      Ember: ['$'],
    });

    expect(collectedBindings).toEqual(['foo']);
  });

  it('collects multiple relevant bindings', () => {
    const node = parseVariableDeclarator('const { $: foo, computed } = Ember');
    const collectedBindings = utils.collectObjectPatternBindings(node, {
      Ember: ['$', 'computed'],
    });

    expect(collectedBindings).toEqual(['foo', 'computed']);
  });
});

describe('isGlobalCallExpression', () => {
  it('recognizes when call is not global', () => {
    const node = parse("$('foo')");
    expect(utils.isGlobalCallExpression(node, '$', ['$', 'jQuery'])).not.toBeTruthy();
  });

  it('recognizes when global call', () => {
    const node = parse("$('foo')");
    expect(utils.isGlobalCallExpression(node, 'jQuery', ['$', 'jQuery'])).toBeTruthy();
  });
});