babel/eslint/babel-eslint-plugin/test/rules/quotes.js

var rule = require("../../src/rules/quotes"),
  RuleTester = require("../helpers/RuleTester");

var ruleTester = new RuleTester();
ruleTester.run("babel/quotes", rule, {
  valid: [
    'var foo = "bar";',
    { code: "var foo = 'bar';", options: ["single"] },
    { code: 'var foo = "bar";', options: ["double"] },
    { code: "var foo = 1;", options: ["single"] },
    { code: "var foo = 1;", options: ["double"] },
    { code: 'var foo = "\'";', options: ["single", { avoidEscape: true }] },
    { code: "var foo = '\"';", options: ["double", { avoidEscape: true }] },
    {
      code: "var foo = <div>Hello world</div>;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6, ecmaFeatures: { jsx: true } },
    },
    {
      code: 'var foo = <div id="foo"></div>;',
      options: ["single"],
      parserOptions: { ecmaVersion: 6, ecmaFeatures: { jsx: true } },
    },
    {
      code: "var foo = <div>Hello world</div>;",
      options: ["double"],
      parserOptions: { ecmaVersion: 6, ecmaFeatures: { jsx: true } },
    },
    {
      code: "var foo = <div>Hello world</div>;",
      options: ["double", { avoidEscape: true }],
      parserOptions: { ecmaVersion: 6, ecmaFeatures: { jsx: true } },
    },
    {
      code: "var foo = `bar`;",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `bar 'baz'`;",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: 'var foo = `bar "baz"`;',
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    { code: "var foo = 1;", options: ["backtick"] },
    {
      code: 'var foo = "a string containing `backtick` quotes";',
      options: ["backtick", { avoidEscape: true }],
    },
    {
      code: 'var foo = <div id="foo"></div>;',
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6, ecmaFeatures: { jsx: true } },
    },
    {
      code: "var foo = <div>Hello world</div>;",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6, ecmaFeatures: { jsx: true } },
    },

    // Backticks are only okay if they have substitutions, contain a line break, or are tagged
    {
      code: "var foo = `back\ntick`;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `back\rtick`;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `back\u2028tick`;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `back\u2029tick`;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `back\\\\\ntick`;", // 2 backslashes followed by a newline
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `back\\\\\\\\\ntick`;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `\n`;",
      options: ["single"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `back${x}tick`;",
      options: ["double"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = tag`backtick`;",
      options: ["double"],
      parserOptions: { ecmaVersion: 6 },
    },

    // Backticks are also okay if allowTemplateLiterals
    {
      code: "var foo = `bar 'foo' baz` + 'bar';",
      options: ["single", { allowTemplateLiterals: true }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `bar 'foo' baz` + \"bar\";",
      options: ["double", { allowTemplateLiterals: true }],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "var foo = `bar 'foo' baz` + `bar`;",
      options: ["backtick", { allowTemplateLiterals: true }],
      parserOptions: { ecmaVersion: 6 },
    },

    // `backtick` should not warn the directive prologues.
    {
      code: '"use strict"; var foo = `backtick`;',
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: '"use strict"; \'use strong\'; "use asm"; var foo = `backtick`;',
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code:
        'function foo() { "use strict"; "use strong"; "use asm"; var foo = `backtick`; }',
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code:
        "(function() { 'use strict'; 'use strong'; 'use asm'; var foo = `backtick`; })();",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code:
        '(() => { "use strict"; "use strong"; "use asm"; var foo = `backtick`; })();',
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },

    // `backtick` should not warn import/export sources.
    {
      code: "import \"a\"; import 'b';",
      options: ["backtick"],
      parserOptions: { sourceType: "module" },
    },
    {
      code: "import a from \"a\"; import b from 'b';",
      options: ["backtick"],
      parserOptions: { sourceType: "module" },
    },
    {
      code: "export * from \"a\"; export * from 'b';",
      options: ["backtick"],
      parserOptions: { sourceType: "module" },
    },

    // `backtick` should not warn property/method names (not computed).
    {
      code: "var obj = {\"key0\": 0, 'key1': 1};",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "class Foo { 'bar'(){} }",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },
    {
      code: "class Foo { static ''(){} }",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
    },

    // Babel
    "<>foo</>;",
    { code: "<>foo</>;", options: ["single"] },
    { code: "<>foo</>;", options: ["double"] },
    "<><div /><div /></>;",
    { code: "<><div /><div /></>;", options: ["single"] },
    { code: "<><div /><div /></>;", options: ["double"] },
  ],
  invalid: [
    {
      code: "var foo = 'bar';",
      output: 'var foo = "bar";',
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: 'var foo = "bar";',
      output: "var foo = 'bar';",
      options: ["single"],
      errors: [{ message: "Strings must use singlequote.", type: "Literal" }],
    },
    {
      code: "var foo = `bar`;",
      output: "var foo = 'bar';",
      options: ["single"],
      parserOptions: {
        ecmaVersion: 6,
      },
      errors: [
        { message: "Strings must use singlequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "var foo = 'don\\'t';",
      output: 'var foo = "don\'t";',
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: 'var msg = "Plugin \'" + name + "\' not found"',
      output: "var msg = 'Plugin \\'' + name + '\\' not found'",
      options: ["single"],
      errors: [
        {
          message: "Strings must use singlequote.",
          type: "Literal",
          column: 11,
        },
        {
          message: "Strings must use singlequote.",
          type: "Literal",
          column: 31,
        },
      ],
    },
    {
      code: "var foo = 'bar';",
      output: 'var foo = "bar";',
      options: ["double"],
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: "var foo = `bar`;",
      output: 'var foo = "bar";',
      options: ["double"],
      parserOptions: {
        ecmaVersion: 6,
      },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: 'var foo = "bar";',
      output: "var foo = 'bar';",
      options: ["single", { avoidEscape: true }],
      errors: [{ message: "Strings must use singlequote.", type: "Literal" }],
    },
    {
      code: "var foo = 'bar';",
      output: 'var foo = "bar";',
      options: ["double", { avoidEscape: true }],
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: "var foo = '\\\\';",
      output: 'var foo = "\\\\";',
      options: ["double", { avoidEscape: true }],
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: 'var foo = "bar";',
      output: "var foo = 'bar';",
      options: ["single", { allowTemplateLiterals: true }],
      errors: [{ message: "Strings must use singlequote.", type: "Literal" }],
    },
    {
      code: "var foo = 'bar';",
      output: 'var foo = "bar";',
      options: ["double", { allowTemplateLiterals: true }],
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: "var foo = 'bar';",
      output: "var foo = `bar`;",
      options: ["backtick"],
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },
    {
      code: "var foo = 'b${x}a$r';",
      output: "var foo = `b\\${x}a$r`;",
      options: ["backtick"],
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },
    {
      code: 'var foo = "bar";',
      output: "var foo = `bar`;",
      options: ["backtick"],
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },
    {
      code: 'var foo = "bar";',
      output: "var foo = `bar`;",
      options: ["backtick", { avoidEscape: true }],
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },
    {
      code: "var foo = 'bar';",
      output: "var foo = `bar`;",
      options: ["backtick", { avoidEscape: true }],
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },

    // "use strict" is *not* a directive prologue in these statements so is subject to the rule
    {
      code: 'var foo = `backtick`; "use strict";',
      output: "var foo = `backtick`; `use strict`;",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },
    {
      code: '{ "use strict"; var foo = `backtick`; }',
      output: "{ `use strict`; var foo = `backtick`; }",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },
    {
      code: 'if (1) { "use strict"; var foo = `backtick`; }',
      output: "if (1) { `use strict`; var foo = `backtick`; }",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },

    // `backtick` should warn computed property names.
    {
      code: "var obj = {[\"key0\"]: 0, ['key1']: 1};",
      output: "var obj = {[`key0`]: 0, [`key1`]: 1};",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use backtick.", type: "Literal" },
        { message: "Strings must use backtick.", type: "Literal" },
      ],
    },
    {
      code: "class Foo { ['a'](){} static ['b'](){} }",
      output: "class Foo { [`a`](){} static [`b`](){} }",
      options: ["backtick"],
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use backtick.", type: "Literal" },
        { message: "Strings must use backtick.", type: "Literal" },
      ],
    },

    // https://github.com/eslint/eslint/issues/7084
    {
      code: '<div blah={"blah"} />',
      output: "<div blah={'blah'} />",
      options: ["single"],
      parserOptions: { ecmaFeatures: { jsx: true } },
      errors: [{ message: "Strings must use singlequote.", type: "Literal" }],
    },
    {
      code: "<div blah={'blah'} />",
      output: '<div blah={"blah"} />',
      options: ["double"],
      parserOptions: { ecmaFeatures: { jsx: true } },
      errors: [{ message: "Strings must use doublequote.", type: "Literal" }],
    },
    {
      code: "<div blah={'blah'} />",
      output: "<div blah={`blah`} />",
      options: ["backtick"],
      parserOptions: { ecmaFeatures: { jsx: true } },
      errors: [{ message: "Strings must use backtick.", type: "Literal" }],
    },

    // https://github.com/eslint/eslint/issues/7610
    {
      code: "`use strict`;",
      output: null,
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "function foo() { `use strict`; foo(); }",
      output: null,
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "foo = function() { `use strict`; foo(); }",
      output: null,
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "() => { `use strict`; foo(); }",
      output: null,
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "() => { foo(); `use strict`; }",
      output: '() => { foo(); "use strict"; }',
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "foo(); `use strict`;",
      output: 'foo(); "use strict";',
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },

    // https://github.com/eslint/eslint/issues/7646
    {
      code: "var foo = `foo\\nbar`;",
      output: 'var foo = "foo\\nbar";',
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "var foo = `foo\\\nbar`;", // 1 backslash followed by a newline
      output: 'var foo = "foo\\\nbar";',
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "var foo = `foo\\\\\\\nbar`;", // 3 backslashes followed by a newline
      output: 'var foo = "foo\\\\\\\nbar";',
      parserOptions: { ecmaVersion: 6 },
      errors: [
        { message: "Strings must use doublequote.", type: "TemplateLiteral" },
      ],
    },
    {
      code: "````",
      output: '""``',
      parserOptions: { ecmaVersion: 6 },
      errors: [
        {
          message: "Strings must use doublequote.",
          type: "TemplateLiteral",
          line: 1,
          column: 1,
        },
      ],
    },
  ],
});