Style guide applied to all the code involving the tests

jesusprubio · jesusprubio · commit e21c9a4a2a5b · 2016-05-15T21:47:07.000+02:00
diff --git a/test/detect-child-process.js b/test/detect-child-process.js
@@ -1,33 +1,35 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-child-process");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-child-process';
+const Rule = require(`../rules/${ruleName}`);
 
-var eslintTester = new RuleTester(),
-  valid = "child_process.exec('ls')",
-  invalidRequire = "require('child_process')",
-  invalidExec= "var child = require('child_process'); child.exec(com)";
+const valid = 'child_process.exec(\'ls\')';
+const invalidRequire = 'require(\'child_process\')';
+const invalidExec = 'var child = require(\'child_process\'); child.exec(com)';
 
 
-eslintTester.run("detect-child-process (require('child_process'))", rule, {
+tester.run(`${ruleName} (require("child_process"))`, Rule, {
   valid: [{ code: valid }],
   invalid: [
     {
       code: invalidRequire,
-      errors: [{ message: "Found require(\"child_process\")\n\t1:  " + invalidRequire }]
-    },
+      errors: [{ message: `Found require("child_process")\n\t1:  ${invalidRequire}` }]
+    }
   ]
 });
 
 
-eslintTester.run("detect-child-process (child_process.exec() wih non literal 1st arg.)", rule, {
+tester.run(`${ruleName} (child_process.exec() wih non literal 1st arg.)`, Rule, {
   valid: [{ code: valid }],
   invalid: [
     {
       code: invalidExec,
       errors: [
-        { message: "Found require(\"child_process\")\n\t1:  " + invalidExec },
-        { message: "Found child_process.exec() with non Literal first argument\n\t1:  " + invalidExec }]
-    },
+        { message: `Found require("child_process")\n\t1:  ${invalidExec}` },
+        { message: `Found child_process.exec() with non Literal first argument\n\t1:  ${invalidExec}` }]
+    }
   ]
 });
diff --git a/test/detect-disable-mustache-escape.js b/test/detect-disable-mustache-escape.js
@@ -1,17 +1,17 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-disable-mustache-escape");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-disable-mustache-escape';
 
-var eslintTester = new RuleTester();
 
-
-eslintTester.run("detect-disable-mustache-escape", rule, {
-  valid: [{ code: "escapeMarkup = false" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'escapeMarkup = false' }],
   invalid: [
     {
-      code: "a.escapeMarkup = false",
-      errors: [{ message: "Markup escaping disabled." }]
-    },
+      code: 'a.escapeMarkup = false',
+      errors: [{ message: 'Markup escaping disabled.' }]
+    }
   ]
 });
diff --git a/test/detect-eval-with-expression.js b/test/detect-eval-with-expression.js
@@ -1,17 +1,17 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-eval-with-expression");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-eval-with-expression';
 
-var eslintTester = new RuleTester();
 
-
-eslintTester.run("detect-eval-with-expression", rule, {
-  valid: [{ code: "eval('alert()')" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'eval(\'alert()\')' }],
   invalid: [
     {
-      code: "eval(a);",
-      errors: [{ message: "eval with argument of type Identifier" }]
-    },
+      code: 'eval(a);',
+      errors: [{ message: 'eval with argument of type Identifier' }]
+    }
   ]
 });
diff --git a/test/detect-new-buffer.js b/test/detect-new-buffer.js
@@ -1,18 +1,18 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-new-buffer");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-new-buffer';
+const invalid = 'var a = new Buffer(c)';
 
-var eslintTester = new RuleTester(),
-    invalid = "var a = new Buffer(c)";
 
-
-eslintTester.run("detect-new-buffer", rule, {
-  valid: [{ code: "var a = new Buffer('test')" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'var a = new Buffer(\'test\')' }],
   invalid: [
     {
       code: invalid,
-      errors: [{ message: "Found new Buffer\n\t1:  " + invalid }]
-    },
+      errors: [{ message: `Found new Buffer\n\t1:  ${invalid}` }]
+    }
   ]
 });
diff --git a/test/detect-no-csrf-before-method-override.js b/test/detect-no-csrf-before-method-override.js
@@ -1,17 +1,16 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-no-csrf-before-method-override");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-no-csrf-before-method-override';
 
