eslint-plugin-crisp 1.5.13 → 1.6.1

package/tests/rules/vue-pinia-action-single-parameter.test.js

@@ -0,0 +1,234 @@
+import rule from "../../rules/vue-pinia-action-single-parameter.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester({
+  languageOptions: {
+    ecmaVersion: 2020,
+    sourceType: "module"
+  }
+});
+
+ruleTester.run("vue-pinia-action-single-parameter", rule, {
+  valid: [
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        const useStore = defineStore("example", {
+          actions: {
+            reset() {},
+            setValue(value) {},
+            updateValue({ id, value }) {},
+            updatePair([id, value]) {},
+            setOptionalValue(value = null) {}
+          }
+        });
+      `
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        defineStore("example", {
+          actions: {
+            reset: function() {},
+            setValue: function(value) {},
+            updateValue: ({ id, value }) => {},
+            updatePair: ([id, value]) => {},
+            setOptionalValue: (value = null) => {}
+          }
+        });
+      `
+    },
+    {
+      code: `
+        import { defineStore as definePiniaStore } from "pinia";
+
+        definePiniaStore("example", {
+          "actions": {
+            reset() {},
+            setValue(value) {}
+          }
+        });
+      `
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        function outside(first, second) {}
+
+        defineStore("example", {
+          state: (first, second) => ({}),
+          getters: {
+            combined(first, second) {}
+          },
+          actions: {
+            run(payload) {
+              return function nested(first, second) {};
+            }
+          }
+        });
+      `
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        const unrelated = {
+          actions: {
+            update(first, second) {},
+            forward(...args) {}
+          }
+        };
+      `
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        const useStore = defineStore("example", (first, second) => {
+          function nested(third, fourth) {}
+
+          return {};
+        });
+      `
+    },
+    {
+      code: `
+        import { defineStore } from "another-package";
+
+        defineStore("example", {
+          actions: {
+            update(first, second) {}
+          }
+        });
+      `
+    },
+    {
+      code: `
+        import pinia, { defineStore as importedDefineStore } from "pinia";
+
+        function wrapper(importedDefineStore) {
+          importedDefineStore("example", {
+            actions: {
+              update(first, second) {}
+            }
+          });
+        }
+
+        pinia.defineStore("example", {
+          actions: {
+            update(first, second) {}
+          }
+        });
+      `
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        const actions = {
+          update(first, second) {}
+        };
+
+        defineStore("example", { actions });
+      `
+    }
+  ],
+
+  invalid: [
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        defineStore("example", {
+          actions: {
+            updateValue(id, value) {}
+          }
+        });
+      `,
+      errors: [
+        {
+          messageId: "singlePayloadArgument"
+        }
+      ]
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        defineStore("example", {
+          actions: {
+            updateOther: function(id, value) {}
+          }
+        });
+      `,
+      errors: [
+        {
+          messageId: "singlePayloadArgument"
+        }
+      ]
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        defineStore("example", {
+          actions: {
+            updateArrow: (id, value) => {}
+          }
+        });
+      `,
+      errors: [
+        {
+          messageId: "singlePayloadArgument"
+        }
+      ]
+    },
+    {
+      code: `
+        import { defineStore } from "pinia";
+
+        defineStore("example", {
+          actions: {
+            forwardArguments(...args) {}
+          }
+        });
+      `,
+      errors: [
+        {
+          messageId: "singlePayloadArgument"
+        }
+      ]
+    },
+    {
+      code: `
+        import { defineStore as definePiniaStore } from "pinia";
+
+        definePiniaStore("example", {
+          actions: {
+            updateMethod(id, value) {},
+            updateFunction: function(id, value, extra) {},
+            updateArrow: (id, value = null) => {},
+            forward: (...args) => {}
+          }
+        });
+      `,
+      errors: [
+        {
+          messageId: "singlePayloadArgument"
+        },
+        {
+          messageId: "singlePayloadArgument"
+        },
+        {
+          messageId: "singlePayloadArgument"
+        },
+        {
+          messageId: "singlePayloadArgument"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/vue-props-declaration-line-break.test.js

@@ -0,0 +1,68 @@
+import rule from "../../rules/vue-props-declaration-line-break.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("vue-props-declaration-line-break", rule, {
+  valid: [
+    {
+      code: `
+        export default {
+          props: {
+            items: {
+              type: Array,
+
+              default: function() { return []; }
+            }
+          }
+        };
+      `
+    },
+    {
+      code: "export default { props: { items: { type: Array, default: () => [] } } };"
+    }
+  ],
+
+  invalid: [
+    {
+      code:
+        "export default { props: { items: { type: Array, " +
+        "default: function() { return []; } } } };",
+      output:
+        "export default { props: { items: { type: Array,\n\n" +
+        "default: function() { return []; } } } };",
+      errors: [
+        {
+          message:
+            "There should be a line break between 'type' and 'default' " +
+            "function in prop definition."
+        }
+      ]
+    },
+    {
+      code: `export default {
+  props: {
+    items: {
+      type: Array, default: function() { return []; }
+    }
+  }
+};`,
+      output: `export default {
+  props: {
+    items: {
+      type: Array,
+
+      default: function() { return []; }
+    }
+  }
+};`,
+      errors: [
+        {
+          message:
+            "There should be a line break between 'type' and 'default' " +
+            "function in prop definition."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/vue-props-declaration-multiline.test.js

@@ -0,0 +1,40 @@
+import rule from "../../rules/vue-props-declaration-multiline.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("vue-props-declaration-multiline", rule, {
+  valid: [
+    {
+      code: `
+        export default {
+          props: {
+            label: {
+              type: String,
+              required: true
+            }
+          }
+        };
+      `
+    },
+    {
+      code: "export default { props: { enabled: Boolean } };"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "export default { props: { label: {type: String, required: true} } };",
+      output:
+        "export default { props: { label: {\n" +
+        "type: String,\n" +
+        "required: true\n" +
+        "} } };",
+      errors: [
+        {
+          message: "Props should be declared in multiple lines."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/vue-props-declaration-order.test.js

@@ -0,0 +1,27 @@
+import rule from "../../rules/vue-props-declaration-order.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("vue-props-declaration-order", rule, {
+  valid: [
+    {
+      code: "export default { props: { alpha: String, beta: Boolean } };"
+    },
+    {
+      code: "const options = { props: { beta: Boolean, alpha: String } };"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "export default { props: { beta: Boolean, alpha: String } };",
+      output: "export default { props: { alpha: String, beta: Boolean } };",
+      errors: [
+        {
+          message: "Props should be in alphabetical order."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/vue-ref-case.test.js

@@ -0,0 +1,40 @@
+import rule from "../../rules/vue-ref-case.js";
+import { createVueRuleTester } from "../rule-tester.js";
+
+const ruleTester = createVueRuleTester();
+const filename = "TestComponent.vue";
+
+ruleTester.run("vue-ref-case", rule, {
+  valid: [
+    {
+      filename,
+      code: `<template>
+  <input ref="email_input">
+  <input :ref="dynamicRef">
+  <section ref />
+</template>
+
+<script setup>
+const dynamicRef = "email_input";
+</script>`
+    }
+  ],
+
+  invalid: [
+    {
+      filename,
+      code: `<template>
+  <input ref="emailInput">
+  <input ref="email-input">
+</template>`,
+      errors: [
+        {
+          message: "Ref attribute \"emailInput\" should be snake-cased."
+        },
+        {
+          message: "Ref attribute \"email-input\" should be snake-cased."
+        }
+      ]
+    }
+  ]
+});

package/tests/rules/vue-watch-handler.test.js

@@ -0,0 +1,89 @@
+import rule from "../../rules/vue-watch-handler.js";
+import createRuleTester from "../rule-tester.js";
+
+const ruleTester = createRuleTester();
+
+ruleTester.run("vue-watch-handler", rule, {
+  valid: [
+    {
+      code: `
+        export default {
+          watch: {
+            ready: { handler() {} },
+            value: { handler(value) {} },
+            item: { handler(newValue, oldValue) {} }
+          }
+        };
+      `
+    },
+    {
+      code: `
+        export default {
+          watch: {
+            value: {
+              immediate: true,
+              handler: (value) => {}
+            }
+          }
+        };
+      `
+    },
+    {
+      code: "const options = { observe: { value(value) {} } };"
+    },
+    {
+      code: "const options = { watch: { value(value) {} } };"
+    }
+  ],
+
+  invalid: [
+    {
+      code: "export default { watch: { value(value) {} } };",
+      errors: [
+        {
+          messageId: "objectForm"
+        }
+      ]
+    },
+    {
+      code: "export default { watch: { value: { immediate: true } } };",
+      errors: [
+        {
+          messageId: "missingHandler"
+        }
+      ]
+    },
+    {
+      code: "export default { watch: { value: { handler: \"onValue\" } } };",
+      errors: [
+        {
+          messageId: "invalidHandler"
+        }
+      ]
+    },
+    {
+      code: "export default { watch: { value: { handler(current, previous) {} } } };",
+      errors: [
+        {
+          messageId: "invalidSignature"
+        }
+      ]
+    },
+    {
+      code: "export default defineComponent({ watch: { value(value) {} } });",
+      errors: [
+        {
+          messageId: "objectForm"
+        }
+      ]
+    },
+    {
+      code: "export default { \"watch\": { value(value) {} } };",
+      errors: [
+        {
+          messageId: "objectForm"
+        }
+      ]
+    }
+  ]
+});

package/tests/rules-coverage.test.js

@@ -0,0 +1,19 @@
+import assert from "node:assert/strict";
+import { readdir } from "node:fs/promises";
+import test from "node:test";
+
+test("every rule has a matching unit test file", async () => {
+  const ruleFiles = await readdir(new URL("../rules/", import.meta.url));
+  const testFiles = await readdir(new URL("./rules/", import.meta.url));
+
+  const rules = ruleFiles
+    .filter(file => file.endsWith(".js"))
+    .map(file => file.slice(0, -3))
+    .sort();
+  const testedRules = testFiles
+    .filter(file => file.endsWith(".test.js"))
+    .map(file => file.slice(0, -8))
+    .sort();
+
+  assert.deepEqual(testedRules, rules);
+});