Trigger Refactor Pipeline

/**
 * Test class template for trigger handlers
 * 
 * INSTRUCTIONS:
 * 1. Replace [ObjectName] with your SObject (e.g., Opportunity)
 * 2. Replace [HandlerClass] with your handler class name
 * 3. Implement the setupTestData() method with your test records
 * 4. Add specific test methods for each handler method
 * 5. Ensure 100% code coverage
 */
@IsTest
private class [ObjectName]TriggerHandlerTest {
    
    /**
     * Setup test data that all test methods can use
     */
    @TestSetup
    static void setupTestData() {
        // TODO: Create test records here
        // Example:
        // List<Opportunity> testOpps = new List<Opportunity>();
        // for (Integer i = 0; i < 10; i++) {
        //     testOpps.add(new Opportunity(
        //         Name = 'Test Opp ' + i,
        //         StageName = 'Prospecting',
        //         CloseDate = Date.today().addDays(30),
        //         Amount = 5000
        //     ));
        // }
        // insert testOpps;
    }
    
    /**
     * Test beforeInsert handler - Positive case
     */
    @IsTest
    static void testBeforeInsert_Positive() {
        Test.startTest();
        
        // TODO: Create valid test records
        // List<Opportunity> testRecords = new List<Opportunity>{
        //     new Opportunity(
        //         Name = 'Valid Opp',
        //         StageName = 'Prospecting',
        //         CloseDate = Date.today().addDays(30),
        //         Amount = 10000
        //     )
        // };
        
        // Insert should succeed
        // insert testRecords;
        
        Test.stopTest();
        
        // TODO: Add assertions
        // List<Opportunity> inserted = [SELECT Id, Name FROM Opportunity WHERE Name = 'Valid Opp'];
        // System.Assert.areEqual(1, inserted.size(), 'Should insert 1 record');
    }
    
    /**
     * Test beforeInsert handler - Negative case
     */
    @IsTest
    static void testBeforeInsert_Negative() {
        Test.startTest();
        
        Boolean exceptionThrown = false;
        
        try {
            // TODO: Create invalid test records that should fail validation
            // List<Opportunity> testRecords = new List<Opportunity>{
            //     new Opportunity(
            //         Name = 'Invalid Opp',
            //         StageName = 'Closed Won',
            //         CloseDate = Date.today(),
            //         Amount = 500  // Below minimum
            //     )
            // };
            
            // insert testRecords;
            
        } catch (DmlException e) {
            exceptionThrown = true;
            // TODO: Assert error message
            // System.Assert.isTrue(e.getMessage().contains('must have Amount'),
            //     'Should throw validation error');
        }
        
        Test.stopTest();
        
        // System.Assert.isTrue(exceptionThrown, 'Should have thrown an exception');
    }
    
    /**
     * Test beforeUpdate handler - Positive case
     */
    @IsTest
    static void testBeforeUpdate_Positive() {
        // TODO: Query existing test data from @TestSetup
        // List<Opportunity> testOpps = [SELECT Id, StageName, Description FROM Opportunity LIMIT 1];
        
        Test.startTest();
        
        // TODO: Update records to trigger handler logic
        // testOpps[0].StageName = 'Qualification';
        // update testOpps;
        
        Test.stopTest();
        
        // TODO: Add assertions
        // Opportunity updated = [SELECT Description FROM Opportunity WHERE Id = :testOpps[0].Id];
        // System.Assert.isTrue(updated.Description.contains('Stage changed'),
        //     'Description should be updated');
    }
    
    /**
     * Test beforeUpdate handler - Negative case
     */
    @IsTest
    static void testBeforeUpdate_Negative() {
        // TODO: Implement negative test for beforeUpdate
        Test.startTest();
        
        // TODO: Attempt update that should fail
        
        Test.stopTest();
        
        // TODO: Assert failure occurred
    }
    
    /**
     * Test afterInsert handler - Positive case
     */
    @IsTest
    static void testAfterInsert_Positive() {
        Test.startTest();
        
        // TODO: Create and insert records
        
        Test.stopTest();
        
        // TODO: Query for related records created by handler
        // List<Task> createdTasks = [SELECT Id FROM Task];
        // System.Assert.areEqual(1, createdTasks.size(), 'Should create 1 task');
    }
    