-var eslintTester = new RuleTester();
-
-
-eslintTester.run("detect-no-csrf-before-method-override", rule, {
-  valid: [{ code: "express.methodOverride();express.csrf()" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'express.methodOverride();express.csrf()' }],
   invalid: [
     {
-      code: "express.csrf();express.methodOverride()",
-      errors: [{ message: "express.csrf() middleware found before express.methodOverride()" }]
-    },
+      code: 'express.csrf();express.methodOverride()',
+      errors: [{ message: 'express.csrf() middleware found before express.methodOverride()' }]
+    }
   ]
 });
diff --git a/test/detect-non-literal-fs-filename.js b/test/detect-non-literal-fs-filename.js
@@ -1,18 +1,18 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-non-literal-fs-filename");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const invalid = 'var a = fs.open(c)';
 
-var eslintTester = new RuleTester(),
-  invalid = "var a = fs.open(c)";
+const ruleName = 'detect-non-literal-fs-filename';
 
-
-eslintTester.run("detect-non-literal-fs-filename", rule, {
-  valid: [{ code: "var a = fs.open('test')" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'var a = fs.open(\'test\')' }],
   invalid: [
     {
       code: invalid,
-      errors: [{ message: "Found fs.open with non literal argument at index 0\n\t1:  " + invalid }]
-    },
+      errors: [{ message: `Found fs.open with non literal argument at index 0\n\t1:  ${invalid}` }]
+    }
   ]
 });
diff --git a/test/detect-non-literal-regexp.js b/test/detect-non-literal-regexp.js
@@ -1,18 +1,18 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-non-literal-regexp");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-non-literal-regexp';
+const invalid = 'var a = new RegExp(c, \'i\')';
 
-var eslintTester = new RuleTester(),
-  invalid = "var a = new RegExp(c, 'i')";
 
-
-eslintTester.run("detect-non-literal-regexp", rule, {
-  valid: [{ code: "var a = new RegExp('ab+c', 'i')" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'var a = new RegExp(\'ab+c\', \'i\')' }],
   invalid: [
     {
       code: invalid,
-      errors: [{ message: "Found non-literal argument to RegExp Constructor\n\t1:  " + invalid }]
-    },
+      errors: [{ message: `Found non-literal argument to RegExp Constructor\n\t1:  ${invalid}` }]
+    }
   ]
 });
diff --git a/test/detect-non-literal-require.js b/test/detect-non-literal-require.js
@@ -1,18 +1,18 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-non-literal-require");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-non-literal-require';
+const invalid = 'var a = require(c)';
 
-var eslintTester = new RuleTester(),
-  invalid = "var a = require(c)";
 
-
-eslintTester.run("detect-non-literal-require", rule, {
-  valid: [{ code: "var a = require('b')" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'var a = require(\'b\')' }],
   invalid: [
     {
       code: invalid,
-      errors: [{ message: "Found non-literal argument in require\n\t1:  " + invalid }]
-    },
+      errors: [{ message: `Found non-literal argument in require\n\t1:  ${invalid}` }]
+    }
   ]
 });
diff --git a/test/detect-object-injection.js b/test/detect-object-injection.js
@@ -1,44 +1,47 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-object-injection");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-object-injection';
 
-var eslintTester = new RuleTester(),
-  valid = "var a = {};",
-  // invalidVariable = "TODO",
-  // invalidFunction = "TODO",
-  invalidGeneric = "var a = {}; a[b] = 4";
+const Rule = require(`../rules/${ruleName}`);
+
+const valid = 'var a = {};';
+// const invalidVariable = "TODO";
+// const invalidFunction = "TODO";
+const invalidGeneric = 'var a = {}; a[b] = 4';
 
 
 // TODO
-// eslintTester.run("detect-object-injection (Variable Assigned to)", rule, {
+// tester.run(`${ruleName} (Variable Assigned to)`, Rule, {
 //   valid: [{ code: valid }],
 //   invalid: [
 //     {
 //       code: invalidVariable,
-//       errors: [{ message: "Variable Assigned to Object Injection Sink: <input>: 1\n\t" + invalidVariable + "\n\n" }]
-//     },
+//       errors: [{ message: `Variable Assigned to Object Injection Sink: <input>: 1\n\t${invalidVariable}\n\n` }]
+//     }
 //   ]
 // });
 //
 //
