@dineroregnskab/eslint-plugin-custom-rules 4.0.1 → 4.3.0

package/README.md

@@ -63,7 +63,7 @@ module.exports = {
 ### Publish & install new rule locally
 
 1. Log in to npm using `npm login`
-2. run:
+2. run (in ./Packages/JavaScript/eslint-plugin-custom-rules/):
 
 ```bash
 # {version_type}: The type of version increment (patch, minor, major)

package/eslint-plugin-custom-rules.js

@@ -11,6 +11,7 @@ const rules = {
     'no-viewencapsulation-none': require('./rules/no-viewencapsulation-none'),
     'enum-comparison-reminder': require('./rules/enum-comparison-reminder'),
     'enum-lowercase': require('./rules/enum-lowercase'),
+    'no-feature-toggle-without-await': require('./rules/no-feature-toggle-without-await'),
 };
 
 console.log('Custom ESLint rules loaded:', Object.keys(rules)); // Debug log

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dineroregnskab/eslint-plugin-custom-rules",
-  "version": "4.0.1",
+  "version": "4.3.0",
   "description": "ESLint plugin with custom rules for Dinero Regnskab",
   "main": "eslint-plugin-custom-rules.js",
   "scripts": {

package/rules/no-feature-toggle-without-await.js

@@ -0,0 +1,147 @@
+module.exports = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description:
+                'Warn when createUserWithOrganization uses featureToggles in beforeEach but awaitFeatureReady is not used in the it() block',
+            category: 'Best Practices',
+            recommended: true,
+        },
+        messages: {
+            missingAwaitFeatureReady:
+                'Feature toggles detected in beforeEach via createUserWithOrganization, but cy.awaitFeatureReady() not found in this it() block.',
+        },
+    },
+
+    create(context) {
+        // Map each describe/context CallExpression node -> whether its beforeEach contains feature toggles
+        const describeFeatureMap = new WeakMap();
+
+        function findNearestDescribe(node) {
+            let current = node && node.parent;
+            while (current) {
+                if (
+                    current.type === 'CallExpression' &&
+                    current.callee &&
+                    (current.callee.name === 'describe' || current.callee.name === 'context')
+                ) {
+                    return current;
+                }
+                current = current.parent;
+            }
+            return null;
+        }
+
+        return {
+            'CallExpression[callee.name="beforeEach"]'(node) {
+                const describeNode = findNearestDescribe(node);
+                if (!describeNode) return;
+
+                const callback = node.arguments[0];
+                if (!callback) return;
+
+                let hasFeatureToggles = false;
+                walkNode(callback, (child) => {
+                    if (
+                        child.type === 'CallExpression' &&
+                        child.callee &&
+                        child.callee.name === 'createUserWithOrganization'
+                    ) {
+                        const arg = child.arguments[0];
+                        if (arg && arg.type === 'ObjectExpression') {
+                            arg.properties.forEach((prop) => {
+                                if (
+                                    prop.type === 'Property' &&
+                                    prop.key &&
+                                    (prop.key.name || prop.key.value)
+                                ) {
+                                    const keyName = prop.key.name || prop.key.value;
+
+                                    if (
+                                        keyName === 'featureToggles' &&
+                                        prop.value.type === 'ArrayExpression' &&
+                                        prop.value.elements.length > 0
+                                    ) {
+                                        hasFeatureToggles = true;
+                                    }
+                                }
+                            });
+                        }
+                    }
+                });
+
+                if (hasFeatureToggles) {
+                    describeFeatureMap.set(describeNode, true);
+                }
+            },
+
+            'CallExpression[callee.name="it"]'(node) {
+                // Walk ancestors to see if any describe/context has feature toggles
+                let current = node.parent;
+                let hasFeatureTogglesInAnyAncestor = false;
+                while (current) {
+                    if (
+                        current.type === 'CallExpression' &&
+                        current.callee &&
+                        (current.callee.name === 'describe' || current.callee.name === 'context')
+                    ) {
+                        if (describeFeatureMap.get(current)) {
+                            hasFeatureTogglesInAnyAncestor = true;
+                            break;
+                        }
+                    }
+                    current = current.parent;
+                }
+                if (!hasFeatureTogglesInAnyAncestor) return;
+
+                const callback = node.arguments[1] || node.arguments[0];
+                if (!callback) return;
+
+                let hasAwaitFeatureReady = false;
+                walkNode(callback, (child) => {
+                    if (
+                        child.type === 'CallExpression' &&
+                        child.callee &&
+                        child.callee.type === 'MemberExpression' &&
+                        child.callee.object &&
+                        child.callee.object.name === 'cy' &&
+                        child.callee.property &&
+                        (child.callee.property.name === 'awaitFeatureReady' ||
+                            child.callee.property.name === 'awaitFeaturesReady')
+                    ) {
+                        hasAwaitFeatureReady = true;
+                    }
+                });
+
+                if (!hasAwaitFeatureReady) {
+                    context.report({
+                        node: node,
+                        messageId: 'missingAwaitFeatureReady',
+                    });
+                }
+            },
+        };
+    },
+};
+
+function walkNode(node, callback) {
+    if (!node) return;
+
+    callback(node);
+
+    for (const key in node) {
+        if (key === 'parent' || key === 'loc' || key === 'range') continue;
+
+        const child = node[key];
+
+        if (Array.isArray(child)) {
+            child.forEach((item) => {
+                if (item && typeof item === 'object' && item.type) {
+                    walkNode(item, callback);
+                }
+            });
+        } else if (child && typeof child === 'object' && child.type) {
+            walkNode(child, callback);
+        }
+    }
+}