mirror of
https://github.com/hanzoai/eslint.git
synced 2026-10-30 19:38:10 +00:00
415 lines
7.7 KiB
JavaScript
415 lines
7.7 KiB
JavaScript
/**
|
|
* @fileoverview Tests for the no-object-constructor rule
|
|
* @author Francesco Trotta
|
|
*/
|
|
|
|
"use strict";
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Requirements
|
|
//------------------------------------------------------------------------------
|
|
|
|
const rule = require("../../../lib/rules/no-object-constructor"),
|
|
RuleTester = require("../../../lib/rule-tester/rule-tester");
|
|
|
|
//------------------------------------------------------------------------------
|
|
// Tests
|
|
//------------------------------------------------------------------------------
|
|
|
|
const ruleTester = new RuleTester({
|
|
languageOptions: { ecmaVersion: "latest", sourceType: "script" },
|
|
});
|
|
|
|
ruleTester.run("no-object-constructor", rule, {
|
|
valid: [
|
|
"new Object(x)",
|
|
"Object(x)",
|
|
"new globalThis.Object",
|
|
"const createObject = Object => new Object()",
|
|
"var Object; new Object;",
|
|
{
|
|
code: "new Object()",
|
|
languageOptions: {
|
|
globals: {
|
|
Object: "off",
|
|
},
|
|
},
|
|
},
|
|
],
|
|
invalid: [
|
|
{
|
|
code: "new Object",
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: "({})",
|
|
data: { replacement: "({})" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Object()",
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: "({})",
|
|
data: { replacement: "({})" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "const fn = () => Object();",
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: "const fn = () => ({});",
|
|
data: { replacement: "({})" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "Object() instanceof Object;",
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: "({}) instanceof Object;",
|
|
data: { replacement: "({})" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "const obj = Object?.();",
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: "const obj = {};",
|
|
data: { replacement: "{}" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
{
|
|
code: "(new Object() instanceof Object);",
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: "({} instanceof Object);",
|
|
data: { replacement: "{}" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
},
|
|
|
|
...[
|
|
// Semicolon required before `({})` to compensate for ASI
|
|
{
|
|
code: `
|
|
foo
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
foo()
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
new foo
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
(a++)
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
++a
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
const foo = function() {}
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
const foo = class {}
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
foo = this.return
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
var yield = bar.yield
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
var foo = { bar: baz }
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
<foo />
|
|
Object()
|
|
`,
|
|
languageOptions: {
|
|
parserOptions: { ecmaFeatures: { jsx: true } },
|
|
},
|
|
},
|
|
{
|
|
code: `
|
|
<foo></foo>
|
|
Object()
|
|
`,
|
|
languageOptions: {
|
|
parserOptions: { ecmaFeatures: { jsx: true } },
|
|
},
|
|
},
|
|
].map(props => ({
|
|
...props,
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteralAfterSemicolon",
|
|
output: props.code.replace(
|
|
/(new )?Object\(\)/u,
|
|
";({})",
|
|
),
|
|
data: { replacement: "({})" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
})),
|
|
|
|
...[
|
|
// No semicolon required before `({})` because ASI does not occur
|
|
{
|
|
code: `
|
|
{}
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
function foo() {}
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
class Foo {}
|
|
Object()
|
|
`,
|
|
},
|
|
{ code: "foo: Object();" },
|
|
{ code: "foo();Object();" },
|
|
{ code: "{ Object(); }" },
|
|
{ code: "if (a) Object();" },
|
|
{ code: "if (a); else Object();" },
|
|
{ code: "while (a) Object();" },
|
|
{
|
|
code: `
|
|
do Object();
|
|
while (a);
|
|
`,
|
|
},
|
|
{ code: "for (let i = 0; i < 10; i++) Object();" },
|
|
{ code: "for (const prop in obj) Object();" },
|
|
{ code: "for (const element of iterable) Object();" },
|
|
{ code: "with (obj) Object();" },
|
|
|
|
// No semicolon required before `({})` because ASI still occurs
|
|
{
|
|
code: `
|
|
const foo = () => {}
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
a++
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
a--
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
function foo() {
|
|
return
|
|
Object();
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
function * foo() {
|
|
yield
|
|
Object();
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
do {}
|
|
while (a)
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
debugger
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
for (;;) {
|
|
break
|
|
Object()
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
for (;;) {
|
|
continue
|
|
Object()
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
foo: break foo
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
foo: while (true) continue foo
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
const foo = bar
|
|
export { foo }
|
|
Object()
|
|
`,
|
|
languageOptions: { sourceType: "module" },
|
|
},
|
|
{
|
|
code: `
|
|
export { foo } from 'bar'
|
|
Object()
|
|
`,
|
|
languageOptions: { sourceType: "module" },
|
|
},
|
|
{
|
|
code: `
|
|
export * as foo from 'bar'
|
|
Object()
|
|
`,
|
|
languageOptions: { sourceType: "module" },
|
|
},
|
|
{
|
|
code: `
|
|
import foo from 'bar'
|
|
Object()
|
|
`,
|
|
languageOptions: { sourceType: "module" },
|
|
},
|
|
{
|
|
code: `
|
|
var yield = 5;
|
|
|
|
yield: while (foo) {
|
|
if (bar)
|
|
break yield
|
|
new Object();
|
|
}
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
var foo
|
|
Object()
|
|
`,
|
|
},
|
|
{
|
|
code: `
|
|
let bar
|
|
Object()
|
|
`,
|
|
},
|
|
].map(props => ({
|
|
...props,
|
|
errors: [
|
|
{
|
|
messageId: "preferLiteral",
|
|
suggestions: [
|
|
{
|
|
messageId: "useLiteral",
|
|
output: props.code.replace(
|
|
/(new )?Object\(\)/u,
|
|
"({})",
|
|
),
|
|
data: { replacement: "({})" },
|
|
},
|
|
],
|
|
},
|
|
],
|
|
})),
|
|
],
|
|
});
|