eslint-plugin-crisp 1.5.13 → 1.6.0

package/tests/rules/methods-ordering.test.js

@@ -0,0 +1,75 @@
+import rule from "../../rules/methods-ordering.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("methods-ordering", rule, {
+  valid: [
+    {
+      code: `class Service {
+        /** @public */
+        start() {}
+
+        /** @protected */
+        _refresh() {}
+
+        /** @private */
+        __reset() {}
+      }`
+    },
+    {
+      code: `class Service {
+        /** @private */
+        __first() {}
+
+        // --> NEXT SECTION <--
+        /** @public */
+        second() {}
+      }`
+    },
+    {
+      code: `class Service {
+        /** @private */
+        __before() {}
+
+        constructor() {}
+
+        /** @public */
+        after() {}
+
+        undocumented() {}
+      }`
+    }
+  ],
+
+  invalid: [
+    {
+      code: `class Service {
+        /** @protected */
+        _refresh() {}
+
+        /** @public */
+        start() {}
+      }`,
+      errors: [
+        {
+          message: "Public methods should be defined before protected or private methods."
+        }
+      ]
+    },
+    {
+      code: `class Service {
+        /** @private */
+        __reset() {}
+
+        /** @protected */
+        _refresh() {}
+      }`,
+      errors: [
+        {
+          message: "Protected methods should be defined before private methods."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/multiline-comment-end-backslash.test.js

@@ -0,0 +1,52 @@
+import rule from "../../rules/multiline-comment-end-backslash.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+const message = "Multiline comments should end with a backslash '\\', unless they are JSDoc comments.";
+
+ruleTester.run("multiline-comment-end-backslash", rule, {
+  valid: [
+    {
+      code: "// A standalone comment\nconst value = 1;"
+    },
+    {
+      code: "// First line \\\n//   continuation\nconst value = 1;"
+    },
+    {
+      code: "/**\n * JSDoc is exempt.\n */\nfunction run() {}"
+    },
+    {
+      code: "/* First line\n * continuation \\*/\nconst value = 1;"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "// First line\n//   continuation\nconst value = 1;",
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: "/* First line\n * continuation */\nconst value = 1;",
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: "// First\n//   continuation\n// Second\n//   continuation",
+      errors: [
+        {
+          message
+        },
+        {
+          message
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/newline-after-switch-case.test.js

@@ -0,0 +1,75 @@
+import rule from "../../rules/newline-after-switch-case.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("newline-after-switch-case", rule, {
+  valid: [
+    {
+      code: `switch (value) {
+  case 1:
+    run();
+    break;
+
+  case 2:
+    stop();
+}`
+    },
+    {
+      code: `switch (value) {
+  case 1:
+  case 2:
+    run();
+}`
+    },
+    {
+      code: `switch (value) {
+  default:
+    run();
+}`
+    }
+  ],
+
+  invalid: [
+    {
+      code: `switch (value) {
+  case 1:
+    run();
+    break;
+  case 2:
+    stop();
+}`,
+      output: `switch (value) {
+  case 1:
+    run();
+    break;
+
+  case 2:
+    stop();
+}`,
+      errors: [
+        {
+          message: "Newline required between switch cases."
+        }
+      ]
+    },
+    {
+      code: `switch (value) {
+  case 1:
+
+  case 2:
+    run();
+}`,
+      output: `switch (value) {
+  case 1:
+  case 2:
+    run();
+}`,
+      errors: [
+        {
+          message: "Extraneous newlines between switch cases."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-async.test.js

@@ -0,0 +1,57 @@
+import rule from "../../rules/no-async.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+const message = "async/await is not allowed, use Promises instead.";
+
+ruleTester.run("no-async", rule, {
+  valid: [
+    {
+      code: "function load() { return Promise.resolve(); }"
+    },
+    {
+      code: "const load = () => Promise.resolve();"
+    },
+    {
+      code: "class Service { load() { return Promise.resolve(); } }"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "async function load() {}",
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: "const load = async () => {};",
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: "const load = async function() {};",
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: "class Service { async load() {} }",
+      errors: [
+        {
+          message
+        },
+        {
+          message
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-extra-line-within-function.test.js

@@ -0,0 +1,87 @@
+import rule from "../../rules/no-extra-line-within-function.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+const message = "Expected at most one line break between declarations within a function.";
+
+ruleTester.run("no-extra-line-within-function", rule, {
+  valid: [
+    {
+      code: `function run() {
+  const first = 1;
+
+  const second = 2;
+}`
+    },
+    {
+      code: `const run = function() {
+  first();
+  second();
+};`
+    },
+    {
+      code: "const run = () => value;"
+    },
+    {
+      code: "const first = 1;\n\n\nconst second = 2;"
+    }
+  ],
+
+  invalid: [
+    {
+      code: `function run() {
+  const first = 1;
+
+
+  const second = 2;
+}`,
+      output: `function run() {
+  const first = 1;
+
+  const second = 2;
+}`,
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: `const run = function() {
+  first();
+
+
+  second();
+};`,
+      output: `const run = function() {
+  first();
+
+  second();
+};`,
+      errors: [
+        {
+          message
+        }
+      ]
+    },
+    {
+      code: `const run = () => {
+  first();
+
+
+
+  second();
+};`,
+      output: `const run = () => {
+  first();
+
+  second();
+};`,
+      errors: [
+        {
+          message
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-inline-function-in-ternary.test.js

@@ -0,0 +1,59 @@
+import rule from "../../rules/no-inline-function-in-ternary.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("no-inline-function-in-ternary", rule, {
+  valid: [
+    {
+      code: "const callback = enabled ? onEnabled : onDisabled;"
+    },
+    {
+      code: "const result = predicate(() => true) ? yes : no;"
+    },
+    {
+      code: "const callback = () => enabled ? yes : no;"
+    },
+    {
+      code: "items.map((item) => item.value);"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "const callback = enabled ? () => run() : fallback;",
+      errors: [
+        {
+          messageId: "inlineFunction"
+        }
+      ]
+    },
+    {
+      code: "const callback = enabled ? fallback : function() { run(); };",
+      errors: [
+        {
+          messageId: "inlineFunction"
+        }
+      ]
+    },
+    {
+      code: "const callback = enabled ? wrap(() => run()) : fallback;",
+      errors: [
+        {
+          messageId: "inlineFunction"
+        }
+      ]
+    },
+    {
+      code: "const callback = enabled ? () => run() : function() { stop(); };",
+      errors: [
+        {
+          messageId: "inlineFunction"
+        },
+        {
+          messageId: "inlineFunction"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-short-parameters.test.js

@@ -0,0 +1,62 @@
+import rule from "../../rules/no-short-parameters.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("no-short-parameters", rule, {
+  valid: [
+    "function map(value, index) {}",
+    "const map = ({ x }, [y]) => x + y;",
+    {
+      code: "const map = (x, i) => x + i;",
+      options: [
+        {
+          exceptions: ["x", "i"]
+        }
+      ]
+    }
+  ],
+
+  invalid: [
+    {
+      code: "function map(x) {}",
+      errors: [
+        {
+          message: "Parameter name 'x' is too short."
+        }
+      ]
+    },
+    {
+      code: "const map = function(a, value) {};",
+      errors: [
+        {
+          message: "Parameter name 'a' is too short."
+        }
+      ]
+    },
+    {
+      code: "class Mapper { map(x, y) {} }",
+      errors: [
+        {
+          message: "Parameter name 'x' is too short."
+        },
+        {
+          message: "Parameter name 'y' is too short."
+        }
+      ]
+    },
+    {
+      code: "const map = (x, y) => x + y;",
+      options: [
+        {
+          exceptions: ["x"]
+        }
+      ],
+      errors: [
+        {
+          message: "Parameter name 'y' is too short."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-snake-case.test.js

@@ -0,0 +1,81 @@
+import rule from "../../rules/no-snake-case.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("no-snake-case", rule, {
+  valid: [
+    "const MAX_RETRIES = 3;",
+    "const _MAX_RETRIES = 3;",
+    "let camelCase = 1;",
+    "function doWork(inputValue) {}",
+    "const object = { doWork(inputValue) {} };"
+  ],
+
+  invalid: [
+    {
+      code: "let retry_count = 1;",
+      errors: [
+        {
+          message: "Variable 'retry_count' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "const retry_count = 1;",
+      errors: [
+        {
+          message: "Variable 'retry_count' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "function do_work(inputValue) {}",
+      errors: [
+        {
+          message: "Function 'do_work' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "const callback = (input_value) => input_value;",
+      errors: [
+        {
+          message: "Parameter 'input_value' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "class Worker { do_work(inputValue) {} }",
+      errors: [
+        {
+          message: "Method 'do_work' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "const worker = { do_work(inputValue) {} };",
+      errors: [
+        {
+          message: "Method 'do_work' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "class Worker { run(input_value) {} }",
+      errors: [
+        {
+          message: "Parameter 'input_value' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    },
+    {
+      code: "const worker = { run(input_value) {} };",
+      errors: [
+        {
+          message: "Parameter 'input_value' should not use snake_case. Use camelCase instead."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-space-in-optional-arguments.test.js

@@ -0,0 +1,40 @@
+import rule from "../../rules/no-space-in-optional-arguments.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("no-space-in-optional-arguments", rule, {
+  valid: [
+    "function greet(name=\"World\") {}",
+    "const greet = (name=\"World\") => name;",
+    "const object = { greet(name=\"World\") {} };",
+    "function required(name) {}"
+  ],
+
+  invalid: [
+    {
+      code: "function greet(name =\"World\") {}",
+      errors: [
+        {
+          message: "There should be no space before or after = in optional parameters"
+        }
+      ]
+    },
+    {
+      code: "const greet = (name= \"World\") => name;",
+      errors: [
+        {
+          message: "There should be no space before or after = in optional parameters"
+        }
+      ]
+    },
+    {
+      code: "class Greeter { greet(name = \"World\") {} }",
+      errors: [
+        {
+          message: "There should be no space before or after = in optional parameters"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/no-useless-template-literals.test.js

@@ -0,0 +1,36 @@
+import rule from "../../rules/no-useless-template-literals.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("no-useless-template-literals", rule, {
+  valid: [
+    "const greeting = `Hello, ${name}`;",
+    "const greeting = `Hello, ` + name;",
+    "const greeting = name + `!`;",
+    "const greeting = \"Hello\";"
+  ],
+
+  invalid: [
+    {
+      code: "const greeting = `Hello`;",
+      errors: [
+        {
+          message: "Unnecessary use of template literals. Use regular strings instead."
+        }
+      ]
+    },
+    {
+      code: "call(`plain text`);",
+      errors: [
+        {
+          message: "Unnecessary use of template literals. Use regular strings instead."
+        }
+      ]
+    },
+    {
+      code: "const values = [`first`, `second`];",
+      errors: 2
+    }
+  ]
+});

package/tests/rules/no-var-in-blocks.test.js

@@ -0,0 +1,40 @@
+import rule from "../../rules/no-var-in-blocks.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("no-var-in-blocks", rule, {
+  valid: [
+    "var topLevel = 1;",
+    "function load() { var dependency = require(\"dependency\"); }",
+    "const load = () => { var member = require(\"dependency\").member; };",
+    "function calculate() { let result = 1; const other = 2; }"
+  ],
+
+  invalid: [
+    {
+      code: "function calculate() { var result = 1; }",
+      errors: [
+        {
+          message: "Unexpected 'var' declaration inside function, method, or class block."
+        }
+      ]
+    },
+    {
+      code: "const calculate = function() { var result; };",
+      errors: [
+        {
+          message: "Unexpected 'var' declaration inside function, method, or class block."
+        }
+      ]
+    },
+    {
+      code: "class Calculator { calculate() { var result = 1; } }",
+      errors: [
+        {
+          message: "Unexpected 'var' declaration inside function, method, or class block."
+        }
+      ]
+    }
+  ]
+});