-// eslintTester.run("detect-object-injection (Function)", rule, {
+// tester.run(`${ruleName} (Function)`, Rule, {
 //   valid: [{ code: valid }],
 //   invalid: [
 //     {
 //       code: invalidFunction,
-//       errors: [{ message: "Variable Assigned to Object Injection Sink: <input>: 1\n\t" + invalidFunction + "\n\n" }]
-//     },
+//       errors: [{ message: `Variable Assigned to Object Injection Sink: <input>: 1\n\t${invalidFunction}\n\n` }]
+//     }
 //   ]
 // });
 
 
-eslintTester.run("detect-object-injection (Generic)", rule, {
+tester.run(`${ruleName} (Generic)`, Rule, {
   valid: [{ code: valid }],
   invalid: [
     {
       code: invalidGeneric,
-      errors: [{ message: "Generic Object Injection Sink: <input>: 1\n\t" + invalidGeneric + "\n\n" }]
-    },
+      errors: [{ message: `Generic Object Injection Sink: <input>: 1\n\t${invalidGeneric}\n\n` }]
+    }
   ]
 });
diff --git a/test/detect-possible-timing-attacks.js b/test/detect-possible-timing-attacks.js
@@ -1,34 +1,36 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-possible-timing-attacks");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-possible-timing-attacks';
+const Rule = require(`../rules/${ruleName}`);
 
-var eslintTester = new RuleTester(),
-  valid = "if (age === 5) {}",
-  invalidLeft = "if (password === 'mypass') {}",
-  invalidRigth = "if ('mypass' === password) {}";
+const valid = 'if (age === 5) {}';
+const invalidLeft = 'if (password === \'mypass\') {}';
+const invalidRigth = 'if (\'mypass\' === password) {}';
 
 
 // We only check with one string "password" and operator "==="
 // to KISS.
 
-eslintTester.run("detect-detect-possible-timing-attacks (left side)", rule, {
+tester.run(`${ruleName} (left side)`, Rule, {
   valid: [{ code: valid }],
   invalid: [
     {
       code: invalidLeft,
-      errors: [{ message: "Potential timing attack, left side: true\n\t1:  " + invalidLeft }]
-    },
+      errors: [{ message: `Potential timing attack, left side: true\n\t1:  ${invalidLeft}` }]
+    }
   ]
 });
 
 
-eslintTester.run("detect-detect-possible-timing-attacks (right side)", rule, {
+tester.run(`${ruleName} (right side)`, Rule, {
   valid: [{ code: valid }],
   invalid: [
     {
       code: invalidRigth,
-      errors: [{ message: "Potential timing attack, right side: true\n\t1:  " + invalidRigth }]
-    },
+      errors: [{ message: `Potential timing attack, right side: true\n\t1:  ${invalidRigth}` }]
+    }
   ]
 });
diff --git a/test/detect-pseudoRandomBytes.js b/test/detect-pseudoRandomBytes.js
@@ -1,18 +1,18 @@
-var RuleTester = require("eslint").RuleTester;
+'use strict';
 
-var rule = require("../rules/detect-pseudoRandomBytes");
+const RuleTester = require('eslint').RuleTester;
+const tester = new RuleTester();
 
+const ruleName = 'detect-pseudoRandomBytes';
+const invalid = 'crypto.pseudoRandomBytes';
 
-var eslintTester = new RuleTester(),
-  invalid = "crypto.pseudoRandomBytes";
 
-
-eslintTester.run("detect-pseudoRandomBytes", rule, {
-  valid: [{ code: "crypto.randomBytes" }],
+tester.run(ruleName, require(`../rules/${ruleName}`), {
+  valid: [{ code: 'crypto.randomBytes' }],
   invalid: [
     {
       code: invalid,
-      errors: [{ message: "Found crypto.pseudoRandomBytes which does not produce cryptographically strong numbers:\n\t1:  " + invalid }]
-    },
+      errors: [{ message: `Found crypto.pseudoRandomBytes which does not produce cryptographically strong numbers:\n\t1:  ${invalid}` }]
+    }
   ]
 });
diff --git a/test/detect-unsafe-regexp.js b/test/detect-unsafe-regexp.js