    /**
     * Test afterUpdate handler - Positive case
     */
    @IsTest
    static void testAfterUpdate_Positive() {
        // TODO: Query existing test data
        // List<Opportunity> testOpps = [SELECT Id, StageName FROM Opportunity LIMIT 1];
        
        Test.startTest();
        
        // TODO: Update to trigger after-update logic
        // testOpps[0].StageName = 'Closed Won';
        // update testOpps;
        
        Test.stopTest();
        
        // TODO: Query for side effects (e.g., Tasks created)
        // List<Task> tasks = [SELECT Id, Subject FROM Task WHERE WhatId = :testOpps[0].Id];
        // System.Assert.areEqual(1, tasks.size(), 'Should create 1 task');
        // System.Assert.areEqual('Send thank-you', tasks[0].Subject);
    }
    
    /**
     * Test bulk operations - 200+ records
     * Critical for validating bulkification
     */
    @IsTest
    static void testBulkInsert() {
        Test.startTest();
        
        // TODO: Create 200+ records
        // List<Opportunity> bulkOpps = new List<Opportunity>();
        // for (Integer i = 0; i < 200; i++) {
        //     bulkOpps.add(new Opportunity(
        //         Name = 'Bulk Opp ' + i,
        //         StageName = 'Prospecting',
        //         CloseDate = Date.today().addDays(30),
        //         Amount = 10000
        //     ));
        // }
        
        // insert bulkOpps;
        
        Test.stopTest();
        
        // TODO: Assert all records inserted successfully
        // List<Opportunity> inserted = [SELECT Id FROM Opportunity WHERE Name LIKE 'Bulk Opp%'];
        // System.Assert.areEqual(200, inserted.size(), 'Should insert all 200 records');
    }
    
    /**
     * Test bulk update with mixed scenarios
     * Some records qualify for logic, others don't
     */
    @IsTest
    static void testBulkUpdate_Mixed() {
        // Create test data
        List<Opportunity> testOpps = new List<Opportunity>();
        for (Integer i = 0; i < 50; i++) {
            testOpps.add(new Opportunity(
                Name = 'Bulk Update Opp ' + i,
                StageName = 'Prospecting',
                CloseDate = Date.today().addDays(30),
                Amount = 10000
            ));
        }
        insert testOpps;
        
        Test.startTest();
        
        // Update half to trigger logic, half to not trigger
        for (Integer i = 0; i < testOpps.size(); i++) {
            if (Math.mod(i, 2) == 0) {
                // TODO: Set condition that triggers handler logic
                // testOpps[i].StageName = 'Closed Won';
            } else {
                // TODO: Set condition that doesn't trigger handler logic
                // testOpps[i].Amount = 15000;
            }
        }
        
        // update testOpps;
        
        Test.stopTest();
        
        // TODO: Assert only qualifying records triggered side effects
        // List<Task> tasks = [SELECT Id FROM Task WHERE WhatId IN :testOpps];
        // System.Assert.areEqual(25, tasks.size(), 'Should create tasks for 25 qualifying records');
    }
    
    /**
     * Test governor limits are not exceeded
     */
    @IsTest
    static void testGovernorLimits() {
        Test.startTest();
        
        // TODO: Create maximum allowed records
        // List<Opportunity> maxOpps = new List<Opportunity>();
        // for (Integer i = 0; i < 200; i++) {
        //     maxOpps.add(new Opportunity(
        //         Name = 'Limit Test ' + i,
        //         StageName = 'Closed Won',
        //         CloseDate = Date.today(),
        //         Amount = 10000
        //     ));
        // }
        
        // insert maxOpps;
        
        Test.stopTest();
        
        // Assert we're under governor limits
        System.Assert.isTrue(Limits.getDmlStatements() < Limits.getLimitDmlStatements(),
            'Should not exceed DML statement limit');
        System.Assert.isTrue(Limits.getQueries() < Limits.getLimitQueries(),
            'Should not exceed SOQL query limit');
    }
    
    /**
     * Test with null or empty collections
     * Ensures handler doesn't break with edge cases
     */
    @IsTest
    static void testWithEmptyCollection() {
        Test.startTest();
        
        // TODO: Call handler methods with empty lists
        // OpportunityTriggerHandler handler = new OpportunityTriggerHandler();
        // handler.beforeInsert(new List<Opportunity>());
        
        Test.stopTest();
        
        // If we get here without exception, test passes
        System.Assert.isTrue(true, 'Handler should handle empty collections gracefully');
    }
    
    /**
     * Helper method to create test data inline
     * Use when @TestSetup is not sufficient
     */
    private static List<Opportunity> createTestOpportunities(Integer count) {
        List<Opportunity> testOpps = new List<Opportunity>();
        
        for (Integer i = 0; i < count; i++) {
            testOpps.add(new Opportunity(
                Name = 'Test Opp ' + i,
                StageName = 'Prospecting',
                CloseDate = Date.today().addDays(30),
                Amount = 10000
            ));
        }
        
        return testOpps;
    }
    
