@sun-asterisk/sunlint 1.3.0 → 1.3.2

package/integrations/eslint/plugin/rules/common/c076-single-behavior-per-test.js

@@ -1,254 +0,0 @@
-/**
- * Custom ESLint rule for: C076 – Each test should assert only one behavior
- * Rule ID: custom/c076  
- * Purpose: Ensure test functions focus on testing a single behavior/aspect
- * Note: Similar to C072 but with broader scope and different focus
- */
-
-module.exports = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Each test should assert only one behavior to maintain focus and clarity",
-      recommended: true,
-      category: "Testing"
-    },
-    schema: [
-      {
-        type: "object",
-        properties: {
-          maxAssertions: {
-            type: "integer",
-            minimum: 1,
-            default: 1
-          },
-          allowSetupAssertions: {
-            type: "boolean",
-            default: true
-          },
-          assertionPatterns: {
-            type: "array",
-            items: {
-              type: "string"
-            },
-            default: ["expect", "assert", "should"]
-          }
-        },
-        additionalProperties: false
-      }
-    ],
-    messages: {
-      tooManyAssertions: "Test '{{testName}}' has {{count}} assertions. Each test should focus on one behavior (max {{max}} assertions)",
-      multipleBehaviors: "Test '{{testName}}' appears to test multiple behaviors. Consider splitting into separate test cases"
-    }
-  },
-  create(context) {
-    const options = context.options[0] || {};
-    const maxAssertions = options.maxAssertions || 1;
-    const allowSetupAssertions = options.allowSetupAssertions !== false;
-    const assertionPatterns = options.assertionPatterns || ["expect", "assert", "should"];
-
-    function isTestFunction(node) {
-      if (!node || !node.callee) return false;
-
-      if (node.type === "CallExpression") {
-        // Direct test/it/describe calls
-        if (node.callee.type === "Identifier") {
-          return ["test", "it", "describe", "context"].includes(node.callee.name);
-        }
-        
-        // Method calls like jest.test, mocha.it, etc.
-        if (node.callee.type === "MemberExpression" &&
-            node.callee.property &&
-            ["test", "it", "describe", "context"].includes(node.callee.property.name)) {
-          return true;
-        }
-      }
-      return false;
-    }
-
-    function isSetupFunction(node) {
-      if (!node || !node.callee) return false;
-
-      const setupFunctions = ["beforeEach", "afterEach", "beforeAll", "afterAll", "before", "after"];
-      
-      if (node.type === "CallExpression") {
-        if (node.callee.type === "Identifier") {
-          return setupFunctions.includes(node.callee.name);
-        }
-        
-        if (node.callee.type === "MemberExpression" &&
-            node.callee.property &&
-            setupFunctions.includes(node.callee.property.name)) {
-          return true;
-        }
-      }
-      return false;
-    }
-
-    function isAssertionCall(node) {
-      if (!node || node.type !== "CallExpression" || !node.callee) {
-        return false;
-      }
-
-      // Direct assertion calls
-      if (node.callee.type === "Identifier") {
-        return assertionPatterns.includes(node.callee.name);
-      }
-
-      // Method calls like chai.expect, jest.expect, etc.
-      if (node.callee.type === "MemberExpression" && node.callee.property) {
-        return assertionPatterns.includes(node.callee.property.name);
-      }
-
-      return false;
-    }
-
-    function countAssertions(testBody, testName) {
-      let assertionCount = 0;
-      let setupAssertionCount = 0;
-      let hasMultipleBehaviorIndicators = false;
-
-      function traverse(node) {
-        if (!node || typeof node !== 'object') return;
-
-        // Count assertions
-        if (isAssertionCall(node)) {
-          // Check if this assertion is in setup/teardown
-          let parent = node;
-          let inSetup = false;
-          while (parent && parent.parent) {
-            parent = parent.parent;
-            if (parent.type === "CallExpression" && isSetupFunction(parent)) {
-              inSetup = true;
-              break;
-            }
-          }
-
-          if (inSetup) {
-            setupAssertionCount++;
-          } else {
-            assertionCount++;
-          }
-        }
-
-        // Look for multiple behavior indicators
-        if (node.type === "CallExpression") {
-          // Multiple nested test functions indicate multiple behaviors
-          if (isTestFunction(node) && node !== testBody.parent) {
-            hasMultipleBehaviorIndicators = true;
-          }
-        }
-
-        // Look for comment patterns that suggest multiple behaviors
-        if (node.type === "ExpressionStatement" && node.leadingComments) {
-          const comments = node.leadingComments.map(c => c.value.toLowerCase());
-          const behaviorKeywords = ["and", "also", "then", "next", "additionally", "furthermore"];
-          if (comments.some(comment => 
-                behaviorKeywords.some(keyword => comment.includes(keyword)))) {
-            hasMultipleBehaviorIndicators = true;
-          }
-        }
-
-        // Recursively check child nodes, but don't go into nested test functions
-        for (const key in node) {
-          if (key === 'parent' || key === 'range' || key === 'loc') continue;
-          
-          const child = node[key];
-          if (Array.isArray(child)) {
-            child.forEach(item => {
-              if (item && typeof item === 'object' && item.type) {
-                if (!(item.type === "CallExpression" && isTestFunction(item))) {
-                  traverse(item);
-                }
-              }
-            });
-          } else if (child && typeof child === 'object' && child.type) {
-            if (!(child.type === "CallExpression" && isTestFunction(child))) {
-              traverse(child);
-            }
-          }
-        }
-      }
-
-      traverse(testBody);
-
-      return {
-        assertions: assertionCount,
-        setupAssertions: setupAssertionCount,
-        hasMultipleBehaviors: hasMultipleBehaviorIndicators
-      };
-    }
-
-    return {
-      CallExpression(node) {
-        // Only check test function calls, not describe blocks
-        if (!isTestFunction(node) || (node.callee.type === "Identifier" && node.callee.name === "describe")) {
-          return;
-        }
-
-        // Skip describe blocks  
-        if (node.callee.type === "Identifier" && ["describe", "context"].includes(node.callee.name)) {
-          return;
-        }
-
-        // Must have test name and callback
-        if (!node.arguments || node.arguments.length < 2) return;
-
-        const testName = node.arguments[0];
-        const testCallback = node.arguments[1];
-        
-        if (!testCallback || 
-            (testCallback.type !== "FunctionExpression" && 
-             testCallback.type !== "ArrowFunctionExpression")) {
-          return;
-        }
-
-        const testNameStr = testName.type === "Literal" ? testName.value : 
-                           testName.type === "TemplateLiteral" ? "template" : "unnamed";
-
-        // Get function body
-        const fnBody = testCallback.body;
-        if (!fnBody) return;
-
-        // Handle both block statements and expression bodies
-        let bodyToCheck = fnBody;
-        if (testCallback.type === "ArrowFunctionExpression" && fnBody.type !== "BlockStatement") {
-          bodyToCheck = { type: "BlockStatement", body: [{ type: "ExpressionStatement", expression: fnBody }] };
-        }
-
-        // Count assertions and analyze behavior
-        const analysis = countAssertions(bodyToCheck, testNameStr);
-        
-        // Calculate effective assertions (exclude setup if allowed)
-        const effectiveAssertions = allowSetupAssertions ? 
-          analysis.assertions : 
-          analysis.assertions + analysis.setupAssertions;
-
-        // Report if too many assertions
-        if (effectiveAssertions > maxAssertions) {
-          context.report({
-            node,
-            messageId: "tooManyAssertions",
-            data: {
-              testName: testNameStr,
-              count: effectiveAssertions,
-              max: maxAssertions
-            }
-          });
-        }
-
-        // Report if multiple behaviors detected
-        if (analysis.hasMultipleBehaviors) {
-          context.report({
-            node,
-            messageId: "multipleBehaviors", 
-            data: {
-              testName: testNameStr
-            }
-          });
-        }
-      }
-    };
-  }
-};