@sun-asterisk/sunlint 1.2.2 → 1.3.1

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
-            }
-          });
-        }
-      }
-    };
-  }
-};

package/rules/common/C029_catch_block_logging/analyzer-backup.js

@@ -1,426 +0,0 @@
-const fs = require('fs');
-cons  async analyze(files, language, options = {}) {
-    // Use Smart Pipeline as primary choice
-    if (this.smartPipeline) {
-      console.log('🎯 C029: Using Smart Pipeline (3-stage analysis)...');
-      return await this.smartPipeline.analyze(files, language, options);
-    } else if (this.astAnalyzer) {
-      console.log('🚀 C029: Using AST-enhanced analysis...');
-      return await this.astAnalyzer.analyze(files, language, options);
-    } else {
-      console.log('🔍 C029: Using regex-based analysis...');
-      return await this.analyzeWithRegex(files, language, options);
-    }
-  }ire('path');
-const { PatternMatcher } = require('../../utils/pattern-matchers');
-const { RuleHelper } = require('../../utils/rule-helpers');
-
-class C029Analyzer {
-  constructor() {
-    this.ruleId = 'C029';
-    this.ruleName = 'Enhanced Catch Block Error Logging';
-    this.description = 'Mọi catch block phải log nguyên nhân lỗi đầy đủ và bảo toàn context (Smart Pipeline 3-stage analysis)';
-    
-    // Load Smart Pipeline as primary analyzer
-    this.smartPipeline = null;
-    
-    try {
-      this.smartPipeline = require('./analyzer-smart-pipeline.js');
-      console.log('🎯 C029: Smart Pipeline loaded (3-stage: Regex → AST → Data Flow)');
-    } catch (error) {
-      console.warn('⚠️ C029: Smart Pipeline failed, falling back:', error.message);
-      
-      // Fallback to simpler analyzers
-      try {
-        this.astAnalyzer = require('./ast-analyzer.js');
-        console.log('🚀 C029: AST analyzer loaded (hybrid approach)');
-      } catch (error) {
-        console.warn('⚠️ C029: AST analyzer failed:', error.message);
-      }
-    }
-  }
-
-  async analyze(files, language, options = {}) {
-    // Use Smart Pipeline as primary choice
-    if (this.smartPipeline) {
-      console.log('🎯 C029: Using Smart Pipeline (3-stage analysis)...');
-      return await this.smartPipeline.analyze(files, language, options);
-    } else if (this.astAnalyzer) {
-      console.log('🚀 C029: Using AST-enhanced analysis...');
-      return await this.astAnalyzer.analyze(files, language, options);
-    } else {
-      console.log('🔍 C029: Using regex-based analysis...');
-      return await this.analyzeWithRegex(files, language, options);
-    }
-  }
-      console.log('🧠 C029: Using Data Flow analysis (IDE-level)...');
-      return await this.dataFlowAnalyzer.analyze(files, language, options);
-    } else if (this.astAnalyzer) {
-      console.log('� C029: Using AST-enhanced analysis...');
-      return await this.astAnalyzer.analyze(files, language, options);
-    } else {
-      console.log('🔍 C029: Using regex-based analysis...');
-      return await this.analyzeWithRegex(files, language, options);
-    }
-  }
-
-  async analyzeWithRegex(files, language, options = {}) {
-    const violations = [];
-    
-    for (const filePath of files) {
-      if (options.verbose) {
-        console.log(`🔍 Running pattern analysis on ${path.basename(filePath)}`);
-      }
-      
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const fileViolations = await this.analyzeFile(filePath, content, language, options);
-        violations.push(...fileViolations);
-      } catch (error) {
-        console.warn(`⚠️ Failed to analyze ${filePath}: ${error.message}`);
-      }
-    }
-    
-    return violations;
-  }
-
-  async analyzeFile(filePath, content, language, config) {
-    switch (language) {
-      case 'typescript':
-      case 'javascript':
-        return this.analyzeTypeScript(filePath, content, config);
-      default:
-        return [];
-    }
-  }
-
-  async analyzeTypeScript(filePath, content, config) {
-    const violations = [];
-    const lines = content.split('\n');
-
-    // Focus on core functionality - only detect truly silent catch blocks
-    violations.push(...this.findSilentCatchBlocks(lines, filePath));
-    // Disabled strict checks to reduce false positives:
-    // violations.push(...this.findInadequateErrorLogging(lines, filePath));
-    // violations.push(...this.findMissingErrorContext(lines, filePath));
-
-    return violations;
-  }
-
-  /**
-   * Core functionality from ESLint C029 - detect silent catch blocks
-   */
-  findSilentCatchBlocks(lines, filePath) {
-    const violations = [];
-    
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      // Detect catch block start
-      if (this.isCatchBlockStart(trimmedLine)) {
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        
-        if (catchBlockInfo.isEmpty) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Empty catch block - error is silently ignored',
-            severity: 'error',
-            code: trimmedLine,
-            type: 'empty_catch_block',
-            confidence: 1.0,
-            suggestion: 'Add error logging or rethrowing in catch block'
-          });
-        } else if (!catchBlockInfo.hasLoggingOrRethrow) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Catch block must log error or rethrow - silent error handling hides bugs',
-            severity: 'error',
-            code: trimmedLine,
-            type: 'silent_catch_block',
-            confidence: 0.9,
-            suggestion: 'Add error logging (console.error, logger.error) or rethrow the error'
-          });
-        }
-      }
-    });
-
-    return violations;
-  }
-
-  /**
-   * SunLint enhanced functionality - detect inadequate error logging
-   */
-  findInadequateErrorLogging(lines, filePath) {
-    const violations = [];
-    
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      if (this.isCatchBlockStart(trimmedLine)) {
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        
-        if (catchBlockInfo.hasLoggingOrRethrow && !catchBlockInfo.hasAdequateLogging) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Error logging should include error message, stack trace, and context',
-            severity: 'warning',
-            code: trimmedLine,
-            type: 'inadequate_error_logging',
-            confidence: 0.8,
-            suggestion: 'Include error.message, error.stack, and relevant context in error logging'
-          });
-        }
-      }
-    });
-
-    return violations;
-  }
-
-  /**
-   * SunLint enhanced functionality - detect missing error context
-   * DISABLED: Too strict, causing false positives
-   */
-  findMissingErrorContext(lines, filePath) {
-    // Disabled to reduce false positives
-    return [];
-    
-    /* Original strict implementation:
-    const violations = [];
-    
-    lines.forEach((line, index) => {
-      const lineNumber = index + 1;
-      const trimmedLine = line.trim();
-
-      if (this.isCatchBlockStart(trimmedLine)) {
-        const catchBlockInfo = this.extractCatchBlockInfo(lines, index);
-        
-        if (catchBlockInfo.hasLoggingOrRethrow && !catchBlockInfo.hasContextualLogging) {
-          violations.push({
-            ruleId: this.ruleId,
-            file: filePath,
-            line: lineNumber,
-            column: line.indexOf('catch') + 1,
-            message: 'Error logging should include operational context (function name, input parameters)',
-            severity: 'info',
-            code: trimmedLine,
-            type: 'missing_error_context',
-            confidence: 0.7,
-            suggestion: 'Include function name, input parameters, and operational context in error logging'
-          });
-        }
-      }
-    });
-
-    return violations;
-    */
-  }
-
-  isCatchBlockStart(line) {
-    return line.includes('catch (') || line.includes('catch(');
-  }
-
-  extractCatchBlockInfo(lines, startIndex) {
-    const catchBlockLines = [];
-    let braceDepth = 0;
-    let foundCatchBrace = false;
-
-    for (let i = startIndex; i < lines.length; i++) {
-      const line = lines[i];
-      catchBlockLines.push(line);
-      
-      // Check if this is the catch line with opening brace
-      if (this.isCatchBlockStart(line.trim())) {
-        // Count braces in the catch line itself
-        for (const char of line) {
-          if (char === '{') {
-            foundCatchBrace = true;
-            braceDepth = 1; // Start counting from 1 for the catch block
-          }
-        }
-      } else if (foundCatchBrace) {
-        // Count braces in subsequent lines
-        for (const char of line) {
-          if (char === '{') {
-            braceDepth++;
-          } else if (char === '}') {
-            braceDepth--;
-          }
-        }
-        
-        // If we've closed all braces, we're done
-        if (braceDepth === 0) {
-          break;
-        }
-      }
-    }
-
-    const content = catchBlockLines.join('\n').toLowerCase();
-    const originalContent = catchBlockLines.join('\n');
-    
-    return {
-      isEmpty: this.isCatchBlockEmpty(catchBlockLines),
-      hasLoggingOrRethrow: this.hasLoggingOrRethrow(content, originalContent),
-      hasAdequateLogging: this.hasAdequateErrorLogging(content, originalContent),
-      hasContextualLogging: this.hasContextualErrorLogging(content, originalContent)
-    };
-  }
-
-  isCatchBlockEmpty(catchBlockLines) {
-    if (catchBlockLines.length === 0) return true;
-    
-    // Join all lines and find the content between braces
-    const fullContent = catchBlockLines.join('\n');
-    
-    // Find the opening brace and closing brace
-    let openBraceIndex = fullContent.indexOf('{');
-    let closeBraceIndex = fullContent.lastIndexOf('}');
-    
-    if (openBraceIndex === -1 || closeBraceIndex === -1) {
-      return true; // Malformed catch block
-    }
-    
-    // Extract body content between braces
-    const bodyContent = fullContent.substring(openBraceIndex + 1, closeBraceIndex).trim();
-    
-    // Remove comments and whitespace
-    const cleanedBody = bodyContent
-      .replace(/\/\*[\s\S]*?\*\//g, '') // Remove block comments
-      .replace(/\/\/.*$/gm, '') // Remove line comments
-      .replace(/\s+/g, ' ') // Normalize whitespace
-      .trim();
-    
-    return cleanedBody.length === 0;
-  }
-
-  hasLoggingOrRethrow(content, originalContent) {
-    // Check for throw statements
-    if (content.includes('throw ') || content.includes('throw;')) {
-      return true;
-    }
-
-    // Check for test assertions - valid form of error handling
-    const testPatterns = [
-      'expect(',
-      'assert(',
-      'tobeinstanceof',
-      'toequal(',
-      'tohavebeencalled',
-      'toBe(',
-      'toHaveBeenCalledWith'
-    ];
-
-    const hasTestAssertions = testPatterns.some(pattern => 
-      content.includes(pattern.toLowerCase()) || originalContent.toLowerCase().includes(pattern.toLowerCase())
-    );
-
-    if (hasTestAssertions) {
-      return true;
-    }
-
-    // Check for Redux/async thunk error handling
-    const reduxErrorHandlers = [
-      'handleaxioserror',
-      'rejectwithvalue',
-      'dispatch(',
-      'seterror(',
-      'return value',
-      'return rejectwithvalue'
-    ];
-
-    const hasReduxHandling = reduxErrorHandlers.some(pattern => 
-      content.includes(pattern.toLowerCase()) || originalContent.toLowerCase().includes(pattern.toLowerCase())
-    );
-
-    if (hasReduxHandling) {
-      return true;
-    }
-
-    // Check for logging patterns (expanded from original)
-    const loggingPatterns = [
-      'console.error',
-      'console.log',
-      'console.warn',
-      'logger.error',
-      'log.error',
-      'logger.warn',
-      'log.warn',
-      'winston.error',
-      'bunyan.error',
-      'pino.error',
-      '.error(',
-      '.warn(',
-      '.log('
-    ];
-
-    // Accept basic error logging - don't require context
-    const hasBasicLogging = loggingPatterns.some(pattern => 
-      content.includes(pattern) || originalContent.includes(pattern)
-    );
-
-    return hasBasicLogging;
-  }
-
-  hasAdequateErrorLogging(content, originalContent) {
-    // Check for error properties being logged
-    const errorProperties = [
-      'error.message',
-      'error.stack',
-      'err.message',
-      'err.stack',
-      'e.message',
-      'e.stack',
-      'error.name',
-      'error.cause'
-    ];
-
-    const hasErrorProperties = errorProperties.some(prop => 
-      content.includes(prop) || originalContent.includes(prop)
-    );
-
-    // Check for comprehensive error logging
-    const hasLogging = this.hasLoggingOrRethrow(content, originalContent);
-    
-    return hasLogging && hasErrorProperties;
-  }
-
-  hasContextualErrorLogging(content, originalContent) {
-    // Check for contextual information in logging
-    const contextualPatterns = [
-      'function',
-      'method',
-      'operation',
-      'input',
-      'parameters',
-      'context',
-      'state',
-      'request',
-      'response',
-      'userId',
-      'sessionId',
-      'transactionId'
-    ];
-
-    // Check if logging includes contextual information
-    const hasContextualInfo = contextualPatterns.some(pattern => 
-      content.includes(pattern) || originalContent.includes(pattern)
-    );
-
-    // Check for template literals or string concatenation (indicates contextual logging)
-    const hasTemplateLogging = originalContent.includes('${') || originalContent.includes('" + ') || originalContent.includes("' + ");
-
-    return hasContextualInfo || hasTemplateLogging;
-  }
-}
-
-module.exports = new C029Analyzer();