    /**
     * Helper method to assert task creation
     */
    private static void assertTasksCreated(List<Id> oppIds, Integer expectedCount, String subject) {
        List<Task> tasks = [
            SELECT Id, Subject, WhatId
            FROM Task
            WHERE WhatId IN :oppIds
        ];
        
        System.Assert.areEqual(expectedCount, tasks.size(),
            'Should create ' + expectedCount + ' task(s)');
        
        if (expectedCount > 0) {
            System.Assert.areEqual(subject, tasks[0].Subject,
                'Task subject should match');
        }
    }
}

#!/usr/bin/env python3
"""
Analyze Salesforce Apex triggers for common anti-patterns.

Usage:
    python analyze_trigger.py <TriggerName>

Requirements:
    - Salesforce CLI authenticated to target org
    - Python 3.9+
"""

import sys
import subprocess
import json
import re
from typing import List, Dict, Tuple

class TriggerAnalyzer:
    def __init__(self, trigger_name: str):
        self.trigger_name = trigger_name
        self.trigger_body = ""
        self.issues = {
            'dml_in_loops': [],
            'soql_in_loops': [],
            'missing_bulk': [],
        }
        self.complexity_score = 0
        
    def retrieve_trigger(self) -> bool:
        """Retrieve trigger source code from Salesforce org."""
        try:
            cmd = [
                'sf', 'apex', 'get', 'trigger',
                '--trigger-name', self.trigger_name,
                '--json'
            ]
            result = subprocess.run(cmd, capture_output=True, text=True)
            
            if result.returncode != 0:
                print(f"Error retrieving trigger: {result.stderr}")
                return False
                
            data = json.loads(result.stdout)
            self.trigger_body = data.get('result', {}).get('body', '')
            return True
            
        except Exception as e:
            print(f"Failed to retrieve trigger: {e}")
            return False
    
    def analyze_dml_in_loops(self) -> None:
        """Detect DML operations inside for loops."""
        lines = self.trigger_body.split('\n')
        in_loop = False
        loop_start = 0
        
        dml_patterns = [
            r'\binsert\s+', r'\bupdate\s+', r'\bdelete\s+',
            r'\bundelete\s+', r'\bupsert\s+'
        ]
        
        for i, line in enumerate(lines, 1):
            # Track loop entry
            if re.search(r'\bfor\s*\(', line):
                in_loop = True
                loop_start = i
                
            # Track loop exit
            if in_loop and line.strip() == '}':
                # Check if this closes the loop (simplified heuristic)
                in_loop = False
                
            # Check for DML in loop
            if in_loop:
                for pattern in dml_patterns:
                    if re.search(pattern, line):
                        self.issues['dml_in_loops'].append({
                            'line': i,
                            'code': line.strip(),
                            'loop_start': loop_start
                        })
    
    def analyze_soql_in_loops(self) -> None:
        """Detect SOQL queries inside for loops."""
        lines = self.trigger_body.split('\n')
        in_loop = False
        loop_start = 0
        
        soql_pattern = r'\[SELECT\s+'
        
        for i, line in enumerate(lines, 1):
            if re.search(r'\bfor\s*\(', line):
                in_loop = True
                loop_start = i
                
            if in_loop and line.strip() == '}':
                in_loop = False
                
            if in_loop and re.search(soql_pattern, line, re.IGNORECASE):
                self.issues['soql_in_loops'].append({
                    'line': i,
                    'code': line.strip(),
                    'loop_start': loop_start
                })
    
    def analyze_bulkification(self) -> None:
        """Check for proper bulkification patterns."""
        # Simple heuristic: if we have DML in loops, bulkification is missing
        if self.issues['dml_in_loops']:
            self.issues['missing_bulk'].append({
                'message': 'DML operations should be collected and executed outside loops',
                'affected_lines': [issue['line'] for issue in self.issues['dml_in_loops']]
            })
            
        if self.issues['soql_in_loops']:
            self.issues['missing_bulk'].append({
                'message': 'SOQL queries should be moved outside loops or use Maps for lookups',
                'affected_lines': [issue['line'] for issue in self.issues['soql_in_loops']]
            })
    
    def calculate_complexity(self) -> None:
        """Calculate overall complexity score (1-10)."""
        score = 1
        
        # Add points for each issue type
        score += len(self.issues['dml_in_loops']) * 2
        score += len(self.issues['soql_in_loops']) * 2
        score += len(self.issues['missing_bulk']) * 1
        
        # Count trigger contexts
        contexts = len(re.findall(r'Trigger\.(isBefore|isAfter)', self.trigger_body))
        score += contexts
        
        # Count lines of code (normalized)
        loc = len([l for l in self.trigger_body.split('\n') if l.strip()])
        score += min(loc // 10, 3)
        
        self.complexity_score = min(score, 10)
    
    def recommend_approach(self) -> str:
        """Recommend refactoring approach based on analysis."""
        if self.complexity_score <= 3:
            return "Simple handler class with separate methods for each trigger context"
        elif self.complexity_score <= 6:
            return "Handler class with bulkified collections and helper methods"
        else:
            return "Unified handler framework with separate concern classes (validation, DML, etc.)"
    
    def generate_report(self) -> None:
        """Print analysis report."""
        print("\n" + "="*70)
        print(f"TRIGGER ANALYSIS REPORT: {self.trigger_name}")
        print("="*70 + "\n")
        
        print(f"Complexity Score: {self.complexity_score}/10")
        print(f"Recommended Approach: {self.recommend_approach()}\n")
        
        # DML in loops
        if self.issues['dml_in_loops']:
            print("⚠️  DML OPERATIONS IN LOOPS:")
            for issue in self.issues['dml_in_loops']:
                print(f"   Line {issue['line']}: {issue['code']}")
                print(f"   └─ Loop started at line {issue['loop_start']}")
            print()
        else:
            print("✓ No DML operations found in loops\n")
        
        # SOQL in loops
        if self.issues['soql_in_loops']:
            print("⚠️  SOQL QUERIES IN LOOPS:")
            for issue in self.issues['soql_in_loops']:
                print(f"   Line {issue['line']}: {issue['code']}")
                print(f"   └─ Loop started at line {issue['loop_start']}")
            print()
        else:
            print("✓ No SOQL queries found in loops\n")
        
        # Bulkification
        if self.issues['missing_bulk']:
            print("⚠️  BULKIFICATION RECOMMENDATIONS:")
            for issue in self.issues['missing_bulk']:
                print(f"   • {issue['message']}")
                print(f"     Affected lines: {', '.join(map(str, issue['affected_lines']))}")
            print()
        else:
            print("✓ Bulkification patterns look good\n")
        
        print("="*70)
        print("NEXT STEPS:")
        print("1. Review the handler patterns reference guide")
        print("2. Create handler class with bulk-safe collections")
        print("3. Extract trigger logic into handler methods")
        print("4. Generate comprehensive tests using the template")
        print("="*70 + "\n")


def main():
    if len(sys.argv) < 2:
        print("Usage: python analyze_trigger.py <TriggerName>")
        sys.exit(1)
    
    trigger_name = sys.argv[1]
    
    print(f"Analyzing trigger: {trigger_name}...")
    
    analyzer = TriggerAnalyzer(trigger_name)
    
    # For demo purposes, use inline example if retrieval fails
    if not analyzer.retrieve_trigger():
        print("⚠️  Could not retrieve from org. Using example trigger for demonstration.\n")
        # Use the example from the SKILL.md
        analyzer.trigger_body = """trigger OpportunityTrigger on Opportunity (before insert, before update, after update) {
    if (Trigger.isBefore && Trigger.isInsert) {
        for (Opportunity o : Trigger.new) {
            if (o.StageName == 'Closed Won' && (o.Amount == null || o.Amount < 1000)) {
                o.addError('Closed Won opportunities must have Amount ≥ 1000.');
            }
        }
    }
    if (Trigger.isBefore && Trigger.isUpdate) {
        for (Opportunity o : Trigger.new) {
            Opportunity oldO = Trigger.oldMap.get(o.Id);
            if (o.StageName != oldO.StageName) {
                o.Description = 'Stage changed from ' + oldO.StageName + ' to ' + o.StageName;
            }
        }
    }
    if (Trigger.isAfter && Trigger.isUpdate) {
        for (Opportunity o : Trigger.new) {
            Opportunity oldO = Trigger.oldMap.get(o.Id);
            if (o.StageName == 'Closed Won' && oldO.StageName != 'Closed Won') {
                Task t = new Task(
                    WhatId = o.Id,
                    OwnerId = o.OwnerId,
                    Subject = 'Send thank-you',
                    Status = 'Not Started',
                    Priority = 'Normal',
                    ActivityDate = Date.today()
                );
                insert t;
            }
        }
    }
}"""
    
    # Run analysis
    analyzer.analyze_dml_in_loops()
    analyzer.analyze_soql_in_loops()
    analyzer.analyze_bulkification()
    analyzer.calculate_complexity()
    
    # Generate report
    analyzer.generate_report()


if __name__ == '__main__':
    